mise a jour server + client + partiel tactile

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

@@ -0,0 +1,7 @@
+package com.iutlaval.myapplication.Game;
+
+public final class COMMAND {
+    public static final String YOURTURN="yourturn";
+    public static final String DRAW = "draw";
+    public static final String GET_DECK = "getDeck";
+}

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

@@ -14,6 +14,7 @@ import com.iutlaval.myapplication.GameActivity;
 import com.iutlaval.myapplication.R;
 import com.iutlaval.myapplication.Video.Drawables.DrawableBitmap;
 import com.iutlaval.myapplication.Video.Drawables.DrawableCard;
+import com.iutlaval.myapplication.Video.Drawables.DrawableSelfRemoving;
 import com.iutlaval.myapplication.Video.Renderer;
 
 import java.io.IOException;
@@ -32,9 +33,10 @@ public class GameLogicThread extends Thread{
     private Deck localPlayerDeck;
     private Hand localPlayerHand;
     private Board board;
-    private PlayableZonesHandler playableZonesHandler;
-    private DrawableCard currentlySelected = null;
-    private static final float SELECTING_OFFSET = 20F;
+
+
+
+    private boolean isYourTurn;
 
     public GameLogicThread(GameActivity gameActivity, Renderer renderer)
     {
@@ -43,26 +45,29 @@ public class GameLogicThread extends Thread{
         ready=false;
         this.cont = gameActivity;
         this.renderer = renderer;
-        touch = new TouchHandler(renderer);
+        touch = new TouchHandler(renderer,this,gameActivity);
         localPlayerHand = new Hand();
         this.gameActivity=gameActivity;
         board=new Board();
-        playableZonesHandler = new PlayableZonesHandler(board);
         GameActivity.setGameEngine(this);
+        isYourTurn=false;
     }
 
     @Override
     public void run() {
-        //affichage de l'arriere plan
+        //loading textures
+        Bitmap bitmapYourTurn = BitmapFactory.decodeResource(renderer.getResources(),R.drawable.t_pb_your_turn);
         Bitmap bitmap= BitmapFactory.decodeResource(cont.getResources(), R.drawable.t_b_board_background);
+
+        //adding the background
         renderer.addToDraw(new DrawableBitmap(bitmap, 0,0, "background", 100, 100 ));
         //drawHandPreview();
         //Rectangle pos = new Rectangle(0F,0F,100F,100F);
 
         //TODO : choix du deck avant de se co au serv
 
-        final String host = "4.tcp.ngrok.io";//192.168.43.251
-        final int port = 18567;
+        final String host = "4.tcp.ngrok.io";//192.168.43.251tcp://2.tcp.ngrok.io:
+        final int port = 17531;
         ObjectInputStream clientIn=null;
         ObjectOutputStream clientOut=null;
         try {
@@ -76,6 +81,8 @@ public class GameLogicThread extends Thread{
         }
         renderer.updateFrame();
 
+        //principe de fonctionnement : on attends une comande du server et on l'execute
+        //si quelquechose se passe alors c'est le server qu'il l'a dit
         ready=true;
         while(true)
         {
@@ -83,7 +90,7 @@ public class GameLogicThread extends Thread{
                 String serveurCmd = (String)clientIn.readObject();
                 switch (serveurCmd)
                 {
-                    case "getDeck":
+                    case COMMAND.GET_DECK:
                         //TODO get deck from player
                         clientOut.writeObject("deckDemo");
                         //TODO assing this deck
@@ -93,12 +100,19 @@ public class GameLogicThread extends Thread{
 
                         Log.e("recived","getdeck");
                         break;
-                    case "draw":
+                    case COMMAND.DRAW:
                         int nbcard = (Integer)clientIn.readObject();
                         localPlayerHand.pickCardFromDeck(localPlayerDeck,nbcard);
                         Log.e("picked",nbcard+"card");
                         drawHandPreview();
                         break;
+
+                    case COMMAND.YOURTURN:
+                        isYourTurn=true;
+                        renderer.addToDraw(new DrawableSelfRemoving(new DrawableBitmap(bitmapYourTurn,0,0,"yourTurn",100F,50F),1));
+                        break;
+                    default:
+                        Log.e("UNKOWN COMMAND",serveurCmd);
                 }
             } catch (Exception e) {
                 Log.e("ERROR DURING COMS","SERVER DIED");
@@ -145,61 +159,19 @@ public class GameLogicThread extends Thread{
     }
 
     /**
-     * relais l'evenement directement au touch Handler
+     * délegue l'evenement directement au touch Handler
      * @param event
      */
     public void onTouchEvent(MotionEvent event) {
-        if(isReady()){
-            //calcul y sur une echelle de 0 a 100
-            float scalled_Y = event.getY() / GameActivity.screenHeight * 100;
-            //si on clique sur une carte dans la main
-            if(event.getAction() == MotionEvent.ACTION_DOWN) {
-                float unscalled_X = event.getX() / GameActivity.screenWidth * 100;
-                DrawableCard smallCArd = renderer.getCardOn(unscalled_X,scalled_Y);
-                if(smallCArd !=null)
-                {
-                    renderer.removeToDrawWithoutUpdate(smallCArd);
-                    playableZonesHandler.displayPlayableZones(renderer);
-                    renderer.addToDraw(smallCArd);
-                    if(currentlySelected !=null)
-                    {
-                        currentlySelected.setCoordinates(currentlySelected.getX(),currentlySelected.getY() + SELECTING_OFFSET);
-                        //on update pas affin d'avoir un rendu plus fluide au moment de mettre l'aure carte
-                        renderer.removeToDrawWithoutUpdate(currentlySelected.getName()+"BIG");
-                    }
-                    currentlySelected = smallCArd;
-                    DrawableCard bigCard = new DrawableCard(smallCArd,cont,2);
-                    renderer.addToDraw(bigCard);
-                    bigCard.setCoordinates(72F,10F);
-                    smallCArd.setCoordinates(smallCArd.getX(),smallCArd.getY() - SELECTING_OFFSET);
-
-                }
-                touch.onTouchEvent(event);
-            }else if(event.getAction() == MotionEvent.ACTION_UP){
-                //currentlySelected.setCoordinates(currentlySelected.getX(),currentlySelected.getY() + SELECTING_OFFSET);
-                touch.onTouchEvent(event);
-                if(currentlySelected !=null)
-                {
-                    //jouer une carte
-                    int zone = playableZonesHandler.getHoveredZone(currentlySelected);
-                    if(zone != -1)
-                    {
-                        currentlySelected.setOnBoard(true);
-                        currentlySelected.setCoordinates((DrawableCard.getCardWith()+1)*zone,55F);
-                        currentlySelected.setDraggable(false);
-                    }else{
-                        currentlySelected.setCoordinates(currentlySelected.getX(),currentlySelected.getY() + SELECTING_OFFSET);
-                    }
-                    renderer.removeToDraw(currentlySelected.getName()+"BIG");
-                    currentlySelected=null;
-                }
-                playableZonesHandler.hidePlayableZones(renderer);
-            }else{
-                touch.onTouchEvent(event);
-            }
-        }
+        //if(isReady())touch.onTouchEvent(event);
+    }
 
+    public boolean isYourTurn() {
+        return isYourTurn;
     }
 
 
+    public Board getBoard() {
+        return board;
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.iutlaval.myapplication.Game;
 
+import android.content.Context;
 import android.view.MotionEvent;
 
 import com.iutlaval.myapplication.GameActivity;
@@ -12,47 +13,140 @@ public class TouchHandler {
     private float TouchDeltaY = 0;
     private float originalPositionX = 0;
     private float originalPositionY = 0;
-    private DrawableCard moveEventCard = null;
-    private Renderer renderer;
+    private DrawableCard dragAndDropCard = null;
+    private DrawableCard smallCardUserForBig = null;
+    private static final float SELECTING_OFFSET = 20F;
+    private PlayableZonesHandler playableZonesHandler;
 
-    public TouchHandler(Renderer renderer)
+    private Renderer renderer;
+    private GameLogicThread gameLogic;
+    private Context context;
+
+    public TouchHandler(Renderer renderer, GameLogicThread gameLogic, Context context)
     {
+        playableZonesHandler = new PlayableZonesHandler(gameLogic.getBoard());
         this.renderer = renderer;
+        this.gameLogic = gameLogic;
+        this.context=context;
     }
 
 
-    public void onTouchEvent(MotionEvent event){
+    public void onTouchEvent(MotionEvent event)
+    {
         //on ignore le multi touch
         if(event.getPointerCount() <= 1)
         {
-            float unscaled_X = event.getX() / GameActivity.screenWidth * 100;
-            float unscaled_Y = event.getY() / GameActivity.screenHeight * 100;
-
-            if (event.getAction() == MotionEvent.ACTION_DOWN) {
-                if(unscaled_Y <= 90F)
+            if(gameLogic.isYourTurn())
+            {
+                //l'ordre importe on a besoin d'avoir une carte sélectionner pour la jouer
+                if(event.getAction() == MotionEvent.ACTION_DOWN)
                 {
-                    moveEventCard = renderer.getCardOn(unscaled_X, unscaled_Y -20F);
+                    //selectionne la carte
+                    dragAndDropHandler(event);
+                    //affiche les zones de jeu
+                    playCard(event);
                 }else{
-                    moveEventCard = renderer.getCardOn(unscaled_X, unscaled_Y);
+                    //joue la carte si on a ACTION_UP
+                    playCard(event);
+                    //déplace la carte(non ACTION_UP) et la désélection (ACTION_UP)
+                    dragAndDropHandler(event);
                 }
 
-                if (moveEventCard != null) {
-                    TouchDeltaY = unscaled_Y - moveEventCard.getY();
-                    TouchDeltaX = unscaled_X - moveEventCard.getX();
-                    originalPositionX = moveEventCard.getX();
-                    originalPositionY = moveEventCard.getY();
-                    }
+            }
+            //afficher grosse carte
+            bigCardHandler(event);
 
-            } else if (event.getAction() == MotionEvent.ACTION_UP) {
-                TouchDeltaY = 0;
-                TouchDeltaX = 0;
-                //TODO detect zones
-                if(moveEventCard != null)renderer.moveToDraw(originalPositionX,originalPositionY,moveEventCard.getName());
-                moveEventCard = null;
-            } else if (moveEventCard != null) {
-                moveEventCard.setCoordinates(unscaled_X - TouchDeltaX, unscaled_Y - TouchDeltaY);
-                renderer.updateFrame();
+        }
+    }
+
+
+    private void dragAndDropHandler(MotionEvent event)
+    {
+        //on calcul les coordonées en % de l'écran
+        float unscaled_X = event.getX() / GameActivity.screenWidth * 100;
+        float unscaled_Y = event.getY() / GameActivity.screenHeight * 100;
+
+        //quand on appui on capture une carte et on note sa positon initial
+        if (event.getAction() == MotionEvent.ACTION_DOWN) {
+            dragAndDropCard = renderer.getCardOn(unscaled_X, unscaled_Y);
+
+            if(!dragAndDropCard.isDraggable()) dragAndDropCard = null;
+
+            if (dragAndDropCard != null) {
+                //on calcul la position par raport au doigt de l'utilisateur
+                TouchDeltaY = unscaled_Y - dragAndDropCard.getY();
+                TouchDeltaX = unscaled_X - dragAndDropCard.getX();
+                originalPositionX = dragAndDropCard.getX();
+                originalPositionY = dragAndDropCard.getY();
+            }
+
+        } else if (event.getAction() == MotionEvent.ACTION_UP) {
+            TouchDeltaY = 0;
+            TouchDeltaX = 0;
+            //TODO detect zones
+            if(dragAndDropCard != null)renderer.moveToDraw(originalPositionX,originalPositionY, dragAndDropCard.getName());
+            dragAndDropCard = null;
+        } else if (dragAndDropCard != null) {
+            dragAndDropCard.setCoordinates(unscaled_X - TouchDeltaX, unscaled_Y - TouchDeltaY);
+            renderer.updateFrame();
+        }
+    }
+
+    private void bigCardHandler(MotionEvent event)
+    {
+        //calcul y,x sur une echelle de 0 a 100
+        float unScalled_Y = event.getY() / GameActivity.screenHeight * 100;
+        float unScalled_X = event.getX() / GameActivity.screenWidth * 100;
+
+        if(event.getAction() == MotionEvent.ACTION_DOWN) {
+            //on recupére la carte a afficher en grand
+            DrawableCard smallCArd = renderer.getCardOn(unScalled_X,unScalled_Y);
+            if(smallCArd !=null)
+            {
+                if(smallCardUserForBig !=null)
+                {
+                    smallCardUserForBig.setCoordinates(smallCardUserForBig.getX(), smallCardUserForBig.getY() + SELECTING_OFFSET);
+                    //on update pas affin d'avoir un rendu plus fluide au moment de mettre l'aure carte
+                    renderer.removeToDrawWithoutUpdate(smallCardUserForBig.getName()+"BIG");
+                }
+                smallCardUserForBig = smallCArd;
+                DrawableCard bigCard = new DrawableCard(smallCArd,context,2);
+                renderer.addToDraw(bigCard);
+                bigCard.setCoordinates(72F,10F);
+                //on ne décale pas la carte sélectionner si ce n'est pas notre tours
+                if(gameLogic.isYourTurn())smallCArd.setCoordinates(smallCArd.getX(),smallCArd.getY() - SELECTING_OFFSET);
+            //si on lache la carte
+            }else if(event.getAction() == MotionEvent.ACTION_UP) {
+                if (smallCardUserForBig != null) {
+                    renderer.removeToDraw(smallCardUserForBig.getName() + "BIG");
+                    smallCardUserForBig = null;
+                }
             }
         }
     }
+
+    private void playCard(MotionEvent event)
+    {
+        //l'affichage se fait par une liste fifo donc on veut que notre carte soit afficher aprés les zones
+        if(event.getAction() == MotionEvent.ACTION_DOWN) {
+            //on enleve l carte
+            renderer.removeToDrawWithoutUpdate(dragAndDropCard);
+            //on ajoute les zones
+            playableZonesHandler.displayPlayableZones(renderer);
+            // et enfin on remet la carte
+            renderer.addToDraw(dragAndDropCard);
+
+        }else if(event.getAction() == MotionEvent.ACTION_UP) {
+            int zone = playableZonesHandler.getHoveredZone(smallCardUserForBig);
+            if(zone != -1)
+            {
+                dragAndDropCard.setOnBoard(true);
+                dragAndDropCard.setCoordinates((DrawableCard.getCardWith()+1)*zone,55F);
+                dragAndDropCard.setDraggable(false);
+            }else{
+                dragAndDropCard.setCoordinates(dragAndDropCard.getX(),dragAndDropCard.getY() + SELECTING_OFFSET);
+            }
+        }
+    }
+
 }

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

@@ -5,6 +5,7 @@ import android.graphics.Canvas;
 import android.graphics.Paint;
 import androidx.annotation.NonNull;
 import com.iutlaval.myapplication.GameActivity;
+import com.iutlaval.myapplication.exception.BadDrawableName;
 
 public abstract class Drawable {
 
@@ -23,7 +24,12 @@ public abstract class Drawable {
     {
         this.x=x;
         this.y=y;
+        if(name == null || name.equals("")) {
+            throw new BadDrawableName(name);
+        }
         this.name=name;
+
+
     }
 
     /**

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

@@ -33,4 +33,5 @@ public class DrawableBitmap extends Drawable{
 
         setBitmap(Bitmap.createScaledBitmap(bitmap, (int)x_scaled_size, (int)y_scaled_size, GameActivity.bilinearFiltering));
     }
+
 }

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

@@ -0,0 +1,33 @@
+package com.iutlaval.myapplication.Video.Drawables;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+
+import androidx.annotation.NonNull;
+
+import java.time.Instant;
+
+public class DrawableSelfRemoving extends Drawable{
+
+    private Drawable drawable;
+    private long lifetime;
+
+    public DrawableSelfRemoving(Drawable drawable,int lifetime) {
+        super(drawable.getX(), drawable.getY(), drawable.getName());
+        this.drawable = drawable;
+        this.lifetime = System.currentTimeMillis()+lifetime*1000;
+    }
+
+    @Override
+    public void drawOn(@NonNull Canvas c, @NonNull Paint p) {
+        if(lifetime > System.currentTimeMillis())
+        {
+            drawable.drawOn(c,p);
+        }
+    }
+
+    public boolean isDone()
+    {
+        return lifetime < System.currentTimeMillis();
+    }
+}

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

@@ -14,6 +14,7 @@ import com.iutlaval.myapplication.Game.GameLogicThread;
 import com.iutlaval.myapplication.GameActivity;
 import com.iutlaval.myapplication.Video.Drawables.Drawable;
 import com.iutlaval.myapplication.Video.Drawables.DrawableCard;
+import com.iutlaval.myapplication.Video.Drawables.DrawableSelfRemoving;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -88,13 +89,29 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
      * function ran for each frame to draw all the drawables
      * @param canvas canevas on wich to draw on
      */
+    List<Drawable> toremove = new ArrayList<>();
     @Override
     protected void onDraw(Canvas canvas) {
         //le to Array patch les crash
+
         for(Drawable d : toDraw.toArray(new Drawable[0]))
         {
+            if(d instanceof DrawableSelfRemoving)
+            {
+                if(((DrawableSelfRemoving)d).isDone())
+                {
+                    toremove.add(d);
+                }
+            }
             d.drawOn(canvas,p);
         }
+        for(Drawable d : toremove)
+        {
+            removeToDrawWithoutUpdate(d);
+        }
+        if(toremove.size() > 0)updateFrame();
+        toremove.clear();
+
     }
 
     /**

app/src/main/java/com/iutlaval/myapplication/exception/BadDrawableName.java

@@ -0,0 +1,19 @@
+package com.iutlaval.myapplication.exception;
+
+public class BadDrawableName extends RuntimeException{
+    String name;
+    public BadDrawableName(String name) {
+        this.name=name;
+    }
+
+    @Override
+    public void printStackTrace() {
+        super.printStackTrace();
+        if(name == null)
+        {
+            System.out.println("NAME CAN'T BE NULL");
+        }else{
+            System.out.println("NAME CAN'T BE EMPTY");
+        }
+    }
+}