ajout mana + patch defait/victoire + resilience en anti crash

src/game/Board.java

@@ -28,14 +28,4 @@ public class Board {
 		return board[zone];
 	}
 
-	public void printDebugBoard() {
-		for(Card c : board)
-		{
-			if(c == null) System.out.print("X");
-			else System.out.print("O");
-		}
-		System.out.println();
-		
-	}
-
 }

src/game/Command.java

@@ -26,10 +26,6 @@ public final class Command {
     public static final String DESTROY_CARD = "destroyself"; //demande au clien de retirer une carte du terrain
     public static final String DESTROY_ADV_CARD = "destroyadv"; //demande au client de retirer une carte adverse du terrain
 	public static final String BATTLE = "battlephase";
-
+    public static final String SET_ENEMY_HP = "setenemhp";
-
+	public static final String SET_HP = "sethp";
-    //inutilisé
-    public static final String SELECT_CARD = "selectCard";
-    public static final String DEFEND = "defend";
-    public static final String CAST_SPELL = "castSpell";
 }

src/game/Joueur.java

@@ -13,10 +13,11 @@ public class Joueur {
 	private Hand hand;
 	private Board board;
 	private int pV;
+	// la quantité maximum de mana elle augment de 1 par tours
 	private int currentMana = 0;
+	// la mana actuele du joueur
 	private int mana;
 
-	
 	public Joueur(ComsJoueur connectionJoueur) {
 		coms = connectionJoueur;
 		pV = 20;
@@ -25,6 +26,7 @@ public class Joueur {
 
 	/**
 	 * cette fonction permet d'obtenir le deck du joueur et de préparer la main
+	 * 
 	 * @throws IOException
 	 */
 	public void requestDataEarlyGameData() throws IOException {
@@ -35,16 +37,20 @@ public class Joueur {
 		hand = new Hand(deck);
 		coms.send(DeckSerializer.serializeDeck(deck));
 		draw(5);
+		coms.send(Command.SET_HP);
+		coms.send(pV);
+		coms.send(Command.SET_ENEMY_HP);
+		coms.send(pV);
 
 	}
 
 	/**
 	 * cette fonction permet de pioche une quantité donné
+	 * 
 	 * @param amount la quantié
 	 * @throws IOException
 	 */
-	public void draw(int amount) throws IOException
+	public void draw(int amount) throws IOException {
-	{
 		coms.send(Command.DRAW);
 		coms.send(amount);
 		hand.draw(amount);
@@ -52,6 +58,7 @@ public class Joueur {
 
 	/**
 	 * affiche sur l'ecran que c'est le tours de l'adversaire
+	 * 
 	 * @throws IOException
 	 */
 	public void debutTourEnemie() throws IOException {
@@ -60,6 +67,7 @@ public class Joueur {
 
 	/**
 	 * affiche un menu de victoire
+	 * 
 	 * @throws IOException
 	 */
 	public void win() throws IOException {
@@ -68,6 +76,7 @@ public class Joueur {
 
 	/**
 	 * affiche un menu de defaite
+	 * 
 	 * @throws IOException
 	 */
 	public void lose() throws IOException {
@@ -75,36 +84,40 @@ public class Joueur {
 	}
 
 	/**
-	 * cette commande doit être utilisé a chaque début de tour elle permet d'augmenter la mana du joueur
+	 * cette commande doit être utilisé a chaque début de tour elle permet
+	 * d'augmenter la mana du joueur
+	 * 
 	 * @throws IOException
 	 */
 	public void prepMana() throws IOException {
 		// on prepare la mana
-		if(currentMana < 10)currentMana++;
+		if (currentMana < 10)
+			currentMana++;
 		mana = currentMana;
 		coms.send(Command.SETMANA);
 		coms.send(mana);
 	}
 
-
 	/**
 	 * premiére phase de jeu avant d'attacker
+	 * 
 	 * @param adversaire
 	 * @param board
 	 * @throws IOException
 	 */
 	public void mainPhase1(Joueur adversaire) throws IOException {
 		boolean phaseActive = true;
-		//on retire le time out sur l'adversaire car sa peut causer des désyncronisatoin et des crash
+		// on retire le time out sur l'adversaire car sa peut causer des
+		// désyncronisatoin et des crash
 		adversaire.getComs().getSocket().setSoTimeout(Integer.MAX_VALUE);
 		// debut de l'écoude des action client
-		while(phaseActive)
+		int alive = 0;
-		{
+		while (phaseActive) {
 			coms.getSocket().setSoTimeout(500);
 			String command = coms.recieve();
 			coms.getSocket().setSoTimeout(Integer.MAX_VALUE);
-			if(command != null && !command.equals("time out"))
+			if (command != null && !command.equals("time out")) {
-			{
+				alive = 0;
 				System.out.println("GOT COMMAND :" + command);
 
 				switch (command) {
@@ -126,7 +139,19 @@ public class Joueur {
 					System.err.println("unknown command " + command);
 				}
 
+			} else {
+				alive++;
+				// 3000xalive =300s = 5minutes
+				// si au bout de 5 minute le client ne repond pas on envoie une erreur
+				if (alive > 300000) {
+					throw new IOException("dead client");
 				}
+				try {
+					Thread.sleep(100);
+				} catch (InterruptedException e) {
+				}
+			}
+
 		}
 	}
 
@@ -145,10 +170,8 @@ public class Joueur {
 			Class<? extends Card> cardClass = CardRegistery.get(cardId);
 			System.out.println(cardClass.getName());
 
-			
 			int zone = Integer.parseInt(coms.recieve());
 
-
 			Card handCard = hand.contains(cardClass);
 
 			// si la carte n'est pas trouve ou si elle coute trop cher
@@ -156,14 +179,16 @@ public class Joueur {
 				// on refuse le placement
 				System.out.println("no mana or no card");
 				coms.send(Command.NOK);
-			}
+			} else {
-			else {
+				if (board.isZoneAvaliable(zone)) {
-				if(board.isZoneAvaliable(zone))
-				{
 					hand.remove(handCard);
 					board.setCard(zone, handCard);
 					adversaire.enemyPlay(cardId, zone);
 					coms.send(Command.OK);
+
+					coms.send(Command.SETMANA);
+					mana -= handCard.getCost();
+					coms.send(mana);
 				} else {
 					System.out.println("the zone is not avaliable");
 					coms.send(Command.NOK);
@@ -179,6 +204,7 @@ public class Joueur {
 
 	/**
 	 * cette fonctoin est appelé affin de placer une carte sur le plateur énemie
+	 * 
 	 * @param cardId
 	 * @param zone
 	 * @throws IOException
@@ -204,29 +230,28 @@ public class Joueur {
 		this.pV = pV;
 	}
 
-	public boolean isDead()
+	public boolean isDead() {
-	{
 		return pV == 0;
 	}
 
-	public boolean isAlive()
+	public boolean isAlive() {
-	{
 		return !isDead();
 	}
 
 	/**
 	 * envoie le message donné qui aparaitera alors comme une toast
+	 * 
 	 * @param message
 	 * @throws IOException
 	 */
-	public void sendMessage(String message) throws IOException
+	public void sendMessage(String message) throws IOException {
-	{
 		coms.send(Command.POPUP);
 		coms.send(message);
 	}
 
 	/**
 	 * affiche le debut de tours
+	 * 
 	 * @throws IOException
 	 */
 	public void yourturn() throws IOException {
@@ -234,13 +259,13 @@ public class Joueur {
 		coms.send(Command.YOURTURN);
 	}
 
-
 	public boolean isHandFull() {
 		return hand.isFull();
 	}
 
 	/**
 	 * retire le nombre de carte donné du deck
+	 * 
 	 * @param nbcard nombre de carte a supprimé
 	 * @throws IOException
 	 */
@@ -250,8 +275,7 @@ public class Joueur {
 		deck.draw(1);
 	}
 
-	public void battlePhase(Joueur adversaire) throws IOException
+	public void battlePhase(Joueur adversaire) throws IOException {
-	{
 		coms.send(Command.BATTLE);
 
 		boolean phaseActive = true;
@@ -259,13 +283,11 @@ public class Joueur {
 		adversaire.getComs().getSocket().setSoTimeout(Integer.MAX_VALUE);
 		// debut de l'écoude des action client
 
-		while(phaseActive)
+		while (phaseActive) {
-		{
 			coms.getSocket().setSoTimeout(500);
 			String command = coms.recieve();
 			coms.getSocket().setSoTimeout(Integer.MAX_VALUE);
-			if(command != null && !command.equals("time out"))
+			if (command != null && !command.equals("time out")) {
-			{
 				System.out.println("GOT COMMAND :" + command);
 
 				switch (command) {
@@ -283,21 +305,61 @@ public class Joueur {
 					String carteAttaquante = coms.recieve();
 					// numero de la zone de la carte ciblé
 					String carteCible = coms.recieve();
-					if(!isInt(carteAttaquante) || !isInt(carteCible))throw new RuntimeException("non number zone recived in attack phase");
+					if (!isInt(carteAttaquante) || !isInt(carteCible))
+						throw new RuntimeException("non number zone recived in attack phase");
 					Card attackingCard = board.getCardInZone(Integer.parseInt(carteAttaquante));
-					Card attackedCard = adversaire.getBoard().getCardInZone(Integer.parseInt(carteCible));
 
-					if(attackedCard ==null || attackingCard == null)
+					if (attackingCard == null) {
+						throw new RuntimeException("invalid attack");
+					} else {
+						if (carteCible.equals("100")) {
+							boolean isadvDead = handleAttackAgainstPlayer(attackingCard, adversaire);
+							if(isadvDead)
 							{
-						board.printDebugBoard();
+								phaseActive = false;
-						throw new RuntimeException("error invalid  carteCible:"+carteCible + " carteAttaquante : "+carteAttaquante);
+							}
+						} else {
+							handleAttackAgainstCard(attackingCard, carteCible, adversaire);
+						}
+					}
+					break;
+
+				default:
+					System.err.println("unknown command " + command);
 				}
 
-					System.out.println("FIGHT " + "carteCible:"+carteCible + " carteAttaquante : "+carteAttaquante);
+			}
+		}
+	}
+
+	private boolean handleAttackAgainstPlayer(Card attackingCard, Joueur adversaire) throws IOException {
+		boolean result = adversaire.takeDamage(attackingCard.getAttack());
+		if(!result)
+		{
+			adversaire.updateHp(this);
+			return false;
+		}
+		return true;
+	}
+
+	private void updateHp(Joueur adversaire) throws IOException {
+		coms.send(Command.SET_HP);
+		coms.send(pV);
+		adversaire.coms.send(Command.SET_ENEMY_HP);
+		adversaire.coms.send(pV);
+		
+	}
+
+	private void handleAttackAgainstCard(Card attackingCard, String carteCible, Joueur adversaire) throws IOException {
+		Card attackedCard = adversaire.getBoard().getCardInZone(Integer.parseInt(carteCible));
+
+		if (attackedCard == null) {
+			throw new RuntimeException(
+					"error invalid  carteCible:" + carteCible + " carteAttaquante : " + attackingCard);
+		}
 
 		boolean isDestroyed = attackedCard.takeDamage(attackingCard.getAttack());
-					if(isDestroyed)
+		if (isDestroyed) {
-					{
 			// on suprime la carte du terrain
 			board.setCard(Integer.parseInt(carteCible), null);
 
@@ -313,17 +375,23 @@ public class Joueur {
 			// NOTE : non implémenter dans les cartes individuelles par manque de temps
 			attackedCard.onCardDestroyed();
 		}
-					break;
 
-				default:
-					System.err.println("unknown command "+command);
-				}
-				
-			}
-		}
 	}
 
 	private Board getBoard() {
 		return board;
 	}
+	
+	/**
+	 * inflige des degats au joueur
+	 * @param amount
+	 * @return true si les pv du joueur on attein zero
+	 */
+	private boolean takeDamage(int amount)
+	{
+		pV -= amount;
+		pV = pV > 0 ? pV : 0;
+		return pV == 0;
+		
+	}
 }

src/game/Match.java

@@ -30,30 +30,36 @@ public class Match extends Thread {
 	// gameplay
 	@Override
 	public void run() {
+		//cette variable permet de decider le gagnant en cas d'erreur reseau
+		boolean isJ1Turn=true;
 		while (joueur1.isAlive() &&  joueur2.isAlive()) {
 			try {
 				tour(joueur1);
-				tour(joueur2);
+				isJ1Turn=false;
+				if(joueur2.isAlive())tour(joueur2);
+				isJ1Turn=true;
 			} catch (IOException e) {
-				endGameAfterIssue();
+				endGameAfterIssue(isJ1Turn);
 				return;
 			}
 		}
 		try {
 			endMatch();
 		} catch (IOException e) {
-			endGameAfterIssue();
+			endGameAfterIssue(isJ1Turn);
 		}
 	}
 
 	/**
 	 * si le jeu a un crash il faut que si un joueur ai perdu la connection l'autre gagne
+	 * @param isJ1Turn 
 	 */
-	private void endGameAfterIssue() {
+	private void endGameAfterIssue(boolean isJ1Turn) {
 		if(PlayerTesteur.playerTest(joueur1.getComs()))
 		{
 			try {
-				joueur1.win();
+				if(isJ1Turn)joueur1.win();
+				else joueur1.lose();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
@@ -61,7 +67,8 @@ public class Match extends Thread {
 		if(PlayerTesteur.playerTest(joueur2.getComs()))
 		{
 			try {
-				joueur2.win();
+				if(!isJ1Turn)joueur2.win();
+				else joueur2.lose();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
@@ -114,7 +121,7 @@ public class Match extends Thread {
 		joueur.mainPhase1(enemy); //Joue autant de carte qu'il veut/peut
 		joueur.battlePhase(enemy);//lance des attaques à son adversaire qui peut répliquer
 		//cette phases ne serira surment pas car nous manquon de temps pour implrementer les fonctionnalité specifique de certaine cartes
-		joueur.endPhase();//fin du tour du @joueur
+		if(enemy.isAlive())joueur.endPhase();//fin du tour du @joueur
 	}
 
 }