Merge pull request #10 from Zwazel-Teaching-Projects/feat/tank-types

zwazel · web-flow · commit cf364ad0716e · 2025-03-16T16:19:39.000+01:00
Feat/tank types
diff --git a/src/main/java/dev/zwazel/GameWorld.java b/src/main/java/dev/zwazel/GameWorld.java
@@ -5,7 +5,6 @@
 import dev.zwazel.internal.InternalGameWorld;
 import dev.zwazel.internal.PublicGameWorld;
 import dev.zwazel.internal.connection.ConnectionManager;
-import dev.zwazel.internal.debug.MapVisualiser;
 import dev.zwazel.internal.game.state.ClientState;
 import dev.zwazel.internal.game.tank.Tank;
 import dev.zwazel.internal.game.tank.TankFactory;
@@ -26,16 +25,16 @@
 public class GameWorld implements InternalGameWorld, PublicGameWorld {
     private static GameWorld instance;
 
-    private final PropertyHandler properties = PropertyHandler.getInstance();
     private final BlockingQueue<MessageContainer> incomingMessages = new LinkedBlockingQueue<>();
     private final BlockingQueue<MessageContainer> outgoingMessages = new LinkedBlockingQueue<>();
-    private final DebugMode debug;
+    private DebugMode debug;
     private boolean immediatelyStartGame;
     private ConnectionManager connection;
     private GameState gameState;
     private BotInterface bot;
     private Tank tank;
     private GameConfig gameConfig;
+
     /**
      * The predicted state of the client.
      * Resets every tick.
@@ -48,24 +47,23 @@ public class GameWorld implements InternalGameWorld, PublicGameWorld {
 
     private GameWorld() {
         // Private constructor to prevent instantiation
-        this.debug = DebugMode.valueOf(this.properties.getProperty("debug.mode").toUpperCase());
     }
 
-    public static boolean startGame(BotInterface bot, Class<? extends Tank> tankClass) {
+    public static boolean startGame(BotInterface bot) {
         GameWorld gameWorld = GameWorld.getInstance();
-        gameWorld.setup(bot, tankClass, true);
-        if (gameWorld.connect(true)) {
+        gameWorld.setup(bot, true);
+        if (gameWorld.connect()) {
             return true;
         } else {
             System.err.println("Failed to start the game world due to connection issues.");
             return false;
         }
     }
 
-    public static boolean connectToServer(BotInterface bot, Class<? extends Tank> tankClass) {
+    public static boolean connectToServer(BotInterface bot) {
         GameWorld gameWorld = GameWorld.getInstance();
-        gameWorld.setup(bot, tankClass, false);
-        return gameWorld.connect(false);
+        gameWorld.setup(bot, false);
+        return gameWorld.connect();
     }
 
     private static GameWorld getInstance() {
@@ -76,19 +74,20 @@ private static GameWorld getInstance() {
         return instance;
     }
 
-    private void setup(BotInterface bot, Class<? extends Tank> tankClass, boolean immediatelyStartGame) {
+    private void setup(BotInterface bot, boolean immediatelyStartGame) {
         this.bot = bot;
-        this.tank = TankFactory.createTank(tankClass);
+        this.debug = bot.getLocalBotConfig().debugMode().orElse(DebugMode.NONE);
+        this.tank = TankFactory.createTank(bot.getLocalBotConfig().tankType());
         this.immediatelyStartGame = immediatelyStartGame;
     }
 
-    private boolean connect(boolean immediatelyStartGame) {
+    private boolean connect() {
         if (connection.isConnected()) {
             return true;
         }
 
-        String serverIp = properties.getProperty("server.ip");
-        int serverPort = Integer.parseInt(properties.getProperty("server.port"));
+        String serverIp = bot.getLocalBotConfig().serverIp();
+        int serverPort = bot.getLocalBotConfig().serverPort();
 
         if (!connection.connect(serverIp, serverPort)) {
             System.err.println("Failed to connect to " + serverIp + ":" + serverPort);
@@ -146,7 +145,7 @@ public void startGame() {
             System.err.println("Game world is not running!");
         }
 
-        boolean fillEmptySlotsWithDummies = Boolean.parseBoolean(properties.getProperty("lobby.fillEmptySlots"));
+        boolean fillEmptySlotsWithDummies = bot.getLocalBotConfig().lobbyConfig().fillEmptySlots();
         this.send(new MessageContainer(
                 TO_LOBBY_DIRECTLY.get(),
                 StartGameConfig.builder().fillEmptySlotsWithDummies(fillEmptySlotsWithDummies).build()
@@ -235,7 +234,7 @@ public BotInterface getBot() {
         return bot;
     }
 
-    private enum DebugMode {
+    public enum DebugMode {
         NONE,
         INTERNAL,
         PUBLIC,
diff --git a/src/main/java/dev/zwazel/bot/BotInterface.java b/src/main/java/dev/zwazel/bot/BotInterface.java
@@ -1,8 +1,17 @@
 package dev.zwazel.bot;
 
 import dev.zwazel.internal.PublicGameWorld;
+import dev.zwazel.internal.config.LocalBotConfig;
 
 public interface BotInterface {
+    /**
+     * Get the local bot configuration.
+     * The local bot configuration is used to determine the bot's name and tank type when connecting to the game. It can not be changed after the game has started.
+     *
+     * @return the local bot configuration
+     */
+    LocalBotConfig getLocalBotConfig();
+
     /**
      * Set up the bot.
      * Gets called once at the start of the game.
diff --git a/src/main/java/dev/zwazel/internal/config/LobbyConfig.java b/src/main/java/dev/zwazel/internal/config/LobbyConfig.java
@@ -0,0 +1,11 @@
+package dev.zwazel.internal.config;
+
+import lombok.Builder;
+import lombok.NonNull;
+
+import java.util.Optional;
+
+@Builder
+public record LobbyConfig(@NonNull String lobbyName, @NonNull String mapName, @NonNull String teamName, Optional<Integer> spawnPoint,
+                          boolean fillEmptySlots) {
+}
diff --git a/src/main/java/dev/zwazel/internal/config/LocalBotConfig.java b/src/main/java/dev/zwazel/internal/config/LocalBotConfig.java
@@ -0,0 +1,14 @@
+package dev.zwazel.internal.config;
+
+import dev.zwazel.GameWorld;
+import dev.zwazel.internal.game.tank.Tank;
+import lombok.Builder;
+import lombok.NonNull;
+
+import java.util.Optional;
+
+@Builder
+public record LocalBotConfig(Optional<GameWorld.DebugMode> debugMode, @NonNull String botName,
+                             @NonNull Class<? extends Tank> tankType, @NonNull String serverIp, @NonNull int serverPort,
+                             @NonNull LobbyConfig lobbyConfig) {
+}
diff --git a/src/main/java/dev/zwazel/internal/connection/ConnectionManager.java b/src/main/java/dev/zwazel/internal/connection/ConnectionManager.java
@@ -1,8 +1,8 @@
 package dev.zwazel.internal.connection;
 
-import dev.zwazel.PropertyHandler;
 import dev.zwazel.internal.InternalGameWorld;
 import dev.zwazel.internal.PublicGameWorld;
+import dev.zwazel.internal.config.LocalBotConfig;
 import dev.zwazel.internal.message.MessageContainer;
 import dev.zwazel.internal.message.data.FirstContact;
 import lombok.Getter;
@@ -14,7 +14,6 @@
 
 public class ConnectionManager {
     private static ConnectionManager instance;
-    private final PropertyHandler properties = PropertyHandler.getInstance();
 
     private InternalGameWorld world;
     @Getter
@@ -51,16 +50,20 @@ public boolean connect(String host, int port) throws IllegalStateException {
             listenerThread.start();
 
             PublicGameWorld publicGameWorld = this.world.getPublicGameWorld();
+            LocalBotConfig botConfig = this.world.getBot().getLocalBotConfig();
             // Sending first contact message
             MessageContainer message = new MessageContainer(
                     SERVER_ONLY.get(),
                     FirstContact.builder()
-                            .lobbyName(properties.getProperty("lobby.name"))
-                            .botName(properties.getProperty("bot.name"))
-                            .mapName(properties.getProperty("lobby.map.name"))
-                            .teamName(properties.getProperty("lobby.team.name"))
-                            .botAssignedSpawnPoint(properties.getProperty("lobby.spawnPoint") != null ?
-                                    Long.parseLong(properties.getProperty("lobby.spawnPoint")) : null)
+                            .lobbyName(botConfig.lobbyConfig().lobbyName())
+                            .botName(botConfig.botName())
+                            .mapName(botConfig.lobbyConfig().mapName())
+                            .teamName(botConfig.lobbyConfig().teamName())
+                            .botAssignedSpawnPoint(
+                                    botConfig.lobbyConfig().spawnPoint().isPresent() ?
+                                            Long.valueOf(botConfig.lobbyConfig().spawnPoint().get())
+                                            : null
+                            )
                             .clientType(FirstContact.ClientType.PLAYER)
                             .tankType(publicGameWorld.getTank().getTankType())
                             .build()
diff --git a/src/main/java/dev/zwazel/internal/game/map/MapDefinition.java b/src/main/java/dev/zwazel/internal/game/map/MapDefinition.java
@@ -43,6 +43,12 @@ public Vec3 getClosestTileFromWorld(Vec3 worldPos) {
                 minDistance = distance;
                 closest = tile;
             }
+
+            assert closest != null;
+            double closestDistance = Math.abs(closest.getX() - worldPos.getX()) + Math.abs(closest.getZ() - worldPos.getZ());
+            if (distance < closestDistance) {
+                closest = tile;
+            }
         }
 
         assert closest != null;
diff --git a/src/main/java/dev/zwazel/internal/game/tank/TankConfig.java b/src/main/java/dev/zwazel/internal/game/tank/TankConfig.java
@@ -23,10 +23,12 @@
  * @param armor                    the armor of the tank on each side (0-1, 0 = no armor, 1 = full armor)
  *                                 Damage is reduced by the armor value on the side that was hit
  *                                 calculated as: damage = damage * (1 - armor)
+ * @param respawnTimer             how many ticks the tank has to wait before respawning
+ * @param projectileGravity        how much the projectile is affected by gravity (if 0, no gravity)
  */
 public record TankConfig(float moveSpeed, float bodyRotationSpeed, float turretYawRotationSpeed,
                          float turretPitchRotationSpeed, float turretMaxPitch, float turretMinPitch, float maxSlope,
                          Vec3 size, Long shootCooldown, float projectileDamage, float projectileSpeed,
                          long projectileLifetime, Vec3 projectileSize, float maxHealth, HashMap<Side, Float> armor,
-                         long respawnTimer) {
+                         long respawnTimer, float projectileGravity) {
 }
diff --git a/src/main/java/dev/zwazel/internal/game/utils/Graph.java b/src/main/java/dev/zwazel/internal/game/utils/Graph.java
@@ -1,11 +1,63 @@
 package dev.zwazel.internal.game.utils;
 
+import dev.zwazel.internal.game.map.MapDefinition;
 import lombok.Data;
 
 @Data
 public class Graph {
     private Node[][] nodes;
 
+    public Graph(MapDefinition mapDefinition, boolean allowDiagonal) {
+        nodes = new Node[(int) mapDefinition.depth()][(int) mapDefinition.width()];
+
+        // Create nodes
+        for (int y = 0; y < mapDefinition.depth(); y++) {
+            for (int x = 0; x < mapDefinition.width(); x++) {
+                Node node = new Node(mapDefinition.tiles()[y][x], x, y);
+                nodes[y][x] = node;
+            }
+        }
+
+        // Create edges
+        for (Node[] row : nodes) {
+            for (Node node : row) {
+                int x = node.getX();
+                int y = node.getY();
+
+                // Add horizontal and vertical edges
+                if (x > 0) {
+                    node.getNeighbours().add(getNode(x - 1, y));
+                }
+                if (x < mapDefinition.width() - 1) {
+                    node.getNeighbours().add(getNode(x + 1, y));
+                }
+                if (y > 0) {
+                    node.getNeighbours().add(getNode(x, y - 1));
+                }
+                if (y < mapDefinition.depth() - 1) {
+                    node.getNeighbours().add(getNode(x, y + 1));
+                }
+
+                // Add diagonal edges
+                if (allowDiagonal) {
+                    if (x > 0 && y > 0) {
+                        node.getNeighbours().add(getNode(x - 1, y - 1));
+                    }
+                    if (x < mapDefinition.width() - 1 && y > 0) {
+                        node.getNeighbours().add(getNode(x + 1, y - 1));
+                    }
+                    if (x > 0 && y < mapDefinition.depth() - 1) {
+                        node.getNeighbours().add(getNode(x - 1, y + 1));
+                    }
+                    if (x < mapDefinition.width() - 1 && y < mapDefinition.depth() - 1) {
+                        node.getNeighbours().add(getNode(x + 1, y + 1));
+                    }
+                }
+            }
+        }
+    }
+
+    @Deprecated(forRemoval = true)
     public Graph(float[][] heights, boolean allowDiagonal) {
         nodes = new Node[heights.length][heights[0].length];
 

Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,12 @@ public Vec3 getClosestTileFromWorld(Vec3 worldPos) {`
`43`	`43`	`minDistance = distance;`
`44`	`44`	`closest = tile;`
`45`	`45`	`}`
	`46`	`+`
	`47`	`+ assert closest != null;`
	`48`	`+ double closestDistance = Math.abs(closest.getX() - worldPos.getX()) + Math.abs(closest.getZ() - worldPos.getZ());`
	`49`	`+ if (distance < closestDistance) {`
	`50`	`+ closest = tile;`
	`51`	`+ }`
`46`	`52`	`}`
`47`	`53`
`48`	`54`	`assert closest != null;`