ajout du combat

app/src/main/java/com/iutlaval/myapplication/Game/Board.java

@@ -1,6 +1,7 @@
 package com.iutlaval.myapplication.Game;
 
 import com.iutlaval.myapplication.Game.Cards.Card;
+import com.iutlaval.myapplication.Video.Drawables.DrawableCard;
 
 /**
  * cette classe contrain toutes les cartes sur le terrain cela permet de garder une copie qui sera utilisé pour l'affichage
@@ -20,6 +21,40 @@ public class Board {
         return playerCardsOnBoard;
     }
 
+    public int getCardZone(DrawableCard drawableCard)
+    {
+        return getCardZone(drawableCard.getCard());
+    }
+
+    public int getCardZone(Card card)
+    {
+        int index=0;
+        for(Card c : playerCardsOnBoard)
+        {
+            //si c'est la meme instance de la carte
+            // /!\ ne pas mettre un equals ce n'est pas une erreur je test l'instance et non la similarité
+            if(c == card)
+            {
+                return index;
+            }
+            index++;
+        }
+        return -1;
+    }
+
+    public Card removeCardOnPlayerBoard(int zone)
+    {
+        Card c = playerCardsOnBoard[zone];
+        playerCardsOnBoard[zone] = null;
+        return c;
+    }
+
+    public Card removeCardOnEnemyPlayerBoard(int zone) {
+        Card c = advCardsOnBoard[zone];
+        advCardsOnBoard[zone] = null;
+        return c;
+    }
+
     public void setCard(int index, Card c)
     {
         playerCardsOnBoard[index]=c;
@@ -30,4 +65,7 @@ public class Board {
         advCardsOnBoard[index]=c;
     }
 
+    public Card[] getAdvCardsOnBoard() {
+        return advCardsOnBoard;
+    }
 }

app/src/main/java/com/iutlaval/myapplication/Game/Command.java

@@ -10,7 +10,7 @@ public final class Command {
     public static final String PUT_CARD = "putCard"; // place une carte
     public static final String PUT_ENEMY_CARD = "enemycard"; // place une carte sur le terrain adverse
     public static final String PASS_TURN = "passTurn"; // passe son tours
-    public static final String POPUP = "pupup"; // affiche un messsage
+    public static final String POPUP = "popup"; // affiche un messsage
     public static final String ENEMYTURN = "enemyTurn"; // tours enemy
     public static final String SETMANA = "setmana"; // defini la mana
     public static final String WIN = "win"; // gagne
@@ -21,12 +21,14 @@ public final class Command {
     public static final String OK = "ok"; // accepte une actoin
     public static final String MEULE = "meule"; // fait pioché mais n'ajoute pas a la main la carte sera donc perdu
     public static final String UPDATE = "update";//fonction client uniquement a utilisé avec le serveur de débugage permet de mettre a jour l'écrans
+    public static final String ATTACK = "attack"; // dit au server qu'une attaque est lancé
+    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";
 
 
     //inutilisé
-    public static final String SHUFFLE_DECK = "shuffleDeck";
     public static final String SELECT_CARD = "selectCard";
-    public static final String ATTACK = "attack";
     public static final String DEFEND = "defend";
     public static final String CAST_SPELL = "castSpell";
 

app/src/main/java/com/iutlaval/myapplication/Game/GameLogicThread.java

@@ -43,7 +43,8 @@ public class GameLogicThread extends Thread{
     private NetworkDeck deck;
     private Hand hand;
     private Board board;
-    private boolean isYourTurn;
+    private boolean isYourMainPhase;
+    private boolean isYourBattlePhase;
     private boolean cancelled;
     private String deckName;
     private int mana=0;
@@ -51,9 +52,12 @@ public class GameLogicThread extends Thread{
 
 
     //ces variable permette la comunication avec le thread android du tactile et le reseau en passant par ce thread
+    //cette variable controle la demande de gestion de placement de carte
     private boolean requestPlaceCardDone =true;
-    private DrawableCard requestPlaceCardCard =null;
+    //cette variable controle la demande de gestion de l'attaque
-    private int requestPlaceCardZone =-1;
+    boolean requestAttackDone = true;
+    private DrawableCard requestDrawableCard =null;
+    private int requestCardZone =-1;
     private boolean requestPlaceCardResult;
 
     //si mise a true alors le thread va envoyer un message au serveur lui disant de passer a la phase suivante
@@ -71,8 +75,9 @@ public class GameLogicThread extends Thread{
         hand = new Hand();
         this.gameActivity=gameActivity;
         GameActivity.setGameEngine(this);
-        isYourTurn=false;
+        isYourMainPhase =false;
         cancelled=false;
+        isYourBattlePhase=false;
     }
 
     @Override
@@ -91,8 +96,8 @@ public class GameLogicThread extends Thread{
         //Rectangle pos = new Rectangle(0F,0F,100F,100F);
         ready=true;
 
-        final String host = "0.tcp.ngrok.io";//192.168.43.251tcp://2.tcp.ngrok.io:
+        final String host = "2.tcp.ngrok.io";//192.168.43.251tcp://2.tcp.ngrok.io:
-        final int port = 13562;
+        final int port = 13450;
 
         try {
             Socket client = new Socket(host, port);
@@ -108,18 +113,32 @@ public class GameLogicThread extends Thread{
         //si quelquechose se passe alors c'est le server qu'il l'a dit
         while(ready && !cancelled)
         {
-            if(!requestPlaceCardDone && requestPlaceCardZone != -1 && requestPlaceCardCard != null)
+            if(!requestPlaceCardDone && requestCardZone != -1 && requestDrawableCard != null)
             {
                 try {//on allonge le delais car sinon on skip l'autorisation serveur
                     coms.setUnlimitedTimeOut();
                 } catch (SocketException e) {}
-                requestPlaceCardResult = onCardPlayed(requestPlaceCardCard, requestPlaceCardZone);
+                requestPlaceCardResult = onCardPlayed(requestDrawableCard, requestCardZone);
-                requestPlaceCardZone =-1;
+                requestCardZone =-1;
-                requestPlaceCardCard =null;
+                requestDrawableCard =null;
                 Log.e("request","done");
                 requestPlaceCardDone =true;
             }
 
+            if(!requestAttackDone && requestCardZone != -1 && requestDrawableCard != null)
+            {
+                int zoneAttaquant = board.getCardZone(requestDrawableCard);
+
+                try {
+                    coms.send(Command.ATTACK);
+                    coms.send(zoneAttaquant);
+                    coms.send(requestCardZone);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                requestAttackDone=true;
+            }
+
             if(requestEnd)
             {
                 try {
@@ -129,9 +148,12 @@ public class GameLogicThread extends Thread{
                     e.printStackTrace();
                 }
                 requestEnd=false;
+                isYourBattlePhase=false;
             }
 
 
+
+
             try {
                 //on limite le temps du readobject pour eviter les blockaeg
                 coms.setLimitedTimeOut();
@@ -154,7 +176,8 @@ public class GameLogicThread extends Thread{
                         break;
 
                     case Command.YOURTURN:
-                        isYourTurn=true;
+                        isYourMainPhase =true;
+                        isYourBattlePhase=false;
                         renderer.addToDraw(new DrawableSelfRemoving(new DrawableBitmap(bitmapYourTurn,0,0,"yourTurn",100F,50F),1));
                         renderer.addToDraw(new DrawableBitmap(bitmapButtonEnd, BUTTON_X_POS, BUTTON_Y_POS, BUTTONTURN_DRAWABLE_NAME, BUTTON_X_SIZE, BUTTON_Y_SIZE));
                         break;
@@ -166,7 +189,7 @@ public class GameLogicThread extends Thread{
                         break;
 
                     case Command.ENEMYTURN:
-                        isYourTurn=false;
+                        isYourMainPhase =false;
 
                         //on update pas vu que l'instruction suivante va le faire
                         renderer.removeToDrawWithoutUpdate(BUTTONTURN_DRAWABLE_NAME);
@@ -217,10 +240,11 @@ public class GameLogicThread extends Thread{
                         cardPlayed.getDrawableCard().setOnBoard(true);
 
                         //ajout de la carte au rendu
-                        cardPlayed.getDrawableCard().setCoordinates(((DrawableCard.getCardWith()+1)*zone+DrawableCard.getCardWith()),10F);
+                        cardPlayed.getDrawableCard().setCoordinates(((DrawableCard.getCardWith()+1)*zone+20),10F);
                         renderer.addToDraw(cardPlayed.getDrawableCard());
 
                         //ajout la card au terain
+                        cardPlayed.getDrawableCard().setDraggable(false);
                         board.setEnemyCard(zone,cardPlayed);
                         break;
 
@@ -230,6 +254,25 @@ public class GameLogicThread extends Thread{
                         int nbmeule = coms.recieveInt();
                         deck.draw(nbmeule);
 
+                    case Command.BATTLE:
+                        isYourBattlePhase=true;
+                        isYourMainPhase=false;
+                        break;
+
+                    case Command.DESTROY_CARD:
+                        //detruit la carte sur le terrain du joueur
+                        int zoneOfTheDestroyedCard = coms.recieveInt();
+                        Card cardToDestroy = board.removeCardOnPlayerBoard(zoneOfTheDestroyedCard);
+                        renderer.removeToDraw(cardToDestroy);
+                        break;
+
+                    case Command.DESTROY_ADV_CARD:
+                        //detruit la carte sur le terrain du joueur adverse
+                        int zoneOfTheDestroyedEnemyCard = coms.recieveInt();
+                        Card enemyCardToDestroy = board.removeCardOnEnemyPlayerBoard(zoneOfTheDestroyedEnemyCard);
+                        renderer.removeToDraw(enemyCardToDestroy);
+                        break;
+
                     case "timeout":
                         //ceci est une erreur et non une commande elle se doit donc de ne rien faire
                         break;
@@ -284,7 +327,7 @@ public class GameLogicThread extends Thread{
      */
     private boolean onCardPlayed(DrawableCard card,int zone)
     {
-        if(isYourTurn)
+        if(isYourMainPhase)
         {
             try {
                 //on veut jouer une carte
@@ -318,8 +361,8 @@ public class GameLogicThread extends Thread{
         //on ne peut pas avoir 2 requette simultané
         if(!requestPlaceCardDone)return false;
 
-        this.requestPlaceCardCard =card;
+        this.requestDrawableCard =card;
-        this.requestPlaceCardZone =zone;
+        this.requestCardZone =zone;
         requestPlaceCardDone =false;
 
         //on attends la fin de la requette
@@ -333,6 +376,38 @@ public class GameLogicThread extends Thread{
         return requestPlaceCardResult;
     }
 
+    public synchronized boolean setOnCardAttackRequest(DrawableCard card, int zoneCible) {
+        if(board.getAdvCardsOnBoard()[zoneCible] == null
+        || card.getCard().getAttack() == 0)
+        {
+            return false;
+        }
+
+
+        //on ne peut pas avoir 2 requette simultané
+        while(!requestAttackDone) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        this.requestCardZone =zoneCible;
+        this.requestDrawableCard=card;
+        requestAttackDone =false;
+
+        //on attends la fin de la requette
+        while(!requestAttackDone) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return true;
+    }
+
     /**
      * cette fonction est appeller a chaque fin de frame
      * CETTE FONCTION A UN IMPACT DIRECT SUR LES FPS ELLE SE DOIT D'être OPTIMAL
@@ -364,8 +439,8 @@ public class GameLogicThread extends Thread{
         if(isReady())touch.onTouchEvent(event);
     }
 
-    public boolean isYourTurn() {
+    public boolean isYourMainPhase() {
-        return isYourTurn;
+        return isYourMainPhase;
     }
 
 
@@ -388,7 +463,7 @@ public class GameLogicThread extends Thread{
     }
 
     public void requestEndTurn() {
-        if(isYourTurn)
+        if(isYourMainPhase || isYourBattlePhase)
         {
             requestEnd=true;
         }else{
@@ -398,4 +473,10 @@ public class GameLogicThread extends Thread{
             t.show();
         }
     }
+
+    public boolean isYourBattlePhase() {
+        return isYourBattlePhase;
+    }
+
+
 }

app/src/main/java/com/iutlaval/myapplication/Game/PlayableZonesHandler.java

@@ -95,11 +95,35 @@ public class PlayableZonesHandler {
             if(cardX > card.getX() && card.getY() < 75F/*90F orrigine */ && card.getY() > 50F)
             {
                 //on a trouvé l'emplacement de la carte
+                //si il y a une carte a l'emplacement on retourne le numero
                 if(board.getPlayerCardsOnBoard()[i] == null)return i;
                 else break;
             }
         }
-
         return -1;
     }
+
+    /**
+     * retourne le numero de la zone survolé par le drawable si la zone est vite
+     * sinon retourne -1
+     * @param card
+     * @return
+     */
+    public int getEnemyHoveredZone(Drawable card) {
+        for(int i=0 ; i< board.MAX_CARD_ON_BOARD;i++)
+        {
+            int cardX =(DrawableCard.getCardWith()+1)*i + 20;
+            //es que on survole sur l'axe x
+            if(cardX > card.getX() && card.getY() < 50F)
+            {
+                //on a trouvé l'emplacement de la carte
+                //si il y a une carte a l'emplacement on retourne le numero
+                if(board.getPlayerCardsOnBoard()[i] == null)return i;
+                else break;
+            }
+        }
+        return -1;
+    }
+
+    //cardPlayed.getDrawableCard().setCoordinates(((DrawableCard.getCardWith()+1)*zone+DrawableCard.getCardWith()),10F);
 }

app/src/main/java/com/iutlaval/myapplication/Game/TouchHandler.java

@@ -54,14 +54,21 @@ public class TouchHandler {
             handSelectionHandler(event);
             //afficher grosse carte
             bigCardHandler(event);
-            if(gameLogic.isYourTurn())
+            if(gameLogic.isYourMainPhase() && ! gameLogic.isYourBattlePhase())
             {
-                //selectionne la carte
+                //selectionne la carte dans la main
-                dragAndDropHandler(event);
+                dragAndDropHandler(event,false);
                 //affiche les zones de jeu
                 playCard(event);
 
             }
+            if(gameLogic.isYourBattlePhase() && ! gameLogic.isYourMainPhase())
+            {
+                //selectionne la carte sur le terrain
+                dragAndDropHandler(event,true);
+
+                attackHandler(event);
+            }
         }
     }
 
@@ -69,7 +76,7 @@ public class TouchHandler {
      * gére le drag and drop de carte
      * @param event
      */
-    private void dragAndDropHandler(MotionEvent event)
+    private void dragAndDropHandler(MotionEvent event,boolean isBattleTurn)
     {
         //on calcul les coordonées en % de l'écran
 
@@ -80,6 +87,11 @@ public class TouchHandler {
 
             if(dragAndDropCard != null && !dragAndDropCard.isDraggable()) dragAndDropCard = null;
 
+            //si la carte est dans la main durant la phase de combat on ne la prend pas
+            //if(dragAndDropCard != null && isBattleTurn && !dragAndDropCard.isOnBoard())dragAndDropCard = null;
+            //si la carte est sur le terrain durant la phase principale on ne la prends pas
+            if(dragAndDropCard != null && !isBattleTurn && dragAndDropCard.isOnBoard())dragAndDropCard = null;
+
             if (dragAndDropCard != null) {
                 //on calcul la position par raport au doigt de l'utilisateur
                 TouchDeltaY = unScalled_Y - dragAndDropCard.getY();
@@ -119,6 +131,7 @@ public class TouchHandler {
                 DrawableCard bigCard = new DrawableCard(smallCArd,context,2);
                 renderer.addToDraw(bigCard);
                 bigCard.setCoordinates(72F,10F);
+                bigCard.setDraggable(false);
                 //on sélectionne si elle est dans notre main(déplacer la care vers le haut de quelque pixel)
 
             //si on lache la carte
@@ -153,7 +166,6 @@ public class TouchHandler {
                 {
                     dragAndDropCard.setOnBoard(true);
                     dragAndDropCard.setCoordinates((DrawableCard.getCardWith()+1)*zone,55F);
-                    dragAndDropCard.setDraggable(false);
                 }else{
                     if(dragAndDropCard != null)renderer.moveToDraw(originalPositionX,originalPositionY, dragAndDropCard.getName());
                 }
@@ -177,7 +189,7 @@ public class TouchHandler {
                 renderer.updateFrame();
             }
 
-            if(unScalled_Y > 90F && smallCArd !=null && smallCArd.isDraggable() && !smallCArd.isOnBoard() && (cardSeletedInHand == null || !cardSeletedInHand.equals(smallCArd)))
+            if(unScalled_Y > 90F && smallCArd !=null  && !smallCArd.isOnBoard() && (cardSeletedInHand == null || !cardSeletedInHand.equals(smallCArd)))
             {
                 smallCArd.setCoordinates(smallCArd.getX(),smallCArd.getY() - SELECTING_OFFSET);
                 cardSeletedInHand=smallCArd;
@@ -202,4 +214,19 @@ public class TouchHandler {
             gameLogic.requestEndTurn();
         }
     }
+
+    private void attackHandler(MotionEvent event)
+    {
+        if(dragAndDropCard != null){
+            if(event.getAction() == MotionEvent.ACTION_UP) {
+                int zone = playableZonesHandler.getEnemyHoveredZone(dragAndDropCard);
+                if(zone != -1)
+                {
+                    gameLogic.setOnCardAttackRequest(dragAndDropCard,zone);
+                }
+                renderer.moveToDraw(originalPositionX,originalPositionY, dragAndDropCard.getName());
+                playableZonesHandler.hidePlayableZones(renderer);
+            }
+        }
+    }
 }

app/src/main/java/com/iutlaval/myapplication/Video/Drawables/Drawable.java

@@ -104,8 +104,10 @@ public abstract class Drawable {
         return false;
     }
 
+
     protected void setBitmap(Bitmap bitmap)
     {
         this.bitmap=bitmap;
     }
+
 }

app/src/main/java/com/iutlaval/myapplication/Video/Drawables/DrawableCard.java

@@ -343,14 +343,15 @@ public class DrawableCard extends Drawable{
         return draggable;
     }
 
+    public void setDraggable(boolean b) {
+        this.draggable=b;
+    }
+
     public boolean isOnBoard()
     {
         return onBoard;
     }
 
-    public void setDraggable(Boolean draggable) {
-        this.draggable = draggable;
-    }
 
     public Card getCard() {
         return card;

app/src/main/java/com/iutlaval/myapplication/Video/Renderer.java

@@ -11,6 +11,7 @@ import android.view.SurfaceView;
 
 import androidx.annotation.NonNull;
 
+import com.iutlaval.myapplication.Game.Cards.Card;
 import com.iutlaval.myapplication.Game.GameLogicThread;
 import com.iutlaval.myapplication.GameActivity;
 import com.iutlaval.myapplication.Video.Drawables.Drawable;
@@ -125,6 +126,8 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
         needToUpdate =true;
     }
 
+
+
     /**
      * main drawing thread render each frame
      */
@@ -269,6 +272,15 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
         removeToDrawWithoutUpdate(name);
         updateFrame();
     }
+
+    /**
+     * supprime le toDraw du drawable associé a la carte
+     * @param cardToDestroy
+     */
+    public void removeToDraw(Card cardToDestroy) {
+        removeToDraw(cardToDestroy.getDrawableCard());
+    }
+
     /**
      * remove the element from the draw list
      * @param toRemove the element toRemove