Merge branch 'LocalGameplay' into 'development'

merge LokalGameplay into development

See merge request !12

src/main/java/de/hdm_stuttgart/battlearena/Controller/Enum/GameMode.java

+package de.hdm_stuttgart.battlearena.Controller.Enum;
+
+public enum GameMode {
+    LOCAL,
+    NETWORK
+}
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Controller/Enum/GameState.java

+package de.hdm_stuttgart.battlearena.Controller.Enum;
+
+public enum GameState {
+    MENU,
+    PAUSE,
+    PLAYING,
+    LOST,
+    WON
+}
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Controller/Enum/PlayerMode.java

+package de.hdm_stuttgart.battlearena.Controller.Enum;
+
+public enum PlayerMode {
+    PLAYER_ONE,
+    PLAYER_TWO
+}
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Controller/GameSceneController.java

 package de.hdm_stuttgart.battlearena.Controller;
 
+import de.hdm_stuttgart.battlearena.Controller.Enum.GameMode;
+import de.hdm_stuttgart.battlearena.Controller.Enum.GameState;
+import de.hdm_stuttgart.battlearena.Controller.Enum.PlayerMode;
+import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.RuntimeInfo;
 import de.hdm_stuttgart.battlearena.Model.Entity.EntityClass;
 import de.hdm_stuttgart.battlearena.Model.Entity.EntityFactory;
 import de.hdm_stuttgart.battlearena.Model.Entity.EntityType;
@@ -30,11 +34,15 @@ public class GameSceneController implements Initializable {
 
     InputHandler inputHandler = InputHandler.getInstance();
 
+    RuntimeInfo runtimeInfo = RuntimeInfo.getInstance();
+
+    GameMode gameMode = runtimeInfo.getGameMode();
+
     IEntity player;
     IEntity enemy;
 
-    EntityClass playerClass = EntityClass.HUMAN;
-    EntityClass enemyClass = EntityClass.HUMAN;
+    EntityClass playerOneClass = runtimeInfo.getPlayerOneClass();
+    EntityClass playerTwoClass = runtimeInfo.getPlayerTwoClass();
 
     TileManager tileManager;
 
@@ -46,7 +54,7 @@ public class GameSceneController implements Initializable {
                         "4 1 1 1 2 2 4 1 1 1 1 1 1 1 3 1 2 3 " +
                         "4 1 1 1 2 2 4 1 3 3 3 1 1 1 3 2 2 3 " +
                         "4 1 1 1 2 2 4 1 1 1 1 1 1 1 3 2 1 3 " +
-                        "4 1 1 1 2 2 4 3 3 1 4 3 3 3 3 2 1 3 " +
+                        "4 1 5 1 2 2 4 3 3 1 4 3 3 3 3 2 1 3 " +
                         "4 1 1 1 1 1 1 2 2 2 1 1 1 1 1 1 1 3 " +
                         "4 1 1 1 2 2 4 3 3 1 3 3 3 3 3 2 1 3 " +
                         "4 1 1 1 1 2 4 3 3 1 3 3 3 3 3 1 1 3 " +
@@ -59,7 +67,7 @@ public class GameSceneController implements Initializable {
                         "4 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3";
     int horizontalTileCount = 18;
     int verticalTileCount = 18;
-    int diffTileCount = 5;
+    int diffTileCount = 6;
     int scaledTileSize = 48;
 
 
@@ -68,11 +76,20 @@ public class GameSceneController implements Initializable {
         graphicsContext2D = canvas2D.getGraphicsContext2D();
         graphicsContext2D.setImageSmoothing(false);
 
-        player = EntityFactory.createEntity(EntityType.PLAYER, graphicsContext2D, inputHandler, playerClass, this);
-        enemy = EntityFactory.createEntity(EntityType.ENEMY_PLAYER, graphicsContext2D, inputHandler, enemyClass, this);
+        player = EntityFactory.createEntity(EntityType.PLAYER, graphicsContext2D, inputHandler,
+                playerOneClass, this, PlayerMode.PLAYER_ONE);
+        if (gameMode == GameMode.NETWORK) {
+            enemy = EntityFactory.createEntity(EntityType.NETWORK_PLAYER_TWO, graphicsContext2D, inputHandler,
+                    playerTwoClass, this, PlayerMode.PLAYER_TWO);
+        } else {
+            enemy = EntityFactory.createEntity(EntityType.PLAYER, graphicsContext2D, inputHandler,
+                    playerTwoClass, this, PlayerMode.PLAYER_TWO);
+        }
 
         tileManager = new TileManager(graphicsContext2D, diffTileCount, horizontalTileCount, verticalTileCount, mapString);
 
+        runtimeInfo.setGameState(GameState.PLAYING);
+
         AnimationTimer gameLoop = new AnimationTimer() {
             @Override
             public void handle(long l) {
@@ -89,18 +106,25 @@ public class GameSceneController implements Initializable {
         player.updateEntityMovement(this);
         enemy.updateEntityMovement(this);
         player.attack(enemy, graphicsContext2D);
+        enemy.attack(player, graphicsContext2D);
     }
 
     private void renderContent(GraphicsContext graphicsContext) {
         tileManager.renderMap();
         player.renderEntity(graphicsContext);
         enemy.renderEntity(graphicsContext);
+        player.checkHealTile(player, graphicsContext2D);
+        enemy.checkHealTile(enemy, graphicsContext2D);
     }
 
     public IEntity getEnemy() {
         return enemy;
     }
 
+    public IEntity getPlayer() {
+        return player;
+    }
+
     public TileManager getTileManager() {
         return tileManager;
     }

src/main/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/RuntimeInfo.java

 package de.hdm_stuttgart.battlearena.Model.DataStorage.Classes;
 
+import de.hdm_stuttgart.battlearena.Controller.Enum.GameMode;
+import de.hdm_stuttgart.battlearena.Controller.Enum.GameState;
 import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.Exceptions.ParserException;
 import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.Utilities.HashGenerator;
 import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.Utilities.Parser;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityClass;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -16,6 +19,13 @@ public class RuntimeInfo {
     protected String mapDataGame;
     protected boolean offlineMode;  //if Account-Type is online but no SQL connection: start game without stats tracking
 
+    private GameState gameState = GameState.MENU; //Default value: MENU
+    private GameMode gameMode = GameMode.LOCAL; //Default value: LOCAL
+
+    //Default value: HUMAN
+    private EntityClass playerOneClass = EntityClass.HUMAN;
+    private EntityClass playerTwoClass = EntityClass.HUMAN;
+
 
     private RuntimeInfo(){};
 
@@ -48,9 +58,40 @@ public class RuntimeInfo {
         }
     }
 
+    public GameState getGameState() {
+        return gameState;
+    }
+
+    public void setGameState(GameState gameState) {
+        this.gameState = gameState;
+    }
+
+    public GameMode getGameMode() {
+        return gameMode;
+    }
+
+    public void setGameMode(GameMode gameMode) {
+        this.gameMode = gameMode;
+    }
+
+    public EntityClass getPlayerOneClass() {
+        return playerOneClass;
+    }
+
+    public void setPlayerOneClass(EntityClass playerOneClass) {
+        this.playerOneClass = playerOneClass;
+    }
+
+    public EntityClass getPlayerTwoClass() {
+        return playerTwoClass;
+    }
+
+    public void setPlayerTwoClass(EntityClass playerTwoClass) {
+        this.playerTwoClass = playerTwoClass;
+    }
 
     public int gameTimeInHours(){
         return persistenceInst.getStatistics().getGameTime() / 3600;
     }
 
-}
+}
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityFactory.java

 package de.hdm_stuttgart.battlearena.Model.Entity;
 
+import de.hdm_stuttgart.battlearena.Controller.Enum.PlayerMode;
 import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
 import de.hdm_stuttgart.battlearena.Model.Inputs.InputHandler;
 
@@ -12,13 +13,14 @@ public class EntityFactory {
 
     private static final Logger log = LogManager.getLogger(EntityFactory.class);
 
-    public static IEntity createEntity(EntityType entityType, GraphicsContext gameScene, InputHandler inputHandler, EntityClass entityClass, GameSceneController gameSceneController) {
+    public static IEntity createEntity(EntityType entityType, GraphicsContext gameScene, InputHandler inputHandler,
+                                       EntityClass entityClass, GameSceneController gameSceneController, PlayerMode playerMode) {
         if (entityType == EntityType.PLAYER) {
             log.debug("Entity " + entityType + " created");
-            return new Player(gameScene, inputHandler, entityClass, gameSceneController);
-        } else if (entityType == EntityType.ENEMY_PLAYER) {
+            return new Player(gameScene, inputHandler, entityClass, gameSceneController, playerMode);
+        } else if (entityType == EntityType.NETWORK_PLAYER_TWO) {
             log.debug("Entity " + entityType + " created");
-            return new EnemyHandler();
+            return new NetworkPlayerTwo();
         }
 
         throw new IllegalArgumentException ("Entity type not supported " + entityType);

src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityType.java

@@ -2,5 +2,6 @@ package de.hdm_stuttgart.battlearena.Model.Entity;
 
 public enum EntityType {
     PLAYER,
-    ENEMY_PLAYER
+    NETWORK_PLAYER_TWO,
+    LOKAL_PLAYER_TWO
 }
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/IEntity.java

@@ -12,19 +12,23 @@ public interface IEntity {
 
    void updateEntityMovement(GameSceneController gameScene);
 
+   void checkHealTile(IEntity entity, GraphicsContext graphicsContext);
+
    void attack(IEntity entity, GraphicsContext graphicsContext);
 
    void updateEntityWalkAnimation();
 
    void renderEntity(GraphicsContext graphicsContext);
 
-   BoundingBox getBoxCollider();
+    void healPlayer(int heal);
+
+    BoundingBox getBoxCollider();
 
    EntityDirection getEntityDirection();
 
    int getEntitySpeed();
 
-   int gotHit(int damageDone);
+   void gotHit(int damageDone);
 
    int getMapPosX();
 

src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EnemyHandler.java → src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/NetworkPlayerTwo.java

@@ -9,9 +9,9 @@ import javafx.scene.paint.Color;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
 
-class EnemyHandler implements IEntity{
+class NetworkPlayerTwo implements IEntity{
 
-    private static final Logger log = LogManager.getLogger(EnemyHandler.class);
+    private static final Logger log = LogManager.getLogger(NetworkPlayerTwo.class);
 
     private final BoundingBox boxCollider = new BoundingBox(300, 200, 48, 48);
 
@@ -36,6 +36,11 @@ class EnemyHandler implements IEntity{
 
     }
 
+    @Override
+    public void checkHealTile(IEntity entity, GraphicsContext graphicsContext) {
+
+    }
+
     @Override
     public void attack(IEntity entity, GraphicsContext graphicsContext) {
 
@@ -52,6 +57,12 @@ class EnemyHandler implements IEntity{
         graphicsContext.fillRect(300, 200, 48, 48);
     }
 
+    @Override
+    public void healPlayer(int heal) {
+        log.info("Network player health: " + health);
+        health -= heal;
+    }
+
     @Override
     public BoundingBox getBoxCollider() {
         return boxCollider;
@@ -68,9 +79,9 @@ class EnemyHandler implements IEntity{
     }
 
     @Override
-    public int gotHit(int damageDone) {
-        log.debug(health);
-        return health -= damageDone;
+    public void gotHit(int damageDone) {
+        log.debug("Network player health: " + health);
+        health -= damageDone;
     }
 
     @Override

src/main/java/de/hdm_stuttgart/battlearena/Model/Inputs/InputHandler.java

@@ -18,26 +18,51 @@ public class InputHandler {
         return inputHandler;
     }
 
+    //Local Player/Player one controls
     private boolean moveUp, moveDown, moveLeft, moveRight, attack;
 
+    //Local player two controls
+    private boolean sdMoveUp, sdMoveDown, sdMoveLeft, sdMoveRight, sdAttack;
+
     public void handleKeyPress(KeyEvent event) {
         KeyCode code = event.getCode();
 
         switch (code) {
             case W:
                 moveUp = true;
+                log.debug("Player move up");
                 break;
             case S:
                 moveDown = true;
+                log.debug("Player move down");
                 break;
             case A:
                 moveLeft = true;
+                log.debug("Player move left");
                 break;
             case D:
                 moveRight = true;
+                log.debug("Player move right");
                 break;
-            case SPACE:
+            case E:
                 attack = true;
+                log.debug("Player attack");
+                break;
+            case UP:
+                sdMoveUp = true;
+                break;
+            case DOWN:
+                sdMoveDown = true;
+                break;
+            case LEFT:
+                sdMoveLeft = true;
+                break;
+            case RIGHT:
+                sdMoveRight = true;
+                break;
+            case MINUS:
+                sdAttack = true;
+                break;
         }
     }
 
@@ -57,8 +82,24 @@ public class InputHandler {
             case D:
                 moveRight = false;
                 break;
-            case SPACE:
+            case E:
                 attack = false;
+                break;
+            case UP:
+                sdMoveUp = false;
+                break;
+            case DOWN:
+                sdMoveDown = false;
+                break;
+            case LEFT:
+                sdMoveLeft = false;
+                break;
+            case RIGHT:
+                sdMoveRight = false;
+                break;
+            case MINUS:
+                sdAttack = false;
+                break;
         }
     }
 
@@ -81,4 +122,24 @@ public class InputHandler {
     public boolean isAttack() {
         return attack;
     }
+
+    public boolean isSdMoveUp() {
+        return sdMoveUp;
+    }
+
+    public boolean isSdMoveDown() {
+        return sdMoveDown;
+    }
+
+    public boolean isSdMoveLeft() {
+        return sdMoveLeft;
+    }
+
+    public boolean isSdMoveRight() {
+        return sdMoveRight;
+    }
+
+    public boolean isSdAttack() {
+        return sdAttack;
+    }
 }
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Model/Map/BackgroundTile.java

@@ -10,11 +10,12 @@ class BackgroundTile implements ITile{
     private static final Logger log = LogManager.getLogger(BackgroundTile.class);
 
     private final Image tileSprite;
-    private final boolean isWalkable;
+    private final boolean isWalkable, isDestructible;
 
-    public BackgroundTile(Image tileSprite, boolean isWalkable) {
+    public BackgroundTile(Image tileSprite, boolean isWalkable, boolean isDestructible) {
         this.tileSprite = tileSprite;
         this.isWalkable = isWalkable;
+        this.isDestructible = isDestructible;
     }
 
     @Override
@@ -22,6 +23,11 @@ class BackgroundTile implements ITile{
         log.debug("Collision type: " + isWalkable + " returned.");
         return isWalkable;
     }
+    @Override
+    public boolean getDestruction() {
+        log.debug("Collision type: " + isDestructible + " returned.");
+        return isWalkable;
+    }
 
     @Override
     public Image getTileSprite() {

src/main/java/de/hdm_stuttgart/battlearena/Model/Map/ITile.java

@@ -4,5 +4,6 @@ import javafx.scene.image.Image;
 
 public interface ITile {
     boolean getCollision();
+    boolean getDestruction();
     Image getTileSprite();
 }
\ No newline at end of file

src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileFactory.java

@@ -9,13 +9,19 @@ public class TileFactory {
 
     private static final Logger log = LogManager.getLogger(TileFactory.class);
 
-    public static ITile createTile(TileType tileType, Image tileSprite) {
-        if (tileType == TileType.WALKABLE) {
-            log.debug("Tile with type: " + tileType + " created.");
-            return new BackgroundTile(tileSprite, true);
-        } else if (tileType == TileType.NON_WALKABLE) {
-            log.debug("Tile with type: " + tileType + " created.");
-            return new BackgroundTile(tileSprite, false);
+    public static ITile createTile(TileType tileType, TileType tileType2, Image tileSprite) {
+        if (tileType == TileType.WALKABLE && tileType2 == TileType.DESTRUCTIBLE) {
+            log.info("Tile with type: " + tileType + " " + tileType2 + " created.");
+            return new BackgroundTile(tileSprite, true, true);
+        }else if (tileType == TileType.WALKABLE && tileType2 == TileType.NON_DESTRUCTIBLE) {
+            log.info("Tile with type: " + tileType + " " + tileType2 +" created.");
+            return new BackgroundTile(tileSprite, true, false);
+        }else if (tileType == TileType.NON_WALKABLE && tileType2 == TileType.DESTRUCTIBLE) {
+            log.info("Tile with type: " + tileType + " " + tileType2 +" created.");
+            return new BackgroundTile(tileSprite, false, true);
+        }else if (tileType == TileType.NON_WALKABLE && tileType2 == TileType.NON_DESTRUCTIBLE) {
+            log.info("Tile with type: " + tileType + " " + tileType2 +" created.");
+            return new BackgroundTile(tileSprite, false, false);
         }
 
         log.error("TileType: " + tileType + " not supported!");

src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileManager.java

@@ -14,7 +14,7 @@ public class TileManager {
 
     private final GraphicsContext graphicsContext2D;
     private final ITile[] tileSet;
-    private final int[][] tileMap;
+    public static int[][] tileMap;
 
     private final int horizontalTileCount;
     private final int verticalTileCount;
@@ -34,16 +34,18 @@ public class TileManager {
 
     private void createTiles() {
         try {
-            tileSet[0] = TileFactory.createTile(TileType.WALKABLE,
+            tileSet[0] = TileFactory.createTile(TileType.WALKABLE, TileType.NON_DESTRUCTIBLE,
                     new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/Grass01.png"))));
-            tileSet[1] = TileFactory.createTile(TileType.WALKABLE,
+            tileSet[1] = TileFactory.createTile(TileType.WALKABLE, TileType.NON_DESTRUCTIBLE,
                     new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/Grass02.png"))));
-            tileSet[2] = TileFactory.createTile(TileType.WALKABLE,
+            tileSet[2] = TileFactory.createTile(TileType.WALKABLE, TileType.NON_DESTRUCTIBLE,
                     new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/Grass04.png"))));
-            tileSet[3] = TileFactory.createTile(TileType.NON_WALKABLE,
+            tileSet[3] = TileFactory.createTile(TileType.NON_WALKABLE, TileType.DESTRUCTIBLE,
                     new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/Stone01.png"))));
-            tileSet[4] = TileFactory.createTile(TileType.NON_WALKABLE,
+            tileSet[4] = TileFactory.createTile(TileType.NON_WALKABLE, TileType.DESTRUCTIBLE,
                     new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/Stone02.png"))));
+            tileSet[5] = TileFactory.createTile(TileType.WALKABLE,TileType.NON_DESTRUCTIBLE,
+                    new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/map/finalheart.png"))));
         } catch (Exception e) {
             log.error(e);
         }

src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileType.java

@@ -2,5 +2,8 @@ package de.hdm_stuttgart.battlearena.Model.Map;
 
 public enum TileType {
     WALKABLE,
-    NON_WALKABLE
+    NON_WALKABLE,
+    DESTRUCTIBLE,
+    NON_DESTRUCTIBLE
+
 }
\ No newline at end of file