refactor touchHandler + repensé dekc + renpensé carte + suprimé code inutile + ajouter d'event carte

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

@@ -1,12 +1,10 @@
 package com.iutlaval.myapplication.Game;
 
 import com.iutlaval.myapplication.Game.Cards.Card;
-import com.iutlaval.myapplication.Game.Players.Player;
-import com.iutlaval.myapplication.Game.Players.PlayerLocal;
-
-import java.util.ArrayList;
-import java.util.List;
 
+/**
+ * cette classe contrain toutes les cartes sur le terrain cela permet de garder une copie qui sera utilisé pour l'affichage
+ */
 public class Board {
     public static final int MAX_CARD_ON_BOARD=5;
     private Card[] advCardsOnBoard;
@@ -18,43 +16,11 @@ public class Board {
         playerCardsOnBoard = new Card[MAX_CARD_ON_BOARD];
     }
 
-    /**
-     * joue une carte et l'ajoute au terrain du joueur correspondant
-     * si retourne faux alors la carte n'a pas éte joué
-     * @param card
-     * @param player
-     * @return success/failure
-     */
-    public boolean playCard(Card card,Player player)
-    {
-        boolean returnvalue = false;
-        if(player instanceof PlayerLocal)
-        {
-            for(Card c : playerCardsOnBoard)
-            {
-                if(c == null)
-                {
-                    c=card;
-                    returnvalue=true;
-                    break;
-                }
-            }
-        }else{
-            for(Card c : advCardsOnBoard)
-            {
-                if(c == null)
-                {
-                    c=card;
-                    returnvalue=true;
-                    break;
-                }
-            }
-        }
-        card.onCardPlayed(this,player);
-        return returnvalue;
-    }
-
     public Card[] getPlayerCardsOnBoard() {
         return playerCardsOnBoard;
     }
+
+    public Card[] getAdvCardsOnBoard() {
+        return advCardsOnBoard;
+    }
 }

app/src/main/java/com/iutlaval/myapplication/Game/Cards/Card.java

@@ -5,7 +5,6 @@ import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 
 import com.iutlaval.myapplication.Game.Board;
-import com.iutlaval.myapplication.Game.Players.Player;
 import com.iutlaval.myapplication.R;
 import com.iutlaval.myapplication.Video.Drawables.DrawableCard;
 
@@ -23,31 +22,6 @@ public abstract class Card {
         drawableCard = new DrawableCard(this,0,0,UID,c);
     }
 
-    /**
-     * *cette methode est appeler a chaque fois que la carte attaque
-     * @param board
-     */
-    public void onCardAttack(Board board,Card enemy){}
-
-    /**
-     * cette methode est appeler quand la carte est jouer
-     * elle se fait appler par board.java
-     * @param board
-     */
-    public void onCardPlayed(Board board, Player p){}
-
-    /**
-     * cette methode est appeler quand la carte est detruite
-     * @param board
-     */
-    public void onCardDeath(Board board){}
-
-    /**
-     * cette methode est appeler quand le tour commance
-     * @param board
-     */
-    public void onTurnBegin(Board board){}
-
     /**
      * SURTOUT NE PAS @OVERRIDE
      * si vous voulez modifier le cadre changer getFrameTexture()

app/src/main/java/com/iutlaval/myapplication/Game/Decks/Deck.java

@@ -1,25 +0,0 @@
-package com.iutlaval.myapplication.Game.Decks;
-
-import com.iutlaval.myapplication.Game.Cards.Card;
-
-import java.util.Collections;
-import java.util.Stack;
-
-/**
- * TOUT DECK CREE DOIT ETRE AJOUTER A DECKREGISTER
- */
-public abstract class Deck {
-    public abstract Stack<Card> getCards();
-
-    public void shuffle()
-    {
-        Collections.shuffle(getCards());
-    }
-
-    /**
-     * retourne le nom du deck ex: ww2 , science
-     * ce nom doit être unique
-     * @return
-     */
-    public abstract String getDeckName();
-}

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

@@ -8,16 +8,16 @@ import android.view.MotionEvent;
 
 import com.iutlaval.myapplication.Game.Cards.Card;
 import com.iutlaval.myapplication.Game.Cards.CardRegistery;
-import com.iutlaval.myapplication.Game.Decks.Deck;
-import com.iutlaval.myapplication.Game.Decks.NetWorkDeck;
 import com.iutlaval.myapplication.GameActivity;
 import com.iutlaval.myapplication.R;
+import com.iutlaval.myapplication.Video.Drawables.Drawable;
 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;
+import java.io.InterruptedIOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.Socket;
@@ -29,14 +29,15 @@ public class GameLogicThread extends Thread{
     private boolean ready;
     private TouchHandler touch;
     private GameActivity gameActivity;
+    private ObjectInputStream clientIn=null;
+    private ObjectOutputStream clientOut=null;
 
-    private Deck localPlayerDeck;
+    private NetworkDeck deck;
-    private Hand localPlayerHand;
+    private Hand hand;
     private Board board;
-
-
-
     private boolean isYourTurn;
+    private boolean cancelled;
+    private Socket client;
 
     public GameLogicThread(GameActivity gameActivity, Renderer renderer)
     {
@@ -45,12 +46,13 @@ public class GameLogicThread extends Thread{
         ready=false;
         this.cont = gameActivity;
         this.renderer = renderer;
-        touch = new TouchHandler(renderer,this,gameActivity);
-        localPlayerHand = new Hand();
-        this.gameActivity=gameActivity;
         board=new Board();
+        touch = new TouchHandler(renderer,this,gameActivity);
+        hand = new Hand();
+        this.gameActivity=gameActivity;
         GameActivity.setGameEngine(this);
         isYourTurn=false;
+        cancelled=false;
     }
 
     @Override
@@ -64,14 +66,15 @@ public class GameLogicThread extends Thread{
         //drawHandPreview();
         //Rectangle pos = new Rectangle(0F,0F,100F,100F);
 
+        ready=true;
+
         //TODO : choix du deck avant de se co au serv
 
         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 {
-            Socket client = new Socket(host, port);
+            client = new Socket(host, port);
             clientIn = new ObjectInputStream(client.getInputStream());
             clientOut = new ObjectOutputStream(client.getOutputStream());
         } catch (IOException e) {
@@ -83,8 +86,8 @@ public class GameLogicThread extends Thread{
 
         //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)
+        while(ready && !cancelled)
         {
             try {
                 String serveurCmd = (String)clientIn.readObject();
@@ -95,14 +98,14 @@ public class GameLogicThread extends Thread{
                         clientOut.writeObject("deckDemo");
                         //TODO assing this deck
                         String deckstr = (String)clientIn.readObject();
-                        localPlayerDeck = new NetWorkDeck(deckstr,gameActivity.getBaseContext());
+                        deck = new NetworkDeck(deckstr,gameActivity.getBaseContext());
                         Log.e("got deck",deckstr);
 
                         Log.e("recived","getdeck");
                         break;
                     case COMMAND.DRAW:
                         int nbcard = (Integer)clientIn.readObject();
-                        localPlayerHand.pickCardFromDeck(localPlayerDeck,nbcard);
+                        hand.pickCardFromDeck(deck,nbcard);
                         Log.e("picked",nbcard+"card");
                         drawHandPreview();
                         break;
@@ -111,12 +114,18 @@ public class GameLogicThread extends Thread{
                         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) {
+            }catch (InterruptedIOException e)
+            {
+                Log.e("Stopping","dead thread");
+            }
+            catch (Exception e) {
                 Log.e("ERROR DURING COMS","SERVER DIED");
                 e.printStackTrace();
+                break;
             }
         }
     }
@@ -126,7 +135,7 @@ public class GameLogicThread extends Thread{
      */
     private void drawHandPreview() {
         int i = 0;
-        for(Card c : localPlayerHand.getHand())
+        for(Card c : hand.getHand())
         {
             renderer.addToDraw(c.getDrawableCard());
             renderer.moveToDraw(i* DrawableCard.getCardWith(),90F,c.getDrawableCard().getName());
@@ -135,6 +144,16 @@ public class GameLogicThread extends Thread{
 
     }
 
+    /**
+     * cette evenement est appelé par le touchHandler et permet d'envoyer au serveur le fait qu'un carte a été jouer
+     * @param card la carte jouer
+     * @param zone ou elle a été joué sur le terrain
+     */
+    protected void onCardPlayed(Drawable card,int zone)
+    {
+
+    }
+
     /**
      * cette fonction est appeller a chaque fin de frame
      * CETTE FONCTION A UN IMPACT DIRECT SUR LES FPS ELLE SE DOIT D'être OPTIMAL
@@ -163,7 +182,7 @@ public class GameLogicThread extends Thread{
      * @param event
      */
     public void onTouchEvent(MotionEvent event) {
-        //if(isReady())touch.onTouchEvent(event);
+        if(isReady())touch.onTouchEvent(event);
     }
 
     public boolean isYourTurn() {
@@ -174,4 +193,17 @@ public class GameLogicThread extends Thread{
     public Board getBoard() {
         return board;
     }
+
+    public void terminate() {
+        ready=false;
+        try {
+            if(clientOut != null)clientOut.close();
+            if(clientIn != null)clientIn.close();
+            if(client != null)client.close();
+        } catch (IOException e) {}
+        cancelled=true;
+
+        interrupt();
+
+    }
 }

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

@@ -1,7 +1,6 @@
 package com.iutlaval.myapplication.Game;
 
 import com.iutlaval.myapplication.Game.Cards.Card;
-import com.iutlaval.myapplication.Game.Decks.Deck;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -17,7 +16,12 @@ public class Hand {
         hand = new ArrayList<>();
     }
 
-    public void pickCardFromDeck(Deck deck,int amount)
+    /**
+     * recupére la quantité indiqué de carte depuis le deck
+     * @param deck
+     * @param amount
+     */
+    public void pickCardFromDeck(NetworkDeck deck,int amount)
     {
         for(int i = 0 ; i < amount;i++)
         {
@@ -25,12 +29,6 @@ public class Hand {
         }
     }
 
-    //TODO check number of card in hand
-    public void fillHand(Deck deck)
-    {
-        pickCardFromDeck(deck,NUMBER_OF_CARDS_IN_STARTING_HAND);
-    }
-
     public List<Card> getHand() {
         return hand;
     }

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

@@ -1,4 +1,4 @@
-package com.iutlaval.myapplication.Game.Decks;
+package com.iutlaval.myapplication.Game;
 
 import android.content.Context;
 
@@ -12,9 +12,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Stack;
 
-public class NetWorkDeck extends Deck{
+public class NetworkDeck{
     Stack<Card> cards;
-    public NetWorkDeck(String deckstring, Context context)
+    public NetworkDeck(String deckstring, Context context)
     {
         cards = new Stack<>();
         int nbcarte=0;
@@ -33,13 +33,7 @@ public class NetWorkDeck extends Deck{
         }
     }
 
-    @Override
     public Stack<Card> getCards() {
         return cards;
     }
-
-    @Override
-    public String getDeckName() {
-        return null;
-    }
 }

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

@@ -71,7 +71,7 @@ public class PlayableZonesHandler {
         {
             int cardX =(DrawableCard.getCardWith()+1)*i+1;
             //es que on survole sur l'axe x
-            if(cardX > card.getX() && card.getY() < 90F && card.getY() > 50F)
+            if(cardX > card.getX() && card.getY() < 75F/*90F orrigine */ && card.getY() > 50F)
             {
                 //on a trouvé l'emplacement de la carte
                 if(board.getPlayerCardsOnBoard()[i] == null)return i;

app/src/main/java/com/iutlaval/myapplication/Game/Players/Player.java

@@ -1,48 +0,0 @@
-package com.iutlaval.myapplication.Game.Players;
-
-import com.iutlaval.myapplication.Game.Cards.Card;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public abstract class Player {
-    private static final int MAX_HAND_SIZE = 10;
-
-    private List<Card> deck;
-    private List<Card> hand;
-    private int hp = 100;
-
-
-    public Player(){
-        deck=new ArrayList<>();
-        hand=new ArrayList<>();
-    }
-
-    public void shuffle()
-    {
-        Collections.shuffle(deck);
-    }
-
-    /**
-     * cette fonction ajoute un carte dans la main de l'utilisateur
-     */
-    public void pickCard()
-    {
-        if(!deck.isEmpty()) {
-            if (hand.size() >= MAX_HAND_SIZE) {
-                deck.remove(0);
-            } else {
-                hand.add(deck.remove(0));
-            }
-        }else{
-            getHurt(2);
-        }
-    }
-
-    public void getHurt(int dmg)
-    {
-        hp -= dmg;
-        //TODO death trigger
-    }
-}

app/src/main/java/com/iutlaval/myapplication/Game/Players/PlayerBot.java

@@ -1,4 +0,0 @@
-package com.iutlaval.myapplication.Game.Players;
-
-public class PlayerBot extends Player{
-}

app/src/main/java/com/iutlaval/myapplication/Game/Players/PlayerLocal.java

@@ -1,4 +0,0 @@
-package com.iutlaval.myapplication.Game.Players;
-
-public class PlayerLocal extends Player{
-}

app/src/main/java/com/iutlaval/myapplication/Game/Players/PlayerOnlineAdversary.java

@@ -1,4 +0,0 @@
-package com.iutlaval.myapplication.Game.Players;
-
-public class PlayerOnlineAdversary extends Player{
-}

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

@@ -14,8 +14,9 @@ public class TouchHandler {
     private float originalPositionX = 0;
     private float originalPositionY = 0;
     private DrawableCard dragAndDropCard = null;
-    private DrawableCard smallCardUserForBig = null;
+    private DrawableCard smallCardUsedForBig = null;
-    private static final float SELECTING_OFFSET = 20F;
+    private DrawableCard cardSeletedInHand = null;
+    private static final float SELECTING_OFFSET = 10F;
     private PlayableZonesHandler playableZonesHandler;
 
     private Renderer renderer;
@@ -30,36 +31,33 @@ public class TouchHandler {
         this.context=context;
     }
 
-
+    /**
+     * cette evenement doit recevoir le onTouchEvent d'une activité
+     * @param event
+     */
     public void onTouchEvent(MotionEvent event)
     {
         //on ignore le multi touch
         if(event.getPointerCount() <= 1)
         {
+            handSelectionHandler(event);
+            //afficher grosse carte
+            bigCardHandler(event);
             if(gameLogic.isYourTurn())
-            {
-                //l'ordre importe on a besoin d'avoir une carte sélectionner pour la jouer
-                if(event.getAction() == MotionEvent.ACTION_DOWN)
             {
                 //selectionne la carte
                 dragAndDropHandler(event);
                 //affiche les zones de jeu
                 playCard(event);
-                }else{
-                    //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);
-                }
-
-            }
-            //afficher grosse carte
-            bigCardHandler(event);
 
             }
         }
+    }
 
-
+    /**
+     * gére le drag and drop de carte
+     * @param event
+     */
     private void dragAndDropHandler(MotionEvent event)
     {
         //on calcul les coordonées en % de l'écran
@@ -70,7 +68,7 @@ public class TouchHandler {
         if (event.getAction() == MotionEvent.ACTION_DOWN) {
             dragAndDropCard = renderer.getCardOn(unscaled_X, unscaled_Y);
 
-            if(!dragAndDropCard.isDraggable()) dragAndDropCard = null;
+            if(dragAndDropCard != null && !dragAndDropCard.isDraggable()) dragAndDropCard = null;
 
             if (dragAndDropCard != null) {
                 //on calcul la position par raport au doigt de l'utilisateur
@@ -83,15 +81,18 @@ public class TouchHandler {
         } 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;
-            dragAndDropCard = null;
         } else if (dragAndDropCard != null) {
             dragAndDropCard.setCoordinates(unscaled_X - TouchDeltaX, unscaled_Y - TouchDeltaY);
             renderer.updateFrame();
         }
     }
 
+    /**
+     * affiche une grosse carte carte quand une carte est sélectionner
+     * @param event
+     */
     private void bigCardHandler(MotionEvent event)
     {
         //calcul y,x sur une echelle de 0 a 100
@@ -103,30 +104,34 @@ public class TouchHandler {
             DrawableCard smallCArd = renderer.getCardOn(unScalled_X,unScalled_Y);
             if(smallCArd !=null)
             {
-                if(smallCardUserForBig !=null)
+                if(smallCardUsedForBig !=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");
+                    renderer.removeToDrawWithoutUpdate(smallCardUsedForBig.getName()+"BIG");
                 }
-                smallCardUserForBig = smallCArd;
+                smallCardUsedForBig = 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
+                //on sélectionne si elle est dans notre main(déplacer la care vers le haut de quelque pixel)
-                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;
             }
+        }else if(event.getAction() == MotionEvent.ACTION_UP) {
+            if (smallCardUsedForBig != null) {
+                renderer.removeToDraw(smallCardUsedForBig.getName() + "BIG");
+                smallCardUsedForBig = null;
             }
         }
     }
 
+    /**
+     * gére le placement des cartes sur le terrain
+     * @param event
+     */
     private void playCard(MotionEvent event)
     {
+        if(dragAndDropCard != null){
             //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
@@ -137,16 +142,40 @@ public class TouchHandler {
                 renderer.addToDraw(dragAndDropCard);
 
             }else if(event.getAction() == MotionEvent.ACTION_UP) {
-            int zone = playableZonesHandler.getHoveredZone(smallCardUserForBig);
+                int zone = playableZonesHandler.getHoveredZone(dragAndDropCard);
                 if(zone != -1)
                 {
                     dragAndDropCard.setOnBoard(true);
                     dragAndDropCard.setCoordinates((DrawableCard.getCardWith()+1)*zone,55F);
                     dragAndDropCard.setDraggable(false);
+                    gameLogic.onCardPlayed(dragAndDropCard,zone);
                 }else{
-                dragAndDropCard.setCoordinates(dragAndDropCard.getX(),dragAndDropCard.getY() + SELECTING_OFFSET);
+                    if(dragAndDropCard != null)renderer.moveToDraw(originalPositionX,originalPositionY, dragAndDropCard.getName());
                 }
+                playableZonesHandler.hidePlayableZones(renderer);
             }
         }
 
     }
+
+    private void handSelectionHandler(MotionEvent event)
+    {
+        float unScalled_Y = event.getY() / GameActivity.screenHeight * 100;
+        float unScalled_X = event.getX() / GameActivity.screenWidth * 100;
+        DrawableCard smallCArd = renderer.getCardOn(unScalled_X,unScalled_Y);
+        if(event.getAction() == MotionEvent.ACTION_DOWN) {
+            if(cardSeletedInHand != null && !cardSeletedInHand.isOnBoard()){
+                cardSeletedInHand.setCoordinates(cardSeletedInHand.getX(), cardSeletedInHand.getY() + SELECTING_OFFSET);
+                cardSeletedInHand=null;
+                renderer.updateFrame();
+            }
+
+            if(unScalled_Y > 90F && smallCArd !=null && smallCArd.isDraggable() && !smallCArd.isOnBoard() && (cardSeletedInHand == null || !cardSeletedInHand.equals(smallCArd)))
+            {
+                smallCArd.setCoordinates(smallCArd.getX(),smallCArd.getY() - SELECTING_OFFSET);
+                cardSeletedInHand=smallCArd;
+                renderer.updateFrame();
+            }
+        }
+    }
+}

app/src/main/java/com/iutlaval/myapplication/GameActivity.java

@@ -42,6 +42,21 @@ public class GameActivity extends Activity {
         GameActivity.gameEngine = gameEngine;
     }
 
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        //kill les threads
+        System.exit(0);
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        if (renderer != null) renderer.terminate();
+        gameEngine = null;
+        renderer = null;
+    }
+
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         if(gameEngine != null)gameEngine.onTouchEvent(event);

app/src/main/java/com/iutlaval/myapplication/MainActivity.java

@@ -20,6 +20,7 @@ public class MainActivity extends AppCompatActivity {
             public void onClick(View v) {
                 //Toast.makeText(getApplicationContext(), "click sur button", Toast.LENGTH_LONG).show();
                 Intent gameActivity = new Intent(MainActivity.this, GameActivity.class);
+                gameActivity.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
 
                 startActivity(gameActivity);
             }

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

@@ -345,6 +345,11 @@ public class DrawableCard extends Drawable{
         return draggable;
     }
 
+    public boolean isOnBoard()
+    {
+        return onBoard;
+    }
+
     public void setDraggable(Boolean draggable) {
         this.draggable = draggable;
     }

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

@@ -5,6 +5,7 @@ import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
+import android.util.Log;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 
@@ -24,7 +25,7 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
     private SurfaceHolder holder;
     private Paint p;
     private DrawingThread drawingThread;
-    private GameLogicThread engine;
+    private static GameLogicThread engine;
     private GameActivity gameActivity;
     private boolean needToUpdate;
 
@@ -143,8 +144,20 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
             while(getWidth()==0);
             GameActivity.screenHeight=renderer.getHeight() < renderer.getWidth() ? renderer.getHeight() : renderer.getWidth();
             GameActivity.screenWidth=renderer.getHeight() > renderer.getWidth() ? renderer.getHeight() : renderer.getWidth();
+
+            if(engine != null && engine.isAlive())
+            {
+                Log.e("RENDERER","OLD ENGINE DETECTED TERMINATING");
+                engine.terminate();
+                while (!engine.isAlive());
+            }
+
+            Log.i("RENDERER","STARTING ENGINE");
             engine = new GameLogicThread(gameActivity,renderer);
             engine.start();
+            while (!engine.isReady());
+            Log.i("RENDERER","ENGINE STARTED");
+
 
             while (keepDrawing) {
                 Canvas canvas = null;
@@ -309,4 +322,10 @@ public class Renderer extends SurfaceView implements SurfaceHolder.Callback {
         return null;
 
     }
+
+    public void terminate()
+    {
+        if(drawingThread != null)drawingThread.keepDrawing=false;
+        if(engine !=null)engine.terminate();
+    }
 }

app/src/main/res/layout/activity_hand.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".Game.HandActivity">
-
-    <TextView
-        android:id="@+id/textView5"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginStart="365dp"
-        android:layout_marginTop="232dp"
-        android:layout_marginEnd="324dp"
-        android:layout_marginBottom="160dp"
-        android:text="HELLO"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-</androidx.constraintlayout.widget.ConstraintLayout>