Bonjour ,je travail sur un projet qui assure un jeu entre deux joueurs, le probleme est que le joueur 1 par exemple est toujours celui qui commence la partie mais je veux que chaque partie un joueur qui commence (cad partie 1 j1 commence ,partie 2 j2 commence ....)

Salut,

J'suis pas très fort en java,

mais je pense que pour faire sa tu peux simplement faire sa avec un bool : voici un exemple que je t'ai fais, j'espère que sa t'aidera :

import java.util.*;

public class tour_chacun
{
	public static void main (String [] arg)
	{
		boolean test = true; //On initialise a vrai
		int nombre_de_partie = 10;
		
		for (int i=0; i<= nombre_de_partie; i++)
		{
			if (test == true)//si c'est vrai
			{
				System.out.println("Partie "+i+": Joueur 1"); // le joueur 1 commence
				test = false; //on met maintenant a faux pour qu'a la partie d'après sa rentre dans le else 
			}
			else
			{
				System.out.println("Partie "+i+": Joueur 2"); // le joueur 2 prendra la 2eme parti
				test = true;// et meme systeme, on met a vrai pour que la partie d'apres commence pour le joueur 1
			}		
		}
	}
}

et la sortie en console est celle ci :

J'espère t'avoir aidé ;) 

Bonne chance pour ton projet

merci pour votre reponse , j'ai pensé à une solution pareille mais le probleme est que je dois copier le meme  code lorsque joueur 1 joue et lorsque joueur 2 joue ,ça devrait fonctionner mais j'ai dit que c'est pas bien de faire copier le meme code dans 2 if

Salut !

Tu n'as qu'à utiliser une fonction :

private static void afficherPartie(int numeroPartie, short numeroJoueur) { // public si cette fonction doit être appelée hors de cette classe et ne mets pas static si elle doit être utilisée sur un objet précisément.
    System.out.println("Partie " + numeroPartie + " : Joueur " + numeroJoueur);
}

Et le tour est joué.

Complètement d'accord avec la réponse de Detork,

Utilise une fonction.

En reprenant mon code + celui de Detork cela donne sa :

import java.util.*;

public class tour_chacun
{
	public static void afficherPartie(int numPartie, short numJoueur)
	{
		System.out.println("Partie "+numPartie+": Joueur :"+numJoueur);
		//rajoute ton code ici !
	}
	
	public static void main (String [] arg)
	{	
		short joueur=1; //Joueur 1 commence tout le temps premier
		int nombre_de_partie = 10;
		
		for (int i=0; i<= nombre_de_partie; i++)
		{
			if (joueur==1)// joueur 1
			{
				afficherPartie(i,joueur);
				joueur=2;
			}
			else //joueur 2
			{
				afficherPartie(i,joueur);
				joueur=1;				
			}		
		}
	}
}

Je pense que ça marche

Bonne continuation

-
Edité par Flyzerd 20 octobre 2016 à 23:04:27

import java.util.*;
 
public class tour_chacun
{
    public static void afficherPartie(int numPartie, short numJoueur)
    {
        System.out.println("Partie "+numPartie+": Joueur :"+numJoueur);
        //rajoute ton code ici !
    }
     
    public static void main (String [] arg)
    {  
        int nombre_de_partie = 10;
         
        for (int i=0; i<= nombre_de_partie; i++)
        {
            afficherPartie(i, 1 + (i % 2));
        }
    }
}

Un modulo permet de rendre le code plus concis, et d'obtenir directement une alternance de joueur sans logique autre que mathématique

Ouais c'est bien mais imaginons (et là je pense être un peu paranoïaque) que l'utilisateur fasse monter la variable i jusqu'à ce qu'elle dépasse les limites de int ?

Avec ma solution de Flyzerd, il pourrait déclarer i en tant que short et la variable i ne serait jamais trop grande.

S'il pense dépasser les limites d'un integer il peut utiliser un long, puisque son numéro de partie serait invalide autrement. 

Pour le numéro de joueur, même si on dépasse la limite du int, on aura toujours la bonne alternance de joueurs en utilisant un modulus plutôt qu'un modulo sur i. 

S'il est un grand joueur et que quelques milliards de parties ne lui suffisent pas, il peut toujours utiliser un long pour pouvoir jouer 9223372036854775807 fois (max. val. long). Espérons que ses joueurs soient toujours en vie pour terminer la partie !

Oui je suis paranoïaque, je sais.

Mais je pense qu'il vaut mieux au moins prévoir au cas où d'au moins vérifier si la variable n'est pas trop grande.