diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Controller/GameSceneController.java b/src/main/java/de/hdm_stuttgart/battlearena/Controller/GameSceneController.java
index 34ba629ad41a879a0361d9e4c3f83b92094816e0..cf14c9bff0a9ccd3ea90f4fdf36ca9d624623501 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Controller/GameSceneController.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Controller/GameSceneController.java
@@ -181,15 +181,17 @@ public class GameSceneController implements Initializable {
}
private void updateContent() {
- player.updateEntity(this);
- enemy.updateEntity(this);
+ player.updateEntity(this, graphicsContext2D);
+ enemy.updateEntity(this, graphicsContext2D);
player.attack(enemy, graphicsContext2D);
enemy.attack(player, graphicsContext2D);
updateGameplayObjects();
+ updateExplosionspawns();
player.checkGameplayObjectInteraction(player, graphicsContext2D);
enemy.checkGameplayObjectInteraction(enemy, graphicsContext2D);
- player.placeBomb(player, graphicsContext2D);
- enemy.placeBomb(enemy, graphicsContext2D);
+
+ player.placeBombAction(player, graphicsContext2D);
+ enemy.placeBombAction(enemy, graphicsContext2D);
double playerHP = (double) getPlayer().getHealth() / getPlayer().getMaxEntityHealth();
double enemyHP = (double) getEnemy().getHealth() / getEnemy().getMaxEntityHealth();
if (playerHP >= 0) {
@@ -229,6 +231,13 @@ public class GameSceneController implements Initializable {
runtimeInfo.setGameplayObjects(updateList);
log.debug("Gameplay objects updated");
}
+ private void updateExplosionspawns() {
+ List<IEntity> explosionspawns = runtimeInfo.getExplosionspawns();
+ List<IEntity> updateList = explosionspawns.stream().filter(obj -> obj.getOBJECT_STATUS() != ObjectStatus.USED)
+ .collect(Collectors.toList());
+ runtimeInfo.setExplosionspawns(updateList);
+ log.debug("explosions objects updated");
+ }
public IEntity getEnemy() {
return enemy;
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/RuntimeInfo.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/RuntimeInfo.java
index bc522e9527d8961a84400613a6d44d6e55a17bc9..30d2ba1fcd4d47519db2a1a4c8fec007398ffcbb 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/RuntimeInfo.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/RuntimeInfo.java
@@ -33,6 +33,9 @@ public class RuntimeInfo {
private List<IEntity> gameplayObjects = new ArrayList<>();
+ private List<IEntity> explosionspawns = new ArrayList<>();
+
+
//Stats Tracking during Gameplay
private int kills = 0;
private int deaths = 0;
@@ -125,6 +128,14 @@ public class RuntimeInfo {
this.gameplayObjects = gameplayObjects;
}
+ public List<IEntity> getExplosionspawns() {
+ return explosionspawns;
+ }
+
+ public void setExplosionspawns(List<IEntity> explosionspawns) {
+ this.explosionspawns = explosionspawns;
+ }
+
public String getMapDataGame() {
return mapDataGame;
}
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityFactory.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityFactory.java
index 40432b15b7eb4de956e968d53fdebdfd231b820d..e15dec5063e815dd25224490547277fc1838eb45 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityFactory.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/EntityFactory.java
@@ -30,18 +30,33 @@ public class EntityFactory {
public static IEntity createGameplayObject(ObjectType objectType, int cordX, int cordY, GraphicsContext graphicsContext) {
if (objectType == ObjectType.HEART) {
return new Heart(cordX, cordY, graphicsContext);
- } else if (objectType == ObjectType.BIG_BOMB) {
- return new BigBomb(cordX, cordY, graphicsContext);
} else if (objectType == ObjectType.BIG_BOMB_ITEMFRAME) {
return new BigBombItemFrame(cordX, cordY, graphicsContext);
} else if (objectType == ObjectType.BLASTUP_ITEMFRAME) {
return new BlastUpItemFrame(cordX, cordY, graphicsContext);
- } else if (objectType == ObjectType.BOMB) {
- return new Bomb(cordX, cordY, graphicsContext);
+ } else if (objectType == ObjectType.BLASTDOWN_ITEMFRAME) {
+ return new BlastDownItemFrame(cordX, cordY, graphicsContext);
+ } else if (objectType == ObjectType.BOMBCLOCK_ITEMFRAME) {
+ return new BombClockItemFrame(cordX, cordY, graphicsContext);
} else if (objectType == ObjectType.EXPLOSION) {
return new Explosion(cordX, cordY, graphicsContext);
+ } else if (objectType == ObjectType.TELEPORT_ITEMFRAME) {
+ return new TeleportationItemFrame(cordX, cordY, graphicsContext);
+ }
+ throw new IllegalArgumentException();
+ }
+ public static IEntity createBombs(ObjectType objectType, int cordX, int cordY, GraphicsContext graphicsContext,int blastradius) {
+ if (objectType == ObjectType.BOMB) {
+ return new Bomb(cordX, cordY, graphicsContext, blastradius);
+ } else if (objectType == ObjectType.BIG_BOMB) {
+ return new BigBomb(cordX, cordY, graphicsContext, blastradius);
+ }
+ throw new IllegalArgumentException();
+ }
+ public static IEntity createMarker(ObjectType objectType, int cordX, int cordY, GraphicsContext graphicsContext,int player) {
+ if (objectType == ObjectType.MARKER) {
+ return new Marker(cordX, cordY, graphicsContext, player);
}
throw new IllegalArgumentException();
}
-
}
\ No newline at end of file
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBomb.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBomb.java
index a5821ab14765c07e7b0f3b69c264798c060acec5..19debfc0250626a78605dd8607737e4bf7dae03e 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBomb.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBomb.java
@@ -1,9 +1,12 @@
package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.RuntimeInfo;
import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityFactory;
import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+import de.hdm_stuttgart.battlearena.Model.Map.TileManager;
import javafx.geometry.BoundingBox;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.image.Image;
@@ -11,23 +14,26 @@ import javafx.scene.image.Image;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
+import java.util.List;
import java.util.Objects;
public class BigBomb implements IEntity {
- private boolean status;
- private static final Logger log = LogManager.getLogger(Bomb.class);
+ private static final Logger log = LogManager.getLogger(BigBomb.class);
+ RuntimeInfo runtimeInfo = RuntimeInfo.getInstance();
private final int posX;
private final int posY;
private int frameIndex = 0;
private int frameCounter = 0;
- private Image[] frames = new Image[6];
+ private final Image[] frames = new Image[6];
private final GraphicsContext graphicsContext;
private BoundingBox boxCollider;
private final ObjectType OBJECT_TYPE = ObjectType.BOMB;
private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+ private final int scaledTileSize = 48;
+ private int blastradius = 18;
- public BigBomb(int posX, int posY, GraphicsContext graphicsContext) {
+ public BigBomb(int posX, int posY, GraphicsContext graphicsContext, int blastradius) {
this.posX = posX;
this.posY = posY;
this.graphicsContext = graphicsContext;
@@ -46,13 +52,10 @@ public class BigBomb implements IEntity {
frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/big_bomb/Bigbomb.png")));
frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/big_bomb/Bigbomb.png")));
frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/bomb/redbomb.png")));
- frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/bigexplosion.png")));
- frames[4] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/middleexplosion.png")));
- frames[5] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/smallexplosion.png")));
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -62,7 +65,7 @@ public class BigBomb implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -87,22 +90,173 @@ public class BigBomb implements IEntity {
if (frameCounter > 17) {
if (frameIndex == 0) {
frameIndex = 1;
- //PLayer.spawnExplosion();
} else if (frameIndex == 1) {
frameIndex = 2;
} else if (frameIndex == 2) {
frameIndex = 3;
- } else if (frameIndex == 3) {
- frameIndex = 4;
- } else if (frameIndex == 4) {
- frameIndex = 5;
- }else if( frameIndex == 5){
+ checkExplosionSpawn(graphicsContext,blastradius);
OBJECT_STATUS = ObjectStatus.USED;
}
frameCounter = 0;
}
}
+ public void checkExplosionSpawn(GraphicsContext graphicsContext, int blastradius) {
+ int isDestructible;
+ boolean stopDown = false, stopUp = false, stopRight = false, stopLeft = false;
+
+ int xTile = posX / scaledTileSize;
+ int yTile = posY / scaledTileSize;
+ int yUp = yTile;
+ int xRight = xTile;
+ int yDown = yTile;
+ int xLeft = xTile;
+
+ spawnExplosion(yTile, xTile,graphicsContext);
+
+ isDestructible = checkTilePlacing(yTile, xTile);
+ if (isDestructible != 0) {
+ spawnExplosion(yTile,xTile,graphicsContext);
+ for (int i = 0; i < blastradius; i++) {
+ yDown += 1;
+ yUp -= 1;
+ xRight += 1;
+ xLeft -= 1;
+ if(yDown < 18 && yDown >= 0 && xTile < 18 && xTile >= 0) {
+ isDestructible = checkTilePlacing(yDown, xTile);
+ if (isDestructible != 0 && !stopDown) {
+ spawnExplosion(yDown, xTile, graphicsContext);
+ if(isDestructible == 2){
+ stopDown = true;
+ }
+ } else {
+ stopDown = true;
+ }
+ }
+ if(yUp < 18 && yUp >= 0 && xTile < 18 && xTile >= 0) {
+ isDestructible = checkTilePlacing(yUp, xTile);
+ if (isDestructible != 0 && !stopUp) {
+ spawnExplosion(yUp, xTile, graphicsContext);
+ if(isDestructible == 2){
+ stopUp = true;
+ }
+ } else {
+ stopUp = true;
+ }
+ }if(yTile < 18 && yTile >= 0 && xRight < 18 && xRight >= 0) {
+ isDestructible = checkTilePlacing(yTile, xRight);
+ if (isDestructible != 0 && !stopRight) {
+ spawnExplosion(yTile, xRight, graphicsContext);
+ if(isDestructible == 2){
+ stopRight = true;
+ }
+ } else {
+ stopRight = true;
+ }
+ }if(yTile < 18 && yTile >= 0 && xLeft < 18 && xLeft >= 0) {
+ isDestructible = checkTilePlacing(yTile, xLeft);
+ if (isDestructible != 0 && !stopLeft) {
+ spawnExplosion(yTile, xLeft, graphicsContext);
+ if (isDestructible == 2) {
+ stopLeft = true;
+ }
+ } else {
+ stopLeft = true;
+ }
+ }
+ }
+ }
+ }
+
+ public int checkTilePlacing(int y, int x) { //Change it with a DestructionHandler like CollisionHandler //tileSet[xTile].getDestruction();
+ if(TileManager.tileMap[y][x] >= 20){
+ return 2; //Last spawn, in this direction
+ }else if(TileManager.tileMap[y][x] <= 9){
+ return 1; //Keep Going
+ }else{
+ return 0; //dont continue
+ }
+ }
+
+ public void spawnExplosion(int spawnCordY, int spawnCordX, GraphicsContext graphicsContext){
+ List<IEntity> explosionspawns = runtimeInfo.getExplosionspawns();
+ IEntity explosion = EntityFactory.createGameplayObject(ObjectType.EXPLOSION, spawnCordX * scaledTileSize, spawnCordY * scaledTileSize, graphicsContext);
+ explosionspawns.add(explosion);
+ runtimeInfo.setGameplayObjects(explosionspawns);
+ log.debug("Big Bomb explosion placed");
+ changeCheckedTileDestructable(graphicsContext);
+ }
+
+ public void changeCheckedTileDestructable(GraphicsContext graphicsContext){
+ int x,y;
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ List<IEntity> explosionList = gameplayObjects.stream().filter(obj -> obj.getOBJECT_TYPE() == ObjectType.EXPLOSION)
+ .toList();
+ for (IEntity entity : explosionList) {
+ y = (entity.getMapPosY()) / scaledTileSize;
+ x = (entity.getMapPosX()) / scaledTileSize;
+ if (TileManager.tileMap[y][x] > 19) {
+ TileManager.tileMap[y][x] = 0;
+
+ //spawning item entitys
+ spawnItems(x * scaledTileSize, y * scaledTileSize, graphicsContext);
+ }
+ }
+ }
+
+ public void spawnItems(int x, int y,GraphicsContext graphicsContext){
+ final double dropChanceBigBombItemFrame = 0.1;
+ final double dropChanceHeart = 0.15;
+ final double dropChanceBlastUpItemFrame = 0.15;
+ final double dropChanceBlastDownItemFrame = 0.15;
+ final double dropChanceBombClock = 0.1;
+ final double dropChanceTeleportItemFrame = 0.15;
+ double randomDropChance = Math.random() * 1;
+
+ if (randomDropChance < dropChanceBigBombItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity heart = EntityFactory.createGameplayObject(ObjectType.BIG_BOMB_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(heart);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BigBombItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity bigBombItemFrame = EntityFactory.createGameplayObject(ObjectType.HEART, x, y, graphicsContext);
+ gameplayObjects.add(bigBombItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.debug("heart dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity blastUpItemFrame = EntityFactory.createGameplayObject(ObjectType.BLASTUP_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(blastUpItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BlastUpItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBlastDownItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity blastDownItemFrame = EntityFactory.createGameplayObject(ObjectType.BLASTDOWN_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(blastDownItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BlastUpItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBlastDownItemFrame + dropChanceBombClock) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity bombClockItemFrame = EntityFactory.createGameplayObject(ObjectType.BOMBCLOCK_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(bombClockItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BombClockItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBombClock + dropChanceTeleportItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity teleportItemFrame = EntityFactory.createGameplayObject(ObjectType.TELEPORT_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(teleportItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("TeleportItemFrame dropped");
+ }
+ }
+
@Override
public void healPlayer(int heal) {
@@ -153,6 +307,11 @@ public class BigBomb implements IEntity {
OBJECT_STATUS = objectStatus;
}
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
@Override
public int getHealth() {
return 0;
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBombItemFrame.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBombItemFrame.java
index 790cc0de444243cd6004342b5894a751231b3692..442b1d287d94128f63fd6789af450137f51b6c7c 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBombItemFrame.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BigBombItemFrame.java
@@ -15,7 +15,6 @@ import java.util.Objects;
public class BigBombItemFrame implements IEntity {
- private boolean status;
private static final Logger log = LogManager.getLogger(Bomb.class);
private final int posX;
@@ -53,7 +52,7 @@ public class BigBombItemFrame implements IEntity {
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -63,7 +62,7 @@ public class BigBombItemFrame implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -149,6 +148,11 @@ public class BigBombItemFrame implements IEntity {
OBJECT_STATUS = objectStatus;
}
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
@Override
public int getHealth() {
return 0;
@@ -158,6 +162,5 @@ public class BigBombItemFrame implements IEntity {
public int getMaxEntityHealth() {
return 0;
}
-
}
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastDownItemFrame.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastDownItemFrame.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bca8c9f47862d873f9594f135e5d0825a793725
--- /dev/null
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastDownItemFrame.java
@@ -0,0 +1,163 @@
+package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
+
+import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+
+import javafx.geometry.BoundingBox;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.image.Image;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import java.util.Objects;
+
+
+public class BlastDownItemFrame implements IEntity {
+ private static final Logger log = LogManager.getLogger(BlastDownItemFrame.class);
+ private final int posX;
+ private final int posY;
+
+ private int frameIndex = 0;
+ private int frameCounter = 0;
+ private Image[] frames = new Image[4];
+ private final GraphicsContext graphicsContext;
+ private BoundingBox boxCollider;
+ private final ObjectType OBJECT_TYPE = ObjectType.BLASTDOWN_ITEMFRAME;
+ private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+
+ public BlastDownItemFrame(int posX, int posY, GraphicsContext graphicsContext) {
+ this.posX = posX;
+ this.posY = posY;
+ this.graphicsContext = graphicsContext;
+
+ initializeEntity();
+ }
+
+ @Override
+ public void initializeEntity() {
+ loadEntitySprites();
+ boxCollider = new BoundingBox(posX + 12, posY + 12, 24, 24);
+ }
+
+ @Override
+ public void loadEntitySprites() {
+ frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastDownItemFrameUp.png")));
+ frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastDownItemFrameMiddle.png")));
+ frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastDownItemFrameDown.png")));
+ frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastDownItemFrameMiddle.png")));
+ }
+
+
+ @Override
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void attack(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void updateEntityWalkAnimation() {
+
+ }
+
+ public void renderEntity(GraphicsContext graphicsContext) {
+ graphicsContext.drawImage(frames[frameIndex], posX, posY, 48, 48);
+ updateAnimation();
+ }
+ private void updateAnimation() {
+ frameCounter++;
+
+ if (frameCounter > 25) {
+ if (frameIndex == 0) {
+ frameIndex = 1;
+ } else if (frameIndex == 1) {
+ frameIndex = 2;
+ } else if (frameIndex == 2) {
+ frameIndex = 3;
+ } else if (frameIndex == 3) {
+ frameIndex = 0;
+ }
+ frameCounter = 0;
+ }
+ }
+
+ @Override
+ public void healPlayer(int heal) {
+
+ }
+
+ @Override
+ public BoundingBox getBoxCollider() {
+ return boxCollider;
+ }
+
+ @Override
+ public EntityDirection getEntityDirection() {
+ return null;
+ }
+
+ @Override
+ public int getEntitySpeed() {
+ return 0;
+ }
+
+ @Override
+ public void gotHit(int damageDone) {
+
+ }
+
+ @Override
+ public int getMapPosX() {
+ return posX;
+ }
+
+ @Override
+ public int getMapPosY() {
+ return posY;
+ }
+
+ @Override
+ public ObjectType getOBJECT_TYPE() {
+ return OBJECT_TYPE;
+ }
+
+ @Override
+ public ObjectStatus getOBJECT_STATUS() {
+ return OBJECT_STATUS;
+ }
+
+ @Override
+ public void setObjectStatus(ObjectStatus objectStatus) {
+ OBJECT_STATUS = objectStatus;
+ }
+
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
+ @Override
+ public int getHealth() {
+ return 0;
+ }
+
+ @Override
+ public int getMaxEntityHealth() {
+ return 0;
+ }
+}
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastUpItemFrame.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastUpItemFrame.java
index 613664880e59ac0ce569d06a51b153fd7247003f..7b242d0a590a7a1da232db5890fa9ea762b2a2b3 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastUpItemFrame.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BlastUpItemFrame.java
@@ -15,9 +15,7 @@ import java.util.Objects;
public class BlastUpItemFrame implements IEntity {
- private boolean status;
-
- private static final Logger log = LogManager.getLogger(Bomb.class);
+ private static final Logger log = LogManager.getLogger(BlastUpItemFrame.class);
private final int posX;
private final int posY;
@@ -45,15 +43,15 @@ public class BlastUpItemFrame implements IEntity {
@Override
public void loadEntitySprites() {
- frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastItemFrameUp.png")));
- frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastItemFrameMiddle.png")));
- frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastItemFrameDown.png")));
- frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastItemFrameMiddle.png")));
+ frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastUpItemFrameUp.png")));
+ frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastUpItemFrameMiddle.png")));
+ frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastUpItemFrameDown.png")));
+ frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/BlastUpItemFrameMiddle.png")));
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -63,7 +61,7 @@ public class BlastUpItemFrame implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -81,13 +79,12 @@ public class BlastUpItemFrame implements IEntity {
graphicsContext.drawImage(frames[frameIndex], posX, posY, 48, 48);
updateAnimation();
}
- private void updateAnimation() { //Easily add more frames
+ private void updateAnimation() {
frameCounter++;
- if (frameCounter > 25) { //17
+ if (frameCounter > 25) {
if (frameIndex == 0) {
frameIndex = 1;
- //PLayer.spawnExplosion();
} else if (frameIndex == 1) {
frameIndex = 2;
} else if (frameIndex == 2) {
@@ -150,6 +147,11 @@ public class BlastUpItemFrame implements IEntity {
}
@Override
+
+ public int getplayer() {
+ return 0;
+ }
+
public int getHealth() {
return 0;
}
@@ -159,4 +161,4 @@ public class BlastUpItemFrame implements IEntity {
return 0;
}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Bomb.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Bomb.java
index f586f7f5c44945ff17e055d5436d47823c18e0fc..f919ee7c7a3b950ef8e36911448d6235a9bc9c06 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Bomb.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Bomb.java
@@ -1,11 +1,17 @@
package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.RuntimeInfo;
import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityFactory;
import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+
+import de.hdm_stuttgart.battlearena.Model.Map.TileManager;
+
import de.hdm_stuttgart.battlearena.Model.Sound.SFX;
import de.hdm_stuttgart.battlearena.Model.Sound.SoundEffects;
+
import javafx.geometry.BoundingBox;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.image.Image;
@@ -13,28 +19,33 @@ import javafx.scene.image.Image;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
+import java.util.List;
import java.util.Objects;
public class Bomb implements IEntity {
- private boolean status;
-
private static final Logger log = LogManager.getLogger(Bomb.class);
+ RuntimeInfo runtimeInfo = RuntimeInfo.getInstance();
private final int posX;
private final int posY;
private int frameIndex = 0;
private int frameCounter = 0;
- private Image[] frames = new Image[6];
+ private final Image[] frames = new Image[6];
private final GraphicsContext graphicsContext;
private BoundingBox boxCollider;
private final ObjectType OBJECT_TYPE = ObjectType.BOMB;
private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+
+ private final int scaledTileSize = 48;
+ private int blastradius;
+
//private SoundEffects soundEffects;
- public Bomb(int posX, int posY, GraphicsContext graphicsContext) {
+
+ public Bomb(int posX, int posY, GraphicsContext graphicsContext, int blastradius) {
this.posX = posX;
this.posY = posY;
this.graphicsContext = graphicsContext;
-
+ this.blastradius = blastradius;
initializeEntity();
}
@@ -49,13 +60,10 @@ public class Bomb implements IEntity {
frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/bomb/bomb.png")));
frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/bomb/bomb.png")));
frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/bomb/redbomb.png")));
- frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/bigexplosion.png")));
- frames[4] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/middleexplosion.png")));
- frames[5] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/smallexplosion.png")));
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -65,7 +73,7 @@ public class Bomb implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -91,23 +99,177 @@ public class Bomb implements IEntity {
if (frameIndex == 0) {
frameIndex = 1;
- //PLayer.spawnExplosion();
} else if (frameIndex == 1) {
frameIndex = 2;
} else if (frameIndex == 2) {
frameIndex = 3;
+
+ checkExplosionSpawn(graphicsContext, blastradius);
+
//soundEffects.playSoundEffectOnce(SFX.BOMB);
- } else if (frameIndex == 3) {
- frameIndex = 4;
- } else if (frameIndex == 4) {
- frameIndex = 5;
- } else if (frameIndex == 5) {
+
+
OBJECT_STATUS = ObjectStatus.USED;
}
frameCounter = 0;
}
}
+ public void checkExplosionSpawn(GraphicsContext graphicsContext, int blastradius) {
+
+ int isDestructible;
+ boolean stopDown = false, stopUp = false, stopRight = false, stopLeft = false;
+
+ int xTile = posX / scaledTileSize;
+ int yTile = posY / scaledTileSize;
+ int yUp = yTile;
+ int xRight = xTile;
+ int yDown = yTile;
+ int xLeft = xTile;
+ spawnExplosion(yTile, xTile,graphicsContext);
+
+ isDestructible = checkTilePlacing(yTile, xTile);
+ if (isDestructible != 0) {
+ spawnExplosion(yTile,xTile,graphicsContext);
+ for (int i = 0; i < blastradius; i++) {
+ yDown += 1;
+ yUp -= 1;
+ xRight += 1;
+ xLeft -= 1;
+ if(yDown < 18 && yDown >= 0 && xTile < 18 && xTile >= 0) {
+ isDestructible = checkTilePlacing(yDown, xTile);
+ if (isDestructible != 0 && !stopDown) {
+ spawnExplosion(yDown, xTile, graphicsContext);
+ if(isDestructible == 2){
+ stopDown = true;
+ }
+ } else {
+ stopDown = true;
+ }
+ }
+ if(yUp < 18 && yUp >= 0 && xTile < 18 && xTile >= 0) {
+ isDestructible = checkTilePlacing(yUp, xTile);
+ if (isDestructible != 0 && !stopUp) {
+ spawnExplosion(yUp, xTile, graphicsContext);
+ if(isDestructible == 2){
+ stopUp = true;
+ }
+ } else {
+ stopUp = true;
+ }
+ }if(yTile < 18 && yTile >= 0 && xRight < 18 && xRight >= 0) {
+ isDestructible = checkTilePlacing(yTile, xRight);
+ if (isDestructible != 0 && !stopRight) {
+ spawnExplosion(yTile, xRight, graphicsContext);
+ if(isDestructible == 2){
+ stopRight = true;
+ }
+ } else {
+ stopRight = true;
+ }
+ }if(yTile < 18 && yTile >= 0 && xLeft < 18 && xLeft >= 0) {
+ isDestructible = checkTilePlacing(yTile, xLeft);
+ if (isDestructible != 0 && !stopLeft) {
+ spawnExplosion(yTile, xLeft, graphicsContext);
+ if (isDestructible == 2) {
+ stopLeft = true;
+ }
+ } else {
+ stopLeft = true;
+ }
+ }
+ }
+ }
+ }
+
+ public void spawnExplosion(int spawnCordY, int spawnCordX, GraphicsContext graphicsContext){
+ List<IEntity> explosionspawns = runtimeInfo.getExplosionspawns();
+ IEntity explosion = EntityFactory.createGameplayObject(ObjectType.EXPLOSION, spawnCordX * scaledTileSize, spawnCordY * scaledTileSize, graphicsContext);
+ explosionspawns.add(explosion);
+ runtimeInfo.setGameplayObjects(explosionspawns);
+ log.debug("explosion placed");
+ changeCheckedTileDestructable(graphicsContext);
+ }
+
+ public int checkTilePlacing(int y, int x) { //Change it with a DestructionHandler like CollisionHandler //tileSet[xTile].getDestruction();
+ if(TileManager.tileMap[y][x] >= 20){
+ return 2; //Last spawn, in this direction
+ }else if(TileManager.tileMap[y][x] <= 9){
+ return 1; //Keep Going
+ }else{
+ return 0; //dont continue
+ }
+ }
+ public void changeCheckedTileDestructable(GraphicsContext graphicsContext){
+ int x,y;
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ List<IEntity> explosionList = gameplayObjects.stream().filter(obj -> obj.getOBJECT_TYPE() == ObjectType.EXPLOSION)
+ .toList();
+ for (IEntity entity : explosionList) {
+ y = (entity.getMapPosY()) / scaledTileSize;
+ x = (entity.getMapPosX()) / scaledTileSize;
+ if (TileManager.tileMap[y][x] > 19) {
+ TileManager.tileMap[y][x] = 0;
+
+ //spawning item entitys
+ spawnItems(x * scaledTileSize, y * scaledTileSize, graphicsContext);
+ }
+ }
+ }
+
+ public void spawnItems(int x, int y,GraphicsContext graphicsContext){
+ final double dropChanceBigBombItemFrame = 0.1;
+ final double dropChanceHeart = 0.15;
+ final double dropChanceBlastUpItemFrame = 0.15;
+ final double dropChanceBlastDownItemFrame = 0.15;
+ final double dropChanceBombClock = 0.1;
+ final double dropChanceTeleportItemFrame = 0.15;
+ double randomDropChance = Math.random() * 1;
+
+ if (randomDropChance < dropChanceBigBombItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity heart = EntityFactory.createGameplayObject(ObjectType.BIG_BOMB_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(heart);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BigBombItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity bigBombItemFrame = EntityFactory.createGameplayObject(ObjectType.HEART, x, y, graphicsContext);
+ gameplayObjects.add(bigBombItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.debug("heart dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity blastUpItemFrame = EntityFactory.createGameplayObject(ObjectType.BLASTUP_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(blastUpItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BlastUpItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBlastDownItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity blastDownItemFrame = EntityFactory.createGameplayObject(ObjectType.BLASTDOWN_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(blastDownItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BlastUpItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBlastDownItemFrame + dropChanceBombClock) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity bombClock = EntityFactory.createGameplayObject(ObjectType.BOMBCLOCK_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(bombClock);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("BombClockItemFrame dropped");
+ }
+ else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame + dropChanceBlastDownItemFrame + dropChanceBombClock + dropChanceTeleportItemFrame) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ IEntity teleportItemFrame = EntityFactory.createGameplayObject(ObjectType.TELEPORT_ITEMFRAME, x, y, graphicsContext);
+ gameplayObjects.add(teleportItemFrame);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.info("TeleportItemFrame dropped");
+ }
+ }
+
@Override
public void healPlayer(int heal) {
@@ -158,6 +320,11 @@ public class Bomb implements IEntity {
OBJECT_STATUS = objectStatus;
}
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
@Override
public int getHealth() {
return 0;
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BombClockItemFrame.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BombClockItemFrame.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1fbbb357926b7fb947ac987918e10c13e881953
--- /dev/null
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/BombClockItemFrame.java
@@ -0,0 +1,163 @@
+package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
+
+import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+import javafx.geometry.BoundingBox;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.image.Image;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Objects;
+
+
+public class BombClockItemFrame implements IEntity {
+
+ private static final Logger log = LogManager.getLogger(BombClockItemFrame.class);
+ private final int posX;
+ private final int posY;
+
+ private int frameIndex = 0;
+ private int frameCounter = 0;
+ private Image[] frames = new Image[4];
+ private final GraphicsContext graphicsContext;
+ private BoundingBox boxCollider;
+ private final ObjectType OBJECT_TYPE = ObjectType.BOMBCLOCK_ITEMFRAME;
+ private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+
+ public BombClockItemFrame(int posX, int posY, GraphicsContext graphicsContext) {
+ this.posX = posX;
+ this.posY = posY;
+ this.graphicsContext = graphicsContext;
+
+ initializeEntity();
+ }
+
+ @Override
+ public void initializeEntity() {
+ loadEntitySprites();
+ boxCollider = new BoundingBox(posX + 12, posY + 12, 24, 24);
+ }
+
+ @Override
+ public void loadEntitySprites() {
+ frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/ClockItemFrame1Up.png")));
+ frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/ClockItemFrame2Middle.png")));
+ frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/ClockItemFrame3Down.png")));
+ frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/ClockItemFrame4Middle.png")));
+ }
+
+
+ @Override
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void attack(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void updateEntityWalkAnimation() {
+
+ }
+
+ public void renderEntity(GraphicsContext graphicsContext) {
+ graphicsContext.drawImage(frames[frameIndex], posX, posY, 48, 48);
+ updateAnimation();
+ }
+ private void updateAnimation() {
+ frameCounter++;
+
+ if (frameCounter > 25) {
+ if (frameIndex == 0) {
+ frameIndex = 1;
+ } else if (frameIndex == 1) {
+ frameIndex = 2;
+ } else if (frameIndex == 2) {
+ frameIndex = 3;
+ } else if (frameIndex == 3) {
+ frameIndex = 0;
+ }
+ frameCounter = 0;
+ }
+ }
+
+ @Override
+ public void healPlayer(int heal) {
+
+ }
+
+ @Override
+ public BoundingBox getBoxCollider() {
+ return boxCollider;
+ }
+
+ @Override
+ public EntityDirection getEntityDirection() {
+ return null;
+ }
+
+ @Override
+ public int getEntitySpeed() {
+ return 0;
+ }
+
+ @Override
+ public void gotHit(int damageDone) {
+
+ }
+
+ @Override
+ public int getMapPosX() {
+ return posX;
+ }
+
+ @Override
+ public int getMapPosY() {
+ return posY;
+ }
+
+ @Override
+ public ObjectType getOBJECT_TYPE() {
+ return OBJECT_TYPE;
+ }
+
+ @Override
+ public ObjectStatus getOBJECT_STATUS() {
+ return OBJECT_STATUS;
+ }
+
+ @Override
+ public void setObjectStatus(ObjectStatus objectStatus) {
+ OBJECT_STATUS = objectStatus;
+ }
+
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
+ @Override
+ public int getHealth() {
+ return 0;
+ }
+
+ @Override
+ public int getMaxEntityHealth() {
+ return 0;
+ }
+}
+
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Explosion.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Explosion.java
index 977b890eb602792bc23cb7d347f35b619a424695..c0edb59df1d96100d297b5fe89343ad57e073d56 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Explosion.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Explosion.java
@@ -12,9 +12,6 @@ import org.apache.logging.log4j.Logger;
import java.util.Objects;
public class Explosion implements IEntity {
-
- private boolean status;
-
private static final Logger log = LogManager.getLogger(Explosion.class);
private final int posX;
private final int posY;
@@ -39,16 +36,13 @@ public class Explosion implements IEntity {
}
@Override
public void loadEntitySprites() {
- frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/clear.png")));
- frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/clear.png")));
- frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/clear.png")));
- frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/bigexplosion.png")));
- frames[4] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/middleexplosion.png")));
- frames[5] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/smallexplosion.png")));
+ frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/bigexplosion.png")));
+ frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/middleexplosion.png")));
+ frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/smallexplosion.png")));
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -58,7 +52,7 @@ public class Explosion implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -80,19 +74,12 @@ public class Explosion implements IEntity {
private void updateAnimation() { //Easily add more frames
frameCounter++;
- if (frameCounter > 17) {
+ if (frameCounter > 20) {
if (frameIndex == 0) {
frameIndex = 1;
- //PLayer.spawnExplosion();
} else if (frameIndex == 1) {
frameIndex = 2;
} else if (frameIndex == 2) {
- frameIndex = 3;
- } else if (frameIndex == 3) {
- frameIndex = 4;
- } else if (frameIndex == 4) {
- frameIndex = 5;
- }else if( frameIndex == 5){
OBJECT_STATUS = ObjectStatus.USED;
}
frameCounter = 0;
@@ -148,6 +135,9 @@ public class Explosion implements IEntity {
OBJECT_STATUS = objectStatus;
}
+ @Override
+ public int getplayer() { return 0;}
+
@Override
public int getHealth() {
return 0;
@@ -155,6 +145,7 @@ public class Explosion implements IEntity {
@Override
public int getMaxEntityHealth() {
+
return 0;
}
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Heart.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Heart.java
index db00a108cadf5468cad08a2a3c855fa8121299f4..0245be324c69a0f99fb53b5b3b51aba876ae421f 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Heart.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Heart.java
@@ -36,7 +36,7 @@ public class Heart implements IEntity {
@Override
public void initializeEntity() {
loadEntitySprites();
- boxCollider = new BoundingBox(posX+12, posY+12, 24, 24);
+ boxCollider = new BoundingBox(posX + 12, posY + 12, 24, 24);
}
@Override
@@ -45,7 +45,7 @@ public class Heart implements IEntity {
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -55,7 +55,7 @@ public class Heart implements IEntity {
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -124,6 +124,11 @@ public class Heart implements IEntity {
OBJECT_STATUS = objectStatus;
}
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
@Override
public int getHealth() {
return 0;
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Marker.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Marker.java
new file mode 100644
index 0000000000000000000000000000000000000000..428abb7a82ab72ff63718c8ee8e64865ca6db296
--- /dev/null
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/Marker.java
@@ -0,0 +1,151 @@
+package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
+
+import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.DataStorage.Classes.RuntimeInfo;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityFactory;
+import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+
+import de.hdm_stuttgart.battlearena.Model.Map.TileManager;
+import javafx.geometry.BoundingBox;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.image.Image;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import java.util.List;
+import java.util.Objects;
+
+public class Marker implements IEntity {
+ private static final Logger log = LogManager.getLogger(Marker.class);
+ RuntimeInfo runtimeInfo = RuntimeInfo.getInstance();
+ private final int posX;
+ private final int posY;
+ private final int player;
+ private int frameIndex = 0;
+ private int frameCounter = 0;
+ private Image sprite;
+ private final GraphicsContext graphicsContext;
+ private BoundingBox boxCollider;
+ private final ObjectType OBJECT_TYPE = ObjectType.MARKER;
+ private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+
+ public Marker(int posX, int posY, GraphicsContext graphicsContext, int player) {
+ this.posX = posX;
+ this.posY = posY;
+ this.graphicsContext = graphicsContext;
+ this.player = player;
+
+ initializeEntity();
+ }
+
+ @Override
+ public void initializeEntity() {
+ loadEntitySprites();
+ }
+
+ @Override
+ public void loadEntitySprites() {
+ if(player == 1){
+ sprite = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/Markersmall.png")));
+ } else if(player == 2) {
+ sprite = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/vfx/Markersmalllightblue.png")));
+ }
+ } //Else throw Exception ?
+
+ @Override
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void attack(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void updateEntityWalkAnimation() {
+
+ }
+
+ public void renderEntity(GraphicsContext graphicsContext) {
+ graphicsContext.drawImage(sprite, posX, posY, 48, 48);
+ }
+
+ @Override
+ public void healPlayer(int heal) {
+
+ }
+
+ @Override
+ public BoundingBox getBoxCollider() {
+ return boxCollider;
+ }
+
+ @Override
+ public EntityDirection getEntityDirection() {
+ return null;
+ }
+
+ @Override
+ public int getEntitySpeed() {
+ return 0;
+ }
+
+ @Override
+ public void gotHit(int damageDone) {
+
+ }
+
+ @Override
+ public int getMapPosX() {
+ return posX;
+ }
+
+ @Override
+ public int getMapPosY() {
+ return posY;
+ }
+
+ @Override
+ public ObjectType getOBJECT_TYPE() {
+ return OBJECT_TYPE;
+ }
+
+ @Override
+ public ObjectStatus getOBJECT_STATUS() {
+ return OBJECT_STATUS;
+ }
+
+ @Override
+ public void setObjectStatus(ObjectStatus objectStatus) {
+ OBJECT_STATUS = objectStatus;
+ }
+ @Override
+ public int getplayer(){
+ return player;
+ }
+
+ @Override
+ public int getHealth() {
+ return 0;
+ }
+
+ @Override
+ public int getMaxEntityHealth() {
+ return 0;
+ }
+
+}
+
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/ObjectType.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/ObjectType.java
index 62f47fb70fc0c97b8d37e6ceaf3a6ea932aeb225..b11ccc5f5d81eb0465184ea2983fca487d08220d 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/ObjectType.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/ObjectType.java
@@ -2,10 +2,14 @@ package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
public enum ObjectType {
BLASTUP_ITEMFRAME,
+ BLASTDOWN_ITEMFRAME,
+ BOMBCLOCK_ITEMFRAME,
BLASTUP,
BIG_BOMB_ITEMFRAME,
BIG_BOMB,
BOMB,
HEART,
- EXPLOSION
+ EXPLOSION,
+ MARKER,
+ TELEPORT_ITEMFRAME
}
\ No newline at end of file
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/TeleportationItemFrame.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/TeleportationItemFrame.java
new file mode 100644
index 0000000000000000000000000000000000000000..447266fa9b65a3e9c6e517f765e75ea949673861
--- /dev/null
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/GameplayObjects/TeleportationItemFrame.java
@@ -0,0 +1,162 @@
+package de.hdm_stuttgart.battlearena.Model.Entity.GameplayObjects;
+
+import de.hdm_stuttgart.battlearena.Controller.GameSceneController;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Entity.IEntity;
+import javafx.geometry.BoundingBox;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.image.Image;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Objects;
+
+
+public class TeleportationItemFrame implements IEntity {
+ private static final Logger log = LogManager.getLogger(TeleportationItemFrame.class);
+ private final int posX;
+ private final int posY;
+ private int frameIndex = 0;
+ private int frameCounter = 0;
+ private Image[] frames = new Image[4];
+ private final GraphicsContext graphicsContext;
+ private BoundingBox boxCollider;
+ private final ObjectType OBJECT_TYPE = ObjectType.TELEPORT_ITEMFRAME;
+ private ObjectStatus OBJECT_STATUS = ObjectStatus.UNUSED;
+
+ public TeleportationItemFrame(int posX, int posY, GraphicsContext graphicsContext) {
+ this.posX = posX;
+ this.posY = posY;
+ this.graphicsContext = graphicsContext;
+
+ initializeEntity();
+ }
+
+ @Override
+ public void initializeEntity() {
+ loadEntitySprites();
+ boxCollider = new BoundingBox(posX + 12, posY + 12, 24, 24);
+ }
+
+ @Override
+ public void loadEntitySprites() {
+ frames[0] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/AmogUsUp.png")));
+ frames[1] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/AmogUsMiddle.png")));
+ frames[2] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/AmogUsDown.png")));
+ frames[3] = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/textures/objects/itemFrames/AmogUsMiddle.png")));
+ }
+
+
+ @Override
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void attack(IEntity entity, GraphicsContext graphicsContext) {
+
+ }
+
+ @Override
+ public void updateEntityWalkAnimation() {
+
+ }
+
+ public void renderEntity(GraphicsContext graphicsContext) {
+ graphicsContext.drawImage(frames[frameIndex], posX, posY, 48, 48);
+ updateAnimation();
+ }
+ private void updateAnimation() {
+ frameCounter++;
+
+ if (frameCounter > 25) {
+ if (frameIndex == 0) {
+ frameIndex = 1;
+ } else if (frameIndex == 1) {
+ frameIndex = 2;
+ } else if (frameIndex == 2) {
+ frameIndex = 3;
+ } else if (frameIndex == 3) {
+ frameIndex = 0;
+ }
+ frameCounter = 0;
+ }
+ }
+
+ @Override
+ public void healPlayer(int heal) {
+
+ }
+
+ @Override
+ public BoundingBox getBoxCollider() {
+ return boxCollider;
+ }
+
+ @Override
+ public EntityDirection getEntityDirection() {
+ return null;
+ }
+
+ @Override
+ public int getEntitySpeed() {
+ return 0;
+ }
+
+ @Override
+ public void gotHit(int damageDone) {
+
+ }
+
+ @Override
+ public int getMapPosX() {
+ return posX;
+ }
+
+ @Override
+ public int getMapPosY() {
+ return posY;
+ }
+
+ @Override
+ public ObjectType getOBJECT_TYPE() {
+ return OBJECT_TYPE;
+ }
+
+ @Override
+ public ObjectStatus getOBJECT_STATUS() {
+ return OBJECT_STATUS;
+ }
+
+ @Override
+ public void setObjectStatus(ObjectStatus objectStatus) {
+ OBJECT_STATUS = objectStatus;
+ }
+
+ @Override
+ public int getplayer() {
+ return 0;
+ }
+
+ @Override
+ public int getHealth() {
+ return 0;
+ }
+
+ @Override
+ public int getMaxEntityHealth() {
+ return 0;
+ }
+}
+
+
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/IEntity.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/IEntity.java
index 3d9cfc2bcbd713b797f95f13cc3f9517175076f0..336332169b1e9c5e90438cc9672426bf53a84838 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/IEntity.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/IEntity.java
@@ -12,12 +12,12 @@ public interface IEntity {
void loadEntitySprites();
- void updateEntity(GameSceneController gameScene);
+ void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext);
//checks collision with GameplayObjects by iterating through GameplayObjects list
void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext);
- void placeBomb(IEntity entity, GraphicsContext graphicsContext);
+ void placeBombAction(IEntity entity, GraphicsContext graphicsContext);
void attack(IEntity entity, GraphicsContext graphicsContext);
@@ -42,8 +42,12 @@ public interface IEntity {
ObjectType getOBJECT_TYPE();
ObjectStatus getOBJECT_STATUS();
+
void setObjectStatus(ObjectStatus objectStatus);
+ int getplayer();
+
int getHealth();
int getMaxEntityHealth();
+
}
\ No newline at end of file
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/NetworkPlayerTwo.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/NetworkPlayerTwo.java
index d04ca21c3307bfba4250b3c8599685f4b19f0808..cdd2277a1710c10a8ec54d9539123fda0e22161c 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/NetworkPlayerTwo.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/NetworkPlayerTwo.java
@@ -34,7 +34,7 @@ class NetworkPlayerTwo implements IEntity{
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
}
@@ -44,7 +44,7 @@ class NetworkPlayerTwo implements IEntity{
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
}
@@ -117,6 +117,11 @@ class NetworkPlayerTwo implements IEntity{
}
@Override
+
+ public int getplayer() {
+ return 0;
+ }
+
public int getHealth() {
return health;
}
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/Player.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/Player.java
index 051bd8278abe858b23aa6377b0a7fa6e84b039b8..2203eaa5cbe9b440a8b3da2f529ef3ffaa45a2f5 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/Player.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Entity/Player.java
@@ -80,9 +80,16 @@ class Player implements IEntity {
private int iFrameCounter = 0;
private int attackRate = 0;
private int bombPlacementRate = 0;
+ private int bombReducedPlacementRate = 100;
private boolean isBigBombItemFrame = false;
private boolean isBlastUpItemFrame = false;
+ private boolean isBlastDownItemFrame = false;
+ private boolean isBombClockItemFrame = false;
+ private boolean markerPlacedPlayerOne = false;
+ private boolean markerPlacedPlayerTwo = false;
+ private boolean isTeleportItemFrame = false;
private int blastradius = 1;
+ private final int pixelpadding = 30;
public Player(GraphicsContext gameScene, InputHandler inputHandler, EntityClass entityClass,
GameSceneController gameSceneController, PlayerMode PLAYER_MODE) {
@@ -211,7 +218,7 @@ class Player implements IEntity {
}
@Override
- public void updateEntity(GameSceneController gameScene) {
+ public void updateEntity(GameSceneController gameScene, GraphicsContext graphicsContext) {
if (PLAYER_MODE == PlayerMode.PLAYER_ONE) {
updateInvincibility();
updateAttackRate();
@@ -229,7 +236,7 @@ class Player implements IEntity {
boolean isWalkableTile = collisionHandler.handleMapCollision(this, scaledTileSize, gameSceneController);
- performEntityMovement(isWalkableTile);
+ performEntityMovement(isWalkableTile, graphicsContext);
boolean isEntityCollision = boxCollider.intersects(gameScene.getEnemy().getBoxCollider());
//boolean isEntityCollision = collisionHandler.handleBoxCollision(boxCollider, gameScene.getEnemy().getBoxCollider());
@@ -255,7 +262,7 @@ class Player implements IEntity {
boolean isWalkableTile = collisionHandler.handleMapCollision(this, scaledTileSize, gameSceneController);
- performEntityMovement(isWalkableTile);
+ performEntityMovement(isWalkableTile, graphicsContext);
boolean isEntityCollision = boxCollider.intersects(gameScene.getPlayer().getBoxCollider());
//boolean isEntityCollision = collisionHandler.handleBoxCollision(boxCollider, gameScene.getEnemy().getBoxCollider());
@@ -285,9 +292,27 @@ class Player implements IEntity {
}
}
- private void performEntityMovement(boolean isWalkableTile) {
+ private void performEntityMovement(boolean isWalkableTile, GraphicsContext graphicsContext) {
+ int xTile = (pixelpadding + mapPosX) / scaledTileSize;
+ int yTile = (pixelpadding + mapPosY) / scaledTileSize;
+ int lastxTile = xTile;
+ int lastyTile = yTile;
+
+
+ int pos;
+ if (PLAYER_MODE == PlayerMode.PLAYER_ONE && !markerPlacedPlayerOne) {
+ markerPlacedPlayerOne = findNearestTpTile(yTile, xTile, graphicsContext);
+
+
+ }
+ if (PLAYER_MODE == PlayerMode.PLAYER_TWO && !markerPlacedPlayerTwo) {
+ markerPlacedPlayerTwo = findNearestTpTile(yTile, xTile, graphicsContext);
+
+ }
+
lastMapPosX = mapPosX;
lastMapPosY = mapPosY;
+
try {
sfx.playSoundEffect(gameSceneController);
} catch (IOException e) {
@@ -295,6 +320,7 @@ class Player implements IEntity {
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
+
if (isWalkableTile) {
switch (playerDirection) {
case UP:
@@ -310,6 +336,124 @@ class Player implements IEntity {
mapPosX += playerSpeed;
}
}
+ xTile = (pixelpadding + mapPosX) / scaledTileSize;
+ yTile = (pixelpadding + mapPosY) / scaledTileSize;
+
+ if (PLAYER_MODE == PlayerMode.PLAYER_ONE && lastxTile != xTile || PLAYER_MODE == PlayerMode.PLAYER_ONE && lastyTile != yTile) {
+ markerPlacedPlayerOne = removeMarker(markerPlacedPlayerOne);
+ }
+ if (PLAYER_MODE == PlayerMode.PLAYER_TWO && lastxTile != xTile || PLAYER_MODE == PlayerMode.PLAYER_TWO && lastyTile != yTile) {
+ markerPlacedPlayerTwo = removeMarker(markerPlacedPlayerTwo);
+ }
+
+ }
+
+ private boolean placeMarker(int yTile, int xTile, GraphicsContext graphicsContext) {
+
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ int player = 0;
+
+ if (isTeleportItemFrame && TileManager.tileMap[yTile][xTile] < 10 && PLAYER_MODE == PlayerMode.PLAYER_ONE) {
+ player = 1;
+ IEntity marker = EntityFactory.createMarker(ObjectType.MARKER, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext, player);
+ gameplayObjects.add(marker);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.debug("Player 1 marker placed");
+ //isTeleportItemFrame = false;
+ } else if (isTeleportItemFrame && TileManager.tileMap[yTile][xTile] < 10 && PLAYER_MODE == PlayerMode.PLAYER_TWO) {
+ player = 2;
+ IEntity marker = EntityFactory.createMarker(ObjectType.MARKER, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext, player);
+ gameplayObjects.add(marker);
+ runtimeInfo.setGameplayObjects(gameplayObjects);
+ log.debug("Player 2 marker placed");
+ //isTeleportItemFrame = false;
+ }
+
+ //checkTilePlacing(yTile, xTile);
+ return true;
+ }
+
+ private boolean findNearestTpTile(int yTile, int xTile, GraphicsContext graphicsContext) {
+
+ final int minTpLength = 1;
+ final int maxTpLength = 18;
+ boolean isAbleToPlace = false;
+ boolean stopDown = false, stopUp = false, stopRight = false, stopLeft = false;
+ boolean markerSet = false;
+ int yUp = yTile - minTpLength;
+ int yDown = yTile + minTpLength;
+ int xLeft = xTile - minTpLength;
+ int xRight = xTile + minTpLength;
+
+ for (int i = minTpLength; i < maxTpLength; i++) {
+ if (playerDirection == EntityDirection.UP) {
+ yUp -= 1;
+ isAbleToPlace = checkTilePlacing(yUp, xTile);
+ if (isAbleToPlace && !stopUp) {
+ placeMarker(yUp, xTile, graphicsContext);
+
+ stopUp = true;
+ markerSet = true;
+ }
+ } else if (playerDirection == EntityDirection.DOWN) {
+ yDown += 1;
+ isAbleToPlace = checkTilePlacing(yDown, xTile);
+ if (isAbleToPlace && !stopDown) {
+ placeMarker(yDown, xTile, graphicsContext);
+
+ stopDown = true;
+ markerSet = true;
+ }
+ } else if (playerDirection == EntityDirection.LEFT) {
+ xLeft -= 1;
+ isAbleToPlace = checkTilePlacing(yTile, xLeft);
+ if (isAbleToPlace && !stopLeft) {
+ placeMarker(yTile, xLeft, graphicsContext);
+
+ stopLeft = true;
+ markerSet = true;
+ }
+ } else if (playerDirection == EntityDirection.RIGHT) {
+ xRight += 1;
+ isAbleToPlace = checkTilePlacing(yTile, xRight);
+ if (isAbleToPlace && !stopRight) {
+ placeMarker(yTile, xRight, graphicsContext);
+
+ stopRight = true;
+ markerSet = true;
+ }
+ }
+ }
+ return markerSet;
+ }
+
+ public boolean checkTilePlacing(int y, int x) { //Change it with a DestructionHandler like CollisionHandler //tileSet[xTile].getDestruction();
+ if (y < 18 && y > 0 && x < 18 && x > 0 && TileManager.tileMap[y][x] < 10) {
+ return true;
+ }
+ return false;
+ }
+
+ private boolean removeMarker(boolean markerPlacedPlayer) {
+ List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
+ if (markerPlacedPlayer == markerPlacedPlayerOne) {
+ for (IEntity gameplayObject : gameplayObjects) {
+ if (gameplayObject.getOBJECT_TYPE() == ObjectType.MARKER && gameplayObject.getplayer() == 1) {
+ log.debug("Removed Marker Player 1");
+
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ }
+ } else if (markerPlacedPlayer == markerPlacedPlayerTwo) {
+ for (IEntity gameplayObject : gameplayObjects) {
+ if (gameplayObject.getOBJECT_TYPE() == ObjectType.MARKER && gameplayObject.getplayer() == 2) {
+ log.debug("Removed Marker Player 2");
+
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ }
+ } //TODO: Marker - AND other Bombs - get ONLY visually removed when explosion is set to USED ??
+ return false;
}
private void performEntityCollision(boolean isEntityCollision) {
@@ -330,7 +474,6 @@ class Player implements IEntity {
@Override
public void checkGameplayObjectInteraction(IEntity entity, GraphicsContext graphicsContext) {
-
List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
for (IEntity gameplayObject : gameplayObjects) {
if (gameplayObject.getOBJECT_TYPE() == ObjectType.HEART) {
@@ -339,21 +482,11 @@ class Player implements IEntity {
healPlayer(5);
gameplayObject.setObjectStatus(ObjectStatus.USED);
}
- } else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BOMB) {
- if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
- log.debug("Collision with bomb");
- gotHit(10);
- }
} else if (gameplayObject.getOBJECT_TYPE() == ObjectType.EXPLOSION) {
if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
log.debug("Collision with explosion");
gotHit(10);
}
- } else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BIG_BOMB) {
- if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
- log.debug("Collision with bigBomb");
- gotHit(10);
- }
} else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BIG_BOMB_ITEMFRAME) {
if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
isBigBombItemFrame = true;
@@ -362,200 +495,122 @@ class Player implements IEntity {
}
} else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BLASTUP_ITEMFRAME) {
if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
- isBlastUpItemFrame = true;
log.info("Collision with blastUpItemFrame");
+ isBlastUpItemFrame = true;
+ blastradius = updateBlastradius(blastradius);
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ } else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BLASTDOWN_ITEMFRAME) {
+ if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
+ log.info("Collision with blastDownItemFrame");
+ isBlastDownItemFrame = true;
+ blastradius = updateBlastradius(blastradius);
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ } else if (gameplayObject.getOBJECT_TYPE() == ObjectType.BOMBCLOCK_ITEMFRAME) {
+ if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
+ log.info("Collision with bombClockItemFrame");
+ isBombClockItemFrame = true;
+ bombPlacementRate = updateBombPlacementRate(bombPlacementRate);
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ } else if (gameplayObject.getOBJECT_TYPE() == ObjectType.TELEPORT_ITEMFRAME) {
+ if (gameplayObject.getBoxCollider().intersects(boxCollider)) {
+ isTeleportItemFrame = true;
+ log.info("Collision with teleportItemFrame");
gameplayObject.setObjectStatus(ObjectStatus.USED);
}
}
}
- }
- public int updateblastradius(int blastradius) {
- if (isBlastUpItemFrame) {
- blastradius++;
- log.info("Upded blastradius:" + blastradius);
- isBlastUpItemFrame = false;
- return blastradius;
- } else {
- return blastradius;
- }
}
@Override
- public void placeBomb(IEntity entity, GraphicsContext graphicsContext) {
- blastradius = updateblastradius(blastradius);
+ public void placeBombAction(IEntity entity, GraphicsContext graphicsContext) {
List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
if (inputHandler.isBomb() && PLAYER_MODE == PlayerMode.PLAYER_ONE && bombPlacementRate == 0 ||
inputHandler.isSdBomb() && PLAYER_MODE == PlayerMode.PLAYER_TWO && bombPlacementRate == 0) {
sfx.playSoundEffectOnce(SFX.BOMB);
- if (isBigBombItemFrame) {
- log.debug("We have Itemframes in the List");
- bombPlacementRate = 100;
- int xTile = mapPosX / scaledTileSize;
- int yTile = mapPosY / scaledTileSize;
+
+ blastradius = updateBlastradius(blastradius);
+ if (isBigBombItemFrame && !isTeleportItemFrame) {
+ log.debug("We have Big_Bomb ItemFrames in the List");
+ bombPlacementRate = updateBombPlacementRate(bombPlacementRate);
+ int xTile = (pixelpadding + mapPosX) / scaledTileSize;
+ int yTile = (pixelpadding + mapPosY) / scaledTileSize;
if (TileManager.tileMap[yTile][xTile] < 10) {
- int blastradiusbig = 18;
- //List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity bigbomb = EntityFactory.createGameplayObject(ObjectType.BIG_BOMB, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext);
+ IEntity bigbomb = EntityFactory.createBombs(ObjectType.BIG_BOMB, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext, blastradius);
gameplayObjects.add(bigbomb);
runtimeInfo.setGameplayObjects(gameplayObjects);
- log.info("Bigbomb placed");
- checkExplosionSpawn(graphicsContext, blastradiusbig);
+ log.debug("Bigbomb placed");
isBigBombItemFrame = false;
}
- } else {
- log.debug("No Itemframes in the List");
- bombPlacementRate = 100;
- //int extrapixelpadding = 2; //Could this fix the wrong Tile because of the Player??
+ } else if (PLAYER_MODE == PlayerMode.PLAYER_ONE && isTeleportItemFrame) {
+ bombPlacementRate = 25;
+ for (IEntity gameplayObject : gameplayObjects) {
+ if (gameplayObject.getOBJECT_TYPE() == ObjectType.MARKER && gameplayObject.getplayer() == 1) {
+ mapPosX = gameplayObject.getMapPosX();
+ mapPosY = gameplayObject.getMapPosY();
+ log.info("Teleport Player 1");
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ }
+ removeMarker(markerPlacedPlayerOne);
+ isTeleportItemFrame = false;
+ } else if (PLAYER_MODE == PlayerMode.PLAYER_TWO && isTeleportItemFrame) {
+ bombPlacementRate = 25;
+ for (IEntity gameplayObject : gameplayObjects) {
+ if (gameplayObject.getOBJECT_TYPE() == ObjectType.MARKER && gameplayObject.getplayer() == 2) {
+ mapPosX = gameplayObject.getMapPosX();
+ mapPosY = gameplayObject.getMapPosY();
+ log.info("Teleport Player 2");
+ gameplayObject.setObjectStatus(ObjectStatus.USED);
+ }
+ }
+ removeMarker(markerPlacedPlayerTwo);
+ isTeleportItemFrame = false;
+ } else if (!isTeleportItemFrame) {
+ log.debug("No BigBomb Itemframes in the List");
+ bombPlacementRate = bombReducedPlacementRate;
int xTile = mapPosX / scaledTileSize;
int yTile = mapPosY / scaledTileSize;
if (TileManager.tileMap[yTile][xTile] < 10) {
- //List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity bomb = EntityFactory.createGameplayObject(ObjectType.BOMB, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext);
+ IEntity bomb = EntityFactory.createBombs(ObjectType.BOMB, xTile * scaledTileSize, yTile * scaledTileSize, graphicsContext, blastradius);
gameplayObjects.add(bomb);
runtimeInfo.setGameplayObjects(gameplayObjects);
log.info("bomb placed");
- checkExplosionSpawn(graphicsContext, blastradius);
}
}
}
}
- public void checkExplosionSpawn(GraphicsContext graphicsContext, int blastradius) {
- int isDestructible;
- boolean stopDown = false, stopUp = false, stopRight = false, stopLeft = false;
- boolean stopUpRight = false, stopUpLeft = false, stopDownRight = false, stopDownLeft = false;
-
- int xTile = mapPosX / scaledTileSize; //TODO: Fix sometimes bad bomb spawning
- int yTile = mapPosY / scaledTileSize;
- int yUp = yTile;
- int xRight = xTile;
- int yDown = yTile;
- int xLeft = xTile;
- //final int blastradius = 2; //should be 1-2
- isDestructible = checkTilePlacing(yTile, xTile);
- if (isDestructible != 0) {
- for (int i = 0; i < blastradius; i++) {
- yDown += 1;
- yUp -= 1;
- xRight += 1;
- xLeft -= 1;
- if (yDown < 18 && yDown >= 0 && xTile < 18 && xTile >= 0) {
- //changeCheckedTileDestroyable(graphicsContext);
- isDestructible = checkTilePlacing(yDown, xTile);
- if (isDestructible != 0 && !stopDown) {
- spawnExplosion(yDown, xTile, graphicsContext);
- if (isDestructible == 2) {
- stopDown = true;
- }
- } else {
- stopDown = true;
- }
- }
- if (yUp < 18 && yUp >= 0 && xTile < 18 && xTile >= 0) {
- //changeCheckedTileDestroyable(graphicsContext);
- isDestructible = checkTilePlacing(yUp, xTile);
- if (isDestructible != 0 && !stopUp) {
- spawnExplosion(yUp, xTile, graphicsContext);
- if (isDestructible == 2) {
- stopUp = true;
- }
- } else {
- stopUp = true;
- }
- }
- if (yTile < 18 && yTile >= 0 && xRight < 18 && xRight >= 0) {
- //changeCheckedTileDestroyable(graphicsContext);
- isDestructible = checkTilePlacing(yTile, xRight);
- if (isDestructible != 0 && !stopRight) {
- spawnExplosion(yTile, xRight, graphicsContext);
- if (isDestructible == 2) {
- stopRight = true;
- }
- } else {
- stopRight = true;
- }
- }
- if (yTile < 18 && yTile >= 0 && xLeft < 18 && xLeft >= 0) {
- //changeCheckedTileDestroyable(graphicsContext);
- isDestructible = checkTilePlacing(yTile, xLeft);
- if (isDestructible != 0 && !stopLeft) {
- spawnExplosion(yTile, xLeft, graphicsContext);
- if (isDestructible == 2) {
- stopLeft = true;
- }
- } else {
- stopLeft = true;
- }
- }
- }
- }
- }
-
- public int checkTilePlacing(int y, int x) { //Change it with a DestructionHandler like CollisionHandler //tileSet[xTile].getDestruction();
- if (TileManager.tileMap[y][x] >= 20) {
- return 2; //Last spawn, in this direction
- } else if (TileManager.tileMap[y][x] <= 9) {
- return 1; //Keep Going
- } else {
- return 0; //dont continue
+ private int updateBombPlacementRate(int bombPlacementRate) {
+ if (isBombClockItemFrame && bombReducedPlacementRate > 10) {
+ bombReducedPlacementRate -= 10;
+ log.info("Reducing bomb Placementrate:" + bombReducedPlacementRate);
+ isBombClockItemFrame = false;
}
+ return bombReducedPlacementRate;
}
- public void changeCheckedTileDestructable(GraphicsContext graphicsContext) {
- int x, y; //TODO Fix Explosion
- List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- List<IEntity> explosionList = gameplayObjects.stream().filter(obj -> obj.getOBJECT_TYPE() == ObjectType.EXPLOSION)
- .toList();
- for (IEntity entity : explosionList) {
- y = (entity.getMapPosY()) / scaledTileSize;
- x = (entity.getMapPosX()) / scaledTileSize;
- if (TileManager.tileMap[y][x] > 19) {
- TileManager.tileMap[y][x] = 0;
- sfx.playSoundEffectOnce(SFX.WOOD_Destruction);
- //spawning item entitys
- spawnItems(x * scaledTileSize, y * scaledTileSize, graphicsContext);
+ public int updateBlastradius(int blastradius) {
+ if (isBlastUpItemFrame) {
+ blastradius++;
+ log.info("Upping blastradius:" + blastradius);
+ isBlastUpItemFrame = false;
+ } else if (isBlastDownItemFrame) {
+ if (blastradius > 1) {
+ blastradius--;
+ log.info("Lowering blastradius:" + blastradius);
}
+ isBlastDownItemFrame = false;
}
- }
- public void spawnExplosion(int spawnCordX, int spawnCordY, GraphicsContext graphicsContext) {
- List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity explosion = EntityFactory.createGameplayObject(ObjectType.EXPLOSION, spawnCordY * scaledTileSize, spawnCordX * scaledTileSize, graphicsContext);
- gameplayObjects.add(explosion);
- runtimeInfo.setGameplayObjects(gameplayObjects);
- log.debug("explosion placed");
- changeCheckedTileDestructable(graphicsContext);
- }
-
- public void spawnItems(int x, int y, GraphicsContext graphicsContext) {
- final double dropChanceBigBombItemFrame = 0.1;
- final double dropChanceHeart = 0.15;
- final double dropChanceBlastUpItemFrame = 0.15;
- double randomDropChance = Math.random() * 1;
-
- if (randomDropChance < dropChanceBigBombItemFrame) {
- List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity heart = EntityFactory.createGameplayObject(ObjectType.BIG_BOMB_ITEMFRAME, x, y, graphicsContext);
- gameplayObjects.add(heart);
- runtimeInfo.setGameplayObjects(gameplayObjects);
- log.info("heart dropped");
- } else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame) {
- List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity bigBombItemFrame = EntityFactory.createGameplayObject(ObjectType.HEART, x, y, graphicsContext);
- gameplayObjects.add(bigBombItemFrame);
- runtimeInfo.setGameplayObjects(gameplayObjects);
- log.info("BigBombItemFrame dropped");
- } else if (randomDropChance < dropChanceHeart + dropChanceBigBombItemFrame + dropChanceBlastUpItemFrame) {
- List<IEntity> gameplayObjects = runtimeInfo.getGameplayObjects();
- IEntity bigBombItemFrame = EntityFactory.createGameplayObject(ObjectType.BLASTUP_ITEMFRAME, x, y, graphicsContext);
- gameplayObjects.add(bigBombItemFrame);
- runtimeInfo.setGameplayObjects(gameplayObjects);
- log.info("BlastUpItemFrame dropped");
- }
+ return blastradius;
+
}
@Override
@@ -569,9 +624,13 @@ class Player implements IEntity {
if (inputHandler.isAttack() && PLAYER_MODE == PlayerMode.PLAYER_ONE && attackRate == 0 ||
inputHandler.isSdAttack() && PLAYER_MODE == PlayerMode.PLAYER_TWO && attackRate == 0) {
- attackRate = 15;
+
+ attackRate = 50;
+
+
sfx.playSoundEffectOnce(SFX.SWORD_SWING);
+
if (playerDirection == EntityDirection.UP) {
hitBox = new BoundingBox(mapPosX + playerWidth, mapPosY - 10, attackWidth, attackRange);
graphicsContext.strokeRect(mapPosX + playerWidth, mapPosY - 10, attackWidth, attackRange);
@@ -672,12 +731,13 @@ class Player implements IEntity {
if (iFrameCounter == 0) {
if (damagedHealth > 0) {
health -= damageDone;
- iFrameCounter = 10;
+ iFrameCounter = 100;
} else {
+
health = 0;
- //log.info("Dead");
+ log.info("Dead");
}
- //log.info("DamageTaken, current Health: " + health);
+ log.info("DamageTaken, current Health: " + health);
}
}
@@ -746,4 +806,8 @@ class Player implements IEntity {
return maxPlayerHealth;
}
+ @Override
+ public int getplayer() {
+ return 0;
+ }
}
\ No newline at end of file
diff --git a/src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileFactory.java b/src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileFactory.java
index d31689700319fc4dd7bf25082c0c5915df0a09ee..7c10e8b13b9d11b5cda2f27af0be4a882118fa18 100644
--- a/src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileFactory.java
+++ b/src/main/java/de/hdm_stuttgart/battlearena/Model/Map/TileFactory.java
@@ -10,6 +10,7 @@ public class TileFactory {
private static final Logger log = LogManager.getLogger(TileFactory.class);
+
public static ITile createTile(TileType tileType, TileType tileType2, Image tileSprite, SFXLoop sfx) {
if (tileType == TileType.WALKABLE && tileType2 == TileType.DESTRUCTIBLE) {
log.info("Tile with type: " + tileType + " " + tileType2 + " created.");
diff --git a/src/main/resources/textures/objects/itemFrames/AmogUsDown.png b/src/main/resources/textures/objects/itemFrames/AmogUsDown.png
new file mode 100644
index 0000000000000000000000000000000000000000..efd12b87b444db988f3b9dac98c140cb50f8559c
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/AmogUsDown.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/AmogUsMiddle.png b/src/main/resources/textures/objects/itemFrames/AmogUsMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..b4141f898b06342b1620aede93ad572a03bc3c93
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/AmogUsMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/AmogUsUp.png b/src/main/resources/textures/objects/itemFrames/AmogUsUp.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce2825c57c2eb28724863bb9b5e3247f3e23a4a1
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/AmogUsUp.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyDown.png b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyDown.png
new file mode 100644
index 0000000000000000000000000000000000000000..09a90af35ff3aa3fc7bad10651bae877694aa6b2
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyDown.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyMiddle.png b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..daa21909c5980cb99dcae663cae71fdefa41e367
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyUp.png b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyUp.png
new file mode 100644
index 0000000000000000000000000000000000000000..e04a4663d982a678b025b861c3a32ebd49d806b3
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ArmorFrameGreyUp.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ArmorFramePurpleMiddle.png b/src/main/resources/textures/objects/itemFrames/ArmorFramePurpleMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..dda8533891e1362adff512c0109f4392513d520c
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ArmorFramePurpleMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameDown.png b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameDown.png
new file mode 100644
index 0000000000000000000000000000000000000000..9147e7e301037b901445a3492aac6ce9c4351c30
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameDown.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameMiddle.png b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..30e08a4dac0225a815d2587ffe4d06f2312317e1
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameUp.png b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameUp.png
new file mode 100644
index 0000000000000000000000000000000000000000..9e295e1b884e5a89489d81c61aaa5f343e5424ff
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastDownItemFrameUp.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastItemFrameDown.png b/src/main/resources/textures/objects/itemFrames/BlastItemFrameDown.png
deleted file mode 100644
index e5d250bb9b20c7e192358a4dd143cd8b7a908f6f..0000000000000000000000000000000000000000
Binary files a/src/main/resources/textures/objects/itemFrames/BlastItemFrameDown.png and /dev/null differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastItemFrameMiddle.png b/src/main/resources/textures/objects/itemFrames/BlastItemFrameMiddle.png
deleted file mode 100644
index 2c8a93e650aaed70057b6e64fcd1233e19f307f5..0000000000000000000000000000000000000000
Binary files a/src/main/resources/textures/objects/itemFrames/BlastItemFrameMiddle.png and /dev/null differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastItemFrameUp.png b/src/main/resources/textures/objects/itemFrames/BlastItemFrameUp.png
deleted file mode 100644
index 4a633765b869cac0f47b399aa37a047b9e6bb85b..0000000000000000000000000000000000000000
Binary files a/src/main/resources/textures/objects/itemFrames/BlastItemFrameUp.png and /dev/null differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameDown.png b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameDown.png
new file mode 100644
index 0000000000000000000000000000000000000000..d27512a067b1c26e0e09f951cd81c7370ba10905
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameDown.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameMiddle.png b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..bdab779804418a03f86897ec058dd742fecffc85
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameUp.png b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameUp.png
new file mode 100644
index 0000000000000000000000000000000000000000..b334ff57e7f0d255e966ff4eb858e490c43bdabb
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/BlastUpItemFrameUp.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ClockItemFrame1Up.png b/src/main/resources/textures/objects/itemFrames/ClockItemFrame1Up.png
new file mode 100644
index 0000000000000000000000000000000000000000..26f4f749eb98775f1b4a74112002103d357dc54d
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ClockItemFrame1Up.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ClockItemFrame2Middle.png b/src/main/resources/textures/objects/itemFrames/ClockItemFrame2Middle.png
new file mode 100644
index 0000000000000000000000000000000000000000..7f8bd6847d5bb4a895e3711e527ea821621564d8
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ClockItemFrame2Middle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ClockItemFrame3Down.png b/src/main/resources/textures/objects/itemFrames/ClockItemFrame3Down.png
new file mode 100644
index 0000000000000000000000000000000000000000..3de4f072c037347a39f92e37de9f0f90614a0242
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ClockItemFrame3Down.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ClockItemFrame4Middle.png b/src/main/resources/textures/objects/itemFrames/ClockItemFrame4Middle.png
new file mode 100644
index 0000000000000000000000000000000000000000..7782b908bfe01fd7f40ac489fe2d643f9ee3fbe8
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ClockItemFrame4Middle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ShieldItemFrameDown.png b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameDown.png
new file mode 100644
index 0000000000000000000000000000000000000000..b5a34200ee094e2b5133fd8cc2b052b14136c558
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameDown.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ShieldItemFrameMiddle.png b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b3b918c86da9cc12baf5b65dc459e2304d674bf
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/ShieldItemFrameUp.png b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameUp.png
new file mode 100644
index 0000000000000000000000000000000000000000..38b7bc12987427762b56bda36d80035fbb4baa18
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/ShieldItemFrameUp.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle.png b/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc5258c1d9d80a0f35679f0ee8d9f2a988e27375
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle.png differ
diff --git a/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle2.png b/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle2.png
new file mode 100644
index 0000000000000000000000000000000000000000..cf384e9aa58884bc258e38cf0bc47e5d4d677fc0
Binary files /dev/null and b/src/main/resources/textures/objects/itemFrames/Skull_ItemFrameMiddle2.png differ
diff --git a/src/main/resources/textures/objects/vfx/Marker.png b/src/main/resources/textures/objects/vfx/Marker.png
new file mode 100644
index 0000000000000000000000000000000000000000..d93cf7020d44ae72288246af0d6aad2faf2d5e93
Binary files /dev/null and b/src/main/resources/textures/objects/vfx/Marker.png differ
diff --git a/src/main/resources/textures/objects/vfx/Markersmall.png b/src/main/resources/textures/objects/vfx/Markersmall.png
new file mode 100644
index 0000000000000000000000000000000000000000..e291f0dfff61225eae925b1ce3c5a6d933f9b885
Binary files /dev/null and b/src/main/resources/textures/objects/vfx/Markersmall.png differ
diff --git a/src/main/resources/textures/objects/vfx/Markersmallblue.png b/src/main/resources/textures/objects/vfx/Markersmallblue.png
new file mode 100644
index 0000000000000000000000000000000000000000..edc10055737c918b8c94b1ce10b1fa052a8668b5
Binary files /dev/null and b/src/main/resources/textures/objects/vfx/Markersmallblue.png differ
diff --git a/src/main/resources/textures/objects/vfx/Markersmalllightblue.png b/src/main/resources/textures/objects/vfx/Markersmalllightblue.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ad0c5747621a84e37bc05bb0e8451080bd98fc6
Binary files /dev/null and b/src/main/resources/textures/objects/vfx/Markersmalllightblue.png differ
diff --git a/src/main/resources/textures/objects/vfx/explosionFrame3.png b/src/main/resources/textures/objects/vfx/explosionFrame3.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc9fca358c62b821aa12ba60ac15ad11e2762aaf
Binary files /dev/null and b/src/main/resources/textures/objects/vfx/explosionFrame3.png differ
diff --git a/src/test/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/Utilities/CryptoUtilsTest.java b/src/test/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/Utilities/CryptoUtilsTest.java
index 6fe7a78190c6e19cc745d4aaec49d281970665cf..eccb5e56bb077aa56ec18d9476eec803dcd02d41 100644
--- a/src/test/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/Utilities/CryptoUtilsTest.java
+++ b/src/test/java/de/hdm_stuttgart/battlearena/Model/DataStorage/Classes/Utilities/CryptoUtilsTest.java
@@ -33,7 +33,7 @@ public class CryptoUtilsTest {
testInfo.getDisplayName()));
}
@Test
- void encryptDecryptiontest() throws IOException {
+ void encryptDecryptionTest() throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(encryptiondecryptiontestFile));
writer.write(testtext);
writer.close();
diff --git a/src/test/java/de/hdm_stuttgart/battlearena/Model/Entity/PlayerTest.java b/src/test/java/de/hdm_stuttgart/battlearena/Model/Entity/PlayerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7055c8bad92ea6d3136c0b210d0a36579cf52e53
--- /dev/null
+++ b/src/test/java/de/hdm_stuttgart/battlearena/Model/Entity/PlayerTest.java
@@ -0,0 +1,29 @@
+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;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityClass;
+import de.hdm_stuttgart.battlearena.Model.Entity.EntityDirection;
+import de.hdm_stuttgart.battlearena.Model.Map.TileManager;
+import javafx.fxml.FXML;
+import javafx.scene.layout.BorderPane;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlayerTest {
+ @FXML
+ private BorderPane gameScene;
+
+
+ GameSceneController GameSceneController = new GameSceneController();
+ //TileManager tileManager = new TileManager()
+ Player player = new Player(null, InputHandler.getInstance(), EntityClass.HUMAN, GameSceneController, PlayerMode.PLAYER_ONE);
+ @Test
+ public void checkTileWalkable(){
+
+ int x = 1, y =1;
+ if(TileManager.tileMap[y][x] < 10)
+ assertTrue(player.checkTilePlacing(x,y));
+ }
+}