TileManager.java: Changed: tileMap to public static, Added: new Tile and 1 new...

TileManager.java: Changed: tileMap to public static, Added: new Tile and 1 new TileType from TileFactory.java
TileFactory.java: Added: new Tiletype "destructible"
TileType.java: Added 2 new enumTypes
GameSceneController.java: Changed: diffTileCount to 6, Added checkHealTile in renderContent Method
Player.java: Added TileManager import, checkHealTile Method, Added new Code in attack Method to make a heart spawn when attacking an enemy, started using healPlayer Method
NetworkPlayerTwo.java: Added checkHealTile Method and healPlayerMethod
ITile.java: Added getDestruction Method
IEntity.java: Added checkHealTile and healPlayer
BackgroundTile.java: Added Methods for destruction type

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

@@ -54,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 " +
@@ -67,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;
 
 
@@ -113,6 +113,8 @@ public class GameSceneController implements Initializable {
         tileManager.renderMap();
         player.renderEntity(graphicsContext);
         enemy.renderEntity(graphicsContext);
+        player.checkHealTile(player, graphicsContext2D);
+        enemy.checkHealTile(enemy, graphicsContext2D);
     }
 
     public IEntity getEnemy() {

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

@@ -12,13 +12,17 @@ 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();
 

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

@@ -36,6 +36,11 @@ class NetworkPlayerTwo implements IEntity{
 
     }
 
+    @Override
+    public void checkHealTile(IEntity entity, GraphicsContext graphicsContext) {
+
+    }
+
     @Override
     public void attack(IEntity entity, GraphicsContext graphicsContext) {
 
@@ -52,6 +57,12 @@ class NetworkPlayerTwo 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;

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

@@ -4,6 +4,7 @@ import de.hdm_stuttgart.battlearena.Controller.Enum.PlayerMode;
 import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
 import de.hdm_stuttgart.battlearena.Model.Inputs.InputHandler;
 
+import de.hdm_stuttgart.battlearena.Model.Map.TileManager;
 import javafx.geometry.BoundingBox;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.image.Image;
@@ -278,11 +279,31 @@ class Player implements IEntity {
 
         boxCollider = new BoundingBox(mapPosX + 15, mapPosY + 10, playerWidth, playerHeight);
     }
+    @Override
+    public void checkHealTile(IEntity entity, GraphicsContext graphicsContext){
+        int xTile = entity.getMapPosX() / gameSceneController.getScaledTileSize();
+        int yTile = entity.getMapPosY() / gameSceneController.getScaledTileSize();
+        if(TileManager.tileMap[yTile][xTile +1 ] == 5){
+            entity.healPlayer(1);
+            TileManager.tileMap[yTile][xTile +1] = 2;
+            log.info("Healed +1: " + health);
+        }
+    }
 
     @Override
     public void attack(IEntity entity, GraphicsContext graphicsContext) {
         BoundingBox hitBox;
 
+        int xTile = mapPosX / gameSceneController.getScaledTileSize();
+        int yTile = mapPosY / gameSceneController.getScaledTileSize();
+        //log.info(xTile);
+        //log.info(yTile);
+        //int xTile = (int) (Math.random() * (18 - 1));   //Get xTile Coordinate +1 /-1 of playerTile
+        //int yTile = (int) (Math.random() * (18 - 1));   //Get yTile Coordinate +1 /-1 of playerTile
+        double dropChance = 0.5;
+        double randomDropChance = Math.random() * 1;
+        //log.info(randomDropChance);
+
         //Added and subtracted numbers from variables are the pixel insets of the player sprite
 
         int attackRange = 30;
@@ -297,6 +318,12 @@ class Player implements IEntity {
                 if (hitBox.intersects(entity.getBoxCollider())) {
                     entity.gotHit(damage);
                     graphicsContext.strokeText("Hit", 10, 10);
+
+                    if (((TileManager.tileMap[xTile][yTile] == 3) && randomDropChance > dropChance)||
+                            ((TileManager.tileMap[xTile][yTile] == 1)  && randomDropChance > dropChance))
+                        TileManager.tileMap[yTile-1][xTile+1] = 5;
+                    //TileManager.tileMap[yTile-2][xTile] = 5;
+                    //TileManager.tileMap[yTile-3][xTile] = 5;
                 }
             } else if (playerDirection == EntityDirection.DOWN) {
                 hitBox = new BoundingBox(mapPosX + playerWidth, mapPosY + playerHeight, attackWidth, attackRange);
@@ -305,6 +332,12 @@ class Player implements IEntity {
                 if (hitBox.intersects(entity.getBoxCollider())) {
                     entity.gotHit(damage);
                     graphicsContext.strokeText("Hit", 10, 10);
+
+                    if (((TileManager.tileMap[xTile][yTile] == 3) && randomDropChance > dropChance)||
+                            ((TileManager.tileMap[xTile][yTile] == 1)  && randomDropChance > dropChance))
+                        TileManager.tileMap[yTile-1][xTile+1] = 5;
+                    //TileManager.tileMap[yTile-2][xTile] = 5;
+                    //TileManager.tileMap[yTile-3][xTile] = 5;
                 }
             } else if (playerDirection == EntityDirection.LEFT) {
                 hitBox = new BoundingBox(mapPosX - attackWidth, mapPosY + ((double) playerHeight / 2),
@@ -315,6 +348,12 @@ class Player implements IEntity {
                 if (hitBox.intersects(entity.getBoxCollider())) {
                     entity.gotHit(damage);
                     graphicsContext.strokeText("Hit", 10, 10);
+
+                    if (((TileManager.tileMap[xTile][yTile] == 3) && randomDropChance > dropChance)||
+                            ((TileManager.tileMap[xTile][yTile] == 1)  && randomDropChance > dropChance))
+                        TileManager.tileMap[yTile-1][xTile+1] = 5;
+                    //TileManager.tileMap[yTile-2][xTile] = 5;
+                    //TileManager.tileMap[yTile-3][xTile] = 5;
                 }
             } else {
                 hitBox = new BoundingBox(mapPosX + playerWidth + attackWidth, mapPosY + ((double) playerHeight / 2),
@@ -325,6 +364,12 @@ class Player implements IEntity {
                 if (hitBox.intersects(entity.getBoxCollider())) {
                     entity.gotHit(damage);
                     graphicsContext.strokeText("Hit", 10, 10);
+
+                    if (((TileManager.tileMap[xTile][yTile] == 3) && randomDropChance > dropChance)||
+                            ((TileManager.tileMap[xTile][yTile] == 1)  && randomDropChance > dropChance))
+                        TileManager.tileMap[yTile-1][xTile+1] = 5;
+                    //TileManager.tileMap[yTile-2][xTile] = 5;
+                    //TileManager.tileMap[yTile-3][xTile] = 5;
                 }
             }
         }
@@ -393,8 +438,8 @@ class Player implements IEntity {
     public void gotHit(int damageDone) {
         health -= damageDone;
     }
-
-    private void healPlayer(int healthRegenerated) {
+    @Override
+    public void healPlayer(int healthRegenerated) {
         int regeneratedHealth = health + healthRegenerated;
 
         if (regeneratedHealth < maxPlayerHealth) {
@@ -402,7 +447,7 @@ class Player implements IEntity {
         } else {
             health = maxPlayerHealth;
         }
-
+        log.info(health);
     }
 
     @Override

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