.forgejo/workflows/qs.yml

@@ -28,17 +28,6 @@ jobs:
       - name: "Stop Gradle"
         run: gradle --stop
 
-  async:
-    name: "Validate Async API Specification"
-    runs-on: stable
-    container:
-      image: asyncapi/cli:latest
-    steps:
-      - name: "Checkout"
-        uses: "https://git.euph.dev/actions/checkout@v3"
-      - name: run
-        run: asyncapi validate ws/ws.yml
-
   linting:
     name: "Linting"
     runs-on: stable

build.gradle.kts

@@ -61,9 +61,6 @@ dependencies {
     // Postgres
     runtimeOnly("org.postgresql:postgresql")
 
-    // JOML
-    implementation("org.joml:joml:1.10.7")
-
     // Lombok
     compileOnly("org.projectlombok:lombok")
     annotationProcessor("org.projectlombok:lombok")

src/main/java/de/towerdefence/server/game/Enemy.java

@@ -1,13 +0,0 @@
-package de.towerdefence.server.game;
-
-import org.joml.Vector2i;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public class Enemy {
-    protected int id;
-    protected Vector2i pos;
-}

src/main/java/de/towerdefence/server/game/GameSession.java

@@ -1,146 +0,0 @@
-package de.towerdefence.server.game;
-
-import java.lang.reflect.Constructor;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-
-import de.towerdefence.server.game.callbacks.EnemiesChangedCallback;
-import de.towerdefence.server.game.callbacks.PlayerMoneyCallback;
-import de.towerdefence.server.game.callbacks.PlayerHitpointsCallback;
-import de.towerdefence.server.game.exeptions.InvalidPlacementException;
-import de.towerdefence.server.game.exeptions.InvalidPlacementReason;
-import de.towerdefence.server.game.exeptions.WaveInProgressException;
-import de.towerdefence.server.game.pathfinding.AStar;
-import de.towerdefence.server.game.pathfinding.NoPathException;
-import de.towerdefence.server.game.pathfinding.OutOfBoundsException;
-import de.towerdefence.server.player.Player;
-import lombok.Getter;
-import org.joml.Vector2i;
-
-public class GameSession {
-    final static int START_HITPOINTS = 100;
-    final static int START_MONEY = 50;
-    final static Vector2i MAP_SIZE = new Vector2i(10, 20);
-    final static int WAVE_SPAWN_DELAY = 200; // ms
-    final static Vector2i WAVE_SPAWN = new Vector2i(5, 0);
-    final static Vector2i WAVE_TARGET = new Vector2i(5, 19);
-
-    private final Player player;
-    @Getter
-    private int money;
-    @Getter
-    private int playerHitpoints;
-    private final PlayerMoneyCallback moneyCallback;
-    private final PlayerHitpointsCallback hitpointsCallback;
-    private final EnemiesChangedCallback enemyCallback;
-
-    private final Tower[][] towers = new Tower[MAP_SIZE.x][MAP_SIZE.y];
-    private final Enemy[][] enemies = new Enemy[MAP_SIZE.x][MAP_SIZE.y];
-    private List<Enemy> wave = new ArrayList<>();
-    private long lastSpawn = Instant.now().toEpochMilli();
-
-    public GameSession(
-        Player player,
-        PlayerMoneyCallback moneyCallback,
-        PlayerHitpointsCallback hitpointsCallback,
-        EnemiesChangedCallback enemyCallback
-    ) {
-        this.player = player;
-        this.moneyCallback = moneyCallback;
-        this.hitpointsCallback = hitpointsCallback;
-        this.enemyCallback = enemyCallback;
-        this.money = START_MONEY;
-        this.playerHitpoints = START_HITPOINTS;
-
-    }
-
-    public void startWave(List<Enemy> enemies) throws WaveInProgressException {
-        if (wave.size() > 0) {
-            throw new WaveInProgressException();
-        }
-        wave = enemies;
-    }
-
-    public void update() {
-        List<Enemy> newEnemies = new ArrayList<>();
-
-        List<Enemy> changedEnemies = moveEnemies();
-
-        if (wave.size() > 0 && shouldSpawn()) {
-            enemies[WAVE_SPAWN.x][WAVE_SPAWN.y] = wave.removeFirst();
-            newEnemies.add(enemies[WAVE_SPAWN.x][WAVE_SPAWN.y]);
-        }
-
-        if (newEnemies.size() > 0 || changedEnemies.size() > 0) {
-            enemyCallback.call(
-                player,
-                newEnemies.toArray(new Enemy[newEnemies.size()]),
-                changedEnemies.toArray(new Enemy[changedEnemies.size()])
-            );
-        }
-    }
-
-    private boolean shouldSpawn() {
-        return lastSpawn + WAVE_SPAWN_DELAY < Instant.now().toEpochMilli()
-               && enemies[WAVE_SPAWN.x][WAVE_SPAWN.y] == null;
-    }
-
-    private List<Enemy> moveEnemies() {
-        List<Enemy> changedEnemies = moveEnemies();
-
-        for (int x = 0; x < enemies.length; x++) {
-            Enemy[] column = enemies[x];
-            for (int y = 0; y < column.length; y++) {
-                Enemy enemy = column[y];
-                if (changedEnemies.contains(enemy)) {
-                    continue;
-                }
-                AStar a = new AStar((Vector2i pos) -> {
-                    return pos.x >= 0
-                    && pos.x < MAP_SIZE.x
-                    && pos.y >= 0
-                    && pos.y < MAP_SIZE.y
-                    && (towers[pos.x] == null || towers[pos.x][pos.y] == null)
-                    && (enemies[pos.x] == null || enemies[pos.x][pos.y] != null);
-                });
-                Vector2i next;
-                try {
-                    next = a.next(enemy.pos, WAVE_TARGET);
-                } catch (NoPathException | OutOfBoundsException exceptionO) {
-                    throw new RuntimeException("TODO: Implement");
-                }
-                enemy.pos = next;
-                enemies[x][y] = null;
-                enemies[next.x][next.y] = enemy;
-                changedEnemies.add(enemy);
-            }
-        }
-
-        return changedEnemies;
-    }
-
-    public void placeTower(Tower tower, Vector2i pos) throws InvalidPlacementException {
-        if (pos.x < 0 || pos.y < 0 || pos.x + 1 > MAP_SIZE.x || pos.y + 1 > MAP_SIZE.y) {
-            throw new InvalidPlacementException(InvalidPlacementReason.OUT_OF_BOUNDS);
-        }
-        if (towers[pos.x][pos.y] != null) {
-            throw new InvalidPlacementException(InvalidPlacementReason.LOCATION_USED);
-        }
-        if (money < Tower.COST) {
-            throw new InvalidPlacementException(InvalidPlacementReason.NOT_ENOUGH_MONEY);
-        }
-
-        // TODO: Do Pathfinding check for the placement
-
-        money -= Tower.COST;
-        moneyCallback.call(player, money);
-        tower.pos = pos;
-        towers[pos.x][pos.y] = tower;
-    }
-
-    public void addMoney(int amount) {
-        money += amount;
-        moneyCallback.call(player, money);
-    }
-}

src/main/java/de/towerdefence/server/game/Tower.java

@@ -1,14 +0,0 @@
-package de.towerdefence.server.game;
-
-import org.joml.Vector2i;
-
-import lombok.Getter;
-
-@Getter
-public class Tower {
-    public static final int COST = 20;
-    protected Vector2i pos;
-
-    public Tower() {
-    }
-}

src/main/java/de/towerdefence/server/game/callbacks/EnemiesChangedCallback.java

@@ -1,9 +0,0 @@
-package de.towerdefence.server.game.callbacks;
-
-import de.towerdefence.server.game.Enemy;
-import de.towerdefence.server.player.Player;
-
-@FunctionalInterface
-public interface EnemiesChangedCallback {
-    void call(Player player, Enemy[] newEnemies, Enemy[] changedEnemies);
-}

src/main/java/de/towerdefence/server/game/exeptions/WaveInProgressException.java

@@ -1,4 +0,0 @@
-package de.towerdefence.server.game.exeptions;
-
-public class WaveInProgressException extends RuntimeException {
-}

src/main/java/de/towerdefence/server/game/pathfinding/AStar.java

@@ -1,103 +0,0 @@
-package de.towerdefence.server.game.pathfinding;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.joml.Vector2i;
-
-import lombok.AllArgsConstructor;
-
-@AllArgsConstructor
-public class AStar {
-    private final WalkableCallback walkable;
-
-    public Vector2i next(Vector2i current, Vector2i target) throws NoPathException, OutOfBoundsException {
-        if (!walkable.call(current) || !walkable.call(target)) {
-            throw new OutOfBoundsException();
-        }
-
-        if (current.equals(target)) {
-            return target;
-        }
-
-        Map<Vector2i, PathNode> remaining = new HashMap<>();
-        Set<Vector2i> evaluated = new HashSet<>();
-        Map<Vector2i, Vector2i> takenPath = new HashMap<>();
-
-        PathNode origin = new PathNode(current, 0, current.gridDistance(target));
-        remaining.put(current, origin);
-
-        while (!remaining.isEmpty()) {
-            PathNode currentNode = getLowestEstimate(remaining);
-            Vector2i currentPos = currentNode.pos;
-
-            if (currentPos.equals(target)) {
-                return reconstructPath(takenPath, current);
-            }
-
-            remaining.remove(currentPos);
-            evaluated.add(currentPos);
-
-            long nextCost = currentNode.cost + 1;
-            for (PathNode neighbor : getNeighbors(currentPos, nextCost, target)) {
-                if (evaluated.contains(neighbor.pos)) {
-                    continue;
-                }
-                if (!remaining.containsKey(neighbor.pos) || nextCost < remaining.get(neighbor.pos).cost) {
-                    takenPath.put(neighbor.pos, currentPos);
-                    remaining.put(neighbor.pos, neighbor);
-                }
-            }
-        }
-
-        throw new NoPathException();
-    }
-
-    private Vector2i reconstructPath(Map<Vector2i, Vector2i> takenPath, Vector2i origin) {
-        Vector2i current = takenPath.keySet().stream().reduce((first, second) -> second).orElse(null);
-        if (current == null)
-            return null;
-        while (takenPath.get(current) != null && !takenPath.get(current).equals(origin)) {
-            current = takenPath.get(current);
-        }
-        return current;
-    }
-
-    private PathNode getLowestEstimate(Map<Vector2i, PathNode> openSet) {
-        PathNode lowestNode = null;
-        for (PathNode node : openSet.values()) {
-            if (lowestNode == null || node.estimate < lowestNode.estimate) {
-                lowestNode = node;
-            }
-        }
-        return lowestNode;
-    }
-
-    private List<PathNode> getNeighbors(Vector2i pos, long nextCost, Vector2i target) {
-        List<PathNode> neighbors = new ArrayList<>();
-
-        addNeighbor(neighbors, new Vector2i(pos.x + 1, pos.y), nextCost, target);
-        addNeighbor(neighbors, new Vector2i(pos.x - 1, pos.y), nextCost, target);
-        addNeighbor(neighbors, new Vector2i(pos.x, pos.y + 1), nextCost, target);
-        addNeighbor(neighbors, new Vector2i(pos.x, pos.y - 1), nextCost, target);
-        return neighbors;
-    }
-
-    private void addNeighbor(List<PathNode> accumulator, Vector2i pos, long nextCost, Vector2i target) {
-        Vector2i right = new Vector2i(pos.x + 1, pos.y);
-        if (!walkable.call(pos)) {
-            return;
-        }
-        accumulator.add(
-            new PathNode(
-                right,
-                nextCost,
-                right.gridDistance(target) + nextCost
-            )
-        );
-    }
-}

src/main/java/de/towerdefence/server/game/pathfinding/NoPathException.java

@@ -1,4 +0,0 @@
-package de.towerdefence.server.game.pathfinding;
-
-public class NoPathException extends RuntimeException {
-}

src/main/java/de/towerdefence/server/game/pathfinding/OutOfBoundsException.java

@@ -1,4 +0,0 @@
-package de.towerdefence.server.game.pathfinding;
-
-public class OutOfBoundsException extends RuntimeException {
-}

src/main/java/de/towerdefence/server/game/pathfinding/PathNode.java

@@ -1,12 +0,0 @@
-package de.towerdefence.server.game.pathfinding;
-
-import org.joml.Vector2i;
-
-import lombok.AllArgsConstructor;
-
-@AllArgsConstructor
-final class PathNode {
-    final Vector2i pos;
-    final long cost; // This is the cost to this Node
-    final long estimate; // This is the estimated remaining cost to the Target
-}

src/main/java/de/towerdefence/server/game/pathfinding/WalkableCallback.java

@@ -1,8 +0,0 @@
-package de.towerdefence.server.game.pathfinding;
-
-import org.joml.Vector2i;
-
-@FunctionalInterface
-public interface WalkableCallback {
-    boolean call(Vector2i pos);
-}

src/main/java/de/towerdefence/server/match/Enemy.java

@@ -0,0 +1,13 @@
+package de.towerdefence.server.match;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class Enemy {
+    private int poxX;
+    private int posY;
+}

src/main/java/de/towerdefence/server/match/GameSession.java

@@ -0,0 +1,54 @@
+package de.towerdefence.server.match;
+
+import de.towerdefence.server.match.callbacks.PlayerHitpointsCallback;
+import de.towerdefence.server.match.callbacks.PlayerMoneyCallback;
+import de.towerdefence.server.match.exeptions.InvalidPlacementException;
+import de.towerdefence.server.match.exeptions.InvalidPlacementReason;
+import de.towerdefence.server.player.Player;
+import lombok.Getter;
+
+public class GameSession {
+    final static int START_HITPOINTS = 100;
+    final static int START_MONEY = 50;
+    final static int MAP_SIZE_X = 10;
+    final static int MAP_SIZE_Y = 20;
+
+    private final Tower[][] towers = new Tower[MAP_SIZE_X][MAP_SIZE_Y];
+
+    private final Player player;
+    @Getter
+    private int money;
+    @Getter
+    private int playerHitpoints;
+    private final PlayerMoneyCallback moneyCallback;
+    //private final PlayerHitpointsCallback hitpointsCallback;
+
+    public GameSession(Player player, PlayerMoneyCallback moneyCallback) {
+        this.player = player;
+        this.moneyCallback = moneyCallback;
+        //this.hitpointsCallback = hitpointsCallback;
+        this.money = START_MONEY;
+        this.playerHitpoints = START_HITPOINTS;
+
+    }
+
+    public void placeTower(Tower tower, int x, int y) throws InvalidPlacementException {
+        if (x < 0 || y < 0 || x + 1 > MAP_SIZE_X || y + 1 > MAP_SIZE_Y) {
+            throw new InvalidPlacementException(InvalidPlacementReason.OUT_OF_BOUNDS);
+        }
+        if (towers[x][y] != null) {
+            throw new InvalidPlacementException(InvalidPlacementReason.LOCATION_USED);
+        }
+        if (money < Tower.COST) {
+            throw new InvalidPlacementException(InvalidPlacementReason.NOT_ENOUGH_MONEY);
+        }
+        money -= Tower.COST;
+        moneyCallback.call(player, money);
+        towers[x][y] = tower;
+    }
+
+    public void addMoney(int amount) {
+        money += amount;
+        moneyCallback.call(player, money);
+    }
+}

src/main/java/de/towerdefence/server/match/Match.java

@@ -1,15 +1,12 @@
 package de.towerdefence.server.match;
 
-import de.towerdefence.server.game.callbacks.PlayerHitpointsCallback;
+import de.towerdefence.server.match.callbacks.PlayerHitpointsCallback;
-import java.util.Optional;
+import de.towerdefence.server.match.callbacks.PlayerMoneyCallback;
-
-import de.towerdefence.server.game.GameSession;
-import de.towerdefence.server.game.callbacks.EnemiesChangedCallback;
-import de.towerdefence.server.game.callbacks.PlayerMoneyCallback;
-import de.towerdefence.server.game.callbacks.PlayerHitpointsCallback;
 import de.towerdefence.server.player.Player;
 import lombok.Getter;
 
+import java.util.Optional;
+
 @Getter
 public class Match {
 
@@ -54,8 +51,7 @@ public class Match {
     public void connectPlayer(
         Player player,
         PlayerMoneyCallback moneyCallback,
-        PlayerHitpointsCallback hitpointsCallback,
+        PlayerHitpointsCallback hitpointsCallback
-        EnemiesChangedCallback enemyCallback
     ) {
         boolean isPlayer1 = player1.equals(player);
         boolean isPlayer2 = player2.equals(player);
@@ -63,11 +59,11 @@ public class Match {
             return;
         }
         if (isPlayer1 && player1Session == null) {
-            this.player1Session = new GameSession(player, moneyCallback, hitpointsCallback, enemyCallback);
+            this.player1Session = new GameSession(player, moneyCallback);
             return;
         }
         if (isPlayer2 && player2Session == null) {
-            this.player2Session = new GameSession(player, moneyCallback, hitpointsCallback, enemyCallback);
+            this.player2Session = new GameSession(player, moneyCallback);
             return;
         }
     }

src/main/java/de/towerdefence/server/match/MatchService.java

@@ -1,25 +1,17 @@
 package de.towerdefence.server.match;
 
-import de.towerdefence.server.game.callbacks.PlayerHitpointsCallback;
+import de.towerdefence.server.match.callbacks.PlayerHitpointsCallback;
-import de.towerdefence.server.game.callbacks.PlayerMoneyCallback;
+import de.towerdefence.server.match.callbacks.PlayerMoneyCallback;
-import de.towerdefence.server.game.exeptions.InvalidPlacementException;
+import de.towerdefence.server.match.exeptions.InvalidPlacementException;
-import de.towerdefence.server.game.exeptions.InvalidPlacementReason;
+import de.towerdefence.server.match.exeptions.InvalidPlacementReason;
+import de.towerdefence.server.match.exeptions.NotInMatchException;
 import de.towerdefence.server.player.Player;
-
-import org.joml.Vector2i;
 import org.springframework.stereotype.Service;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.Executors;
+import java.util.concurrent.*;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-import de.towerdefence.server.game.GameSession;
-import de.towerdefence.server.game.Tower;
-import de.towerdefence.server.game.callbacks.EnemiesChangedCallback;
 
 @Service
 public class MatchService {
@@ -53,25 +45,24 @@ public class MatchService {
         if (opponent.isEmpty()) {
             throw new NotInMatchException();
         }
-        playerSession.get().placeTower(new Tower(), new Vector2i(x, y));
+        playerSession.get().placeTower(new Tower(), x, y);
         return opponent.get();
     }
 
     public void playerConnected(
         Player player,
         PlayerMoneyCallback moneyCallback,
-        PlayerHitpointsCallback hitpointsCallback,
+        PlayerHitpointsCallback hitpointsCallback
-        EnemiesChangedCallback enemyCallback
     ) {
         Match match = playerMatches.get(player);
-        match.connectPlayer(player, moneyCallback, hitpointsCallback, enemyCallback);
+        match.connectPlayer(player, moneyCallback, hitpointsCallback);
         Optional<GameSession> optionalPlayerSession = match.getPlayerGameSession(player);
         if (optionalPlayerSession.isEmpty()) {
             return;
         }
         GameSession playerSession = optionalPlayerSession.get();
         moneyCallback.call(player, playerSession.getMoney());
-        hitpointsCallback.call(player, playerSession.getPlayerHitpoints());
+        hitpointsCallback.call(player, playerSession.getPlayerHitpoints() );
         if (!match.hasMatchStarted()) {
             return;
         }
@@ -86,13 +77,13 @@ public class MatchService {
         }
         GameSession opponentSession = optionalOpponentSession.get();
         ScheduledFuture<?> moneyTask = scheduler.scheduleAtFixedRate(
-        () -> {
+                () -> {
-            playerSession.addMoney(3);
+                    playerSession.addMoney(3);
-            opponentSession.addMoney(3);
+                    opponentSession.addMoney(3);
-        },
+                },
-        5,
+                5,
-        5,
+                5,
-        TimeUnit.SECONDS);
+                TimeUnit.SECONDS);
         moneyTasks.put(match, moneyTask);
     }
 }

src/main/java/de/towerdefence/server/match/Tower.java

@@ -0,0 +1,5 @@
+package de.towerdefence.server.match;
+
+public class Tower {
+    public static final int COST = 20;
+}

src/main/java/de/towerdefence/server/match/callbacks/PlayerHitpointsCallback.java

@@ -1,4 +1,4 @@
-package de.towerdefence.server.game.callbacks;
+package de.towerdefence.server.match.callbacks;
 
 import de.towerdefence.server.player.Player;
 

src/main/java/de/towerdefence/server/match/callbacks/PlayerMoneyCallback.java

@@ -1,4 +1,4 @@
-package de.towerdefence.server.game.callbacks;
+package de.towerdefence.server.match.callbacks;
 
 import de.towerdefence.server.player.Player;
 

src/main/java/de/towerdefence/server/match/exeptions/InvalidPlacementException.java

@@ -1,4 +1,4 @@
-package de.towerdefence.server.game.exeptions;
+package de.towerdefence.server.match.exeptions;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

src/main/java/de/towerdefence/server/match/exeptions/InvalidPlacementReason.java

@@ -1,4 +1,4 @@
-package de.towerdefence.server.game.exeptions;
+package de.towerdefence.server.match.exeptions;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

src/main/java/de/towerdefence/server/match/exeptions/NotInMatchException.java

@@ -1,4 +1,4 @@
-package de.towerdefence.server.match;
+package de.towerdefence.server.match.exeptions;
 
 public class NotInMatchException extends RuntimeException {
 }

src/main/java/de/towerdefence/server/server/channels/match/MatchWebsocketHandler.java

@@ -1,13 +1,11 @@
 package de.towerdefence.server.server.channels.match;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import de.towerdefence.server.game.Enemy;
-import de.towerdefence.server.game.exeptions.InvalidPlacementException;
 import de.towerdefence.server.match.MatchService;
-import de.towerdefence.server.match.NotInMatchException;
+import de.towerdefence.server.match.exeptions.InvalidPlacementException;
+import de.towerdefence.server.match.exeptions.NotInMatchException;
 import de.towerdefence.server.player.Player;
 import de.towerdefence.server.server.JsonWebsocketHandler;
-import de.towerdefence.server.server.channels.match.enemy.EnemyUpdateMessage;
 import de.towerdefence.server.server.channels.match.hitpoints.PlayerHitpointsMessage;
 import de.towerdefence.server.server.channels.match.money.PlayerMoneyMessage;
 import de.towerdefence.server.server.channels.match.placing.GamePlayerMap;
@@ -16,13 +14,14 @@ import de.towerdefence.server.server.channels.match.placing.RequestTowerPlacingM
 import de.towerdefence.server.server.channels.match.placing.TowerPlacedMessage;
 import de.towerdefence.server.session.Channel;
 import de.towerdefence.server.session.SessionsService;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.TextMessage;
+import org.springframework.web.socket.WebSocketSession;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
-import org.springframework.web.socket.CloseStatus;
-import org.springframework.web.socket.TextMessage;
-import org.springframework.web.socket.WebSocketSession;
 
 public class MatchWebsocketHandler extends JsonWebsocketHandler {
 
@@ -42,18 +41,10 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
         matchService.playerConnected(
             sessionPlayers.get(session),
             this::onPlayerMoneyChanged,
-            this::onPlayerHitpointsChanged,
+            this::onPlayerHitpointsChanged
-            this::onEnemiesChanged
         );
     }
 
-    @Override
-    protected void closeSession(WebSocketSession session, CloseStatus reason) {
-        Player player = sessionPlayers.get(session);
-        super.closeSession(session, reason);
-        playerSessions.remove(player);
-    }
-
     private void onPlayerMoneyChanged(Player player, int playerMoney) {
         WebSocketSession session = playerSessions.get(player);
         try {
@@ -70,12 +61,11 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
         }
     }
 
-    private void onEnemiesChanged(Player player, Enemy[] newEnemies, Enemy[] changedEnemies) {
+    @Override
-        WebSocketSession session = playerSessions.get(player);
+    protected void closeSession(WebSocketSession session, CloseStatus reason) {
-        try {
+        Player player = sessionPlayers.get(session);
-            new EnemyUpdateMessage(newEnemies, changedEnemies).send(session);
+        super.closeSession(session, reason);
-        } catch (IOException ignored) {
+        playerSessions.remove(player);
-        }
     }
 
     @Override
@@ -83,9 +73,9 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
         try {
             String payload = message.getPayload();
             if (!Objects.equals(
-                        objectMapper.readTree(payload).get("$id").asText(),
+                objectMapper.readTree(payload).get("$id").asText(),
-                        RequestTowerPlacingMessage.MESSAGE_ID
+                RequestTowerPlacingMessage.MESSAGE_ID
-                    )) {
+            )) {
                 this.closeSession(session, CloseStatus.BAD_DATA);
                 return;
             }
@@ -93,15 +83,17 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
         } catch (IOException ignored) {
             this.closeSession(session, CloseStatus.BAD_DATA);
         }
+
     }
 
-    private void handleRequestTowerPlacingMessage(WebSocketSession session, String payload)
+    private void handleRequestTowerPlacingMessage(
-    throws IOException {
+        WebSocketSession session,
-        RequestTowerPlacingMessage msg =
+        String payload
-        objectMapper.readValue(payload, RequestTowerPlacingMessage.class);
+    ) throws IOException {
+        RequestTowerPlacingMessage msg = objectMapper.readValue(payload, RequestTowerPlacingMessage.class);
         Player opponent;
         try {
-            opponent =this.matchService.placeTower(
+            opponent = this.matchService.placeTower(
                 this.sessionPlayers.get(session),
                 msg.getX(),
                 msg.getY()

src/main/java/de/towerdefence/server/server/channels/match/enemy/EnemyUpdateMessage.java

@@ -1,59 +0,0 @@
-package de.towerdefence.server.server.channels.match.enemy;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ArrayNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-import de.towerdefence.server.game.Enemy;
-import de.towerdefence.server.server.JsonMessage;
-import lombok.AllArgsConstructor;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-@AllArgsConstructor
-public class EnemyUpdateMessage extends JsonMessage {
-
-    private final Enemy[] newEnemies;
-    private final Enemy[] changedEnemies;
-
-    @Override
-    protected String getMessageId() {
-        return "EnemyUpdate";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-
-        List<JsonNode> newArray = Arrays
-                .stream(newEnemies)
-                .map((Enemy enemy) -> {
-                    ObjectNode o = factory.objectNode();
-                    o.set("id", factory.numberNode(enemy.getId()));
-                    o.set("x", factory.numberNode(enemy.getPos().x));
-                    o.set("y", factory.numberNode(enemy.getPos().y));
-                    return o;
-                })
-                .map(JsonNode.class::cast)
-                .toList();
-
-        List<JsonNode> changedArray = Arrays
-                .stream(changedEnemies)
-                .map((Enemy enemy) -> {
-                    ObjectNode o = factory.objectNode();
-                    o.set("id", factory.numberNode(enemy.getId()));
-                    o.set("x", factory.numberNode(enemy.getPos().x));
-                    o.set("y", factory.numberNode(enemy.getPos().y));
-                    return o;
-                })
-                .map(JsonNode.class::cast)
-                .toList();
-
-        return Map.of(
-            "new", new ArrayNode(factory, newArray),
-            "changed", new ArrayNode(factory, changedArray)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/match/placing/InvalidPlacementMessage.java

@@ -1,14 +1,14 @@
 package de.towerdefence.server.server.channels.match.placing;
 
-import java.util.Map;
-
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 
-import de.towerdefence.server.game.exeptions.InvalidPlacementReason;
+import de.towerdefence.server.match.exeptions.InvalidPlacementReason;
 import de.towerdefence.server.server.JsonMessage;
 import lombok.AllArgsConstructor;
 
+import java.util.Map;
+
 @AllArgsConstructor
 public class InvalidPlacementMessage extends JsonMessage {
 
@@ -24,9 +24,8 @@ public class InvalidPlacementMessage extends JsonMessage {
     @Override
     protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
         return Map.of(
-                   "x", factory.numberNode(this.x),
+                "x", factory.numberNode(this.x),
-                   "y", factory.numberNode(this.y),
+                "y", factory.numberNode(this.y),
-                   "reason", factory.textNode(this.reason.getJsonName())
+                "reason", factory.textNode(this.reason.getJsonName()));
-               );
     }
 }

src/main/java/de/towerdefence/server/server/channels/match/placing/TowerPlacedMessage.java

@@ -22,9 +22,9 @@ public class TowerPlacedMessage extends JsonMessage {
     @Override
     protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
         return Map.of(
-                   "x", factory.numberNode(this.x),
+            "x", factory.numberNode(this.x),
-                   "y", factory.numberNode(this.y),
+            "y", factory.numberNode(this.y),
-                   "map", factory.textNode(this.map.getJsonName())
+            "map", factory.textNode(this.map.getJsonName())
-               );
+        );
     }
 }

src/main/resources/spotbugs-exclude.xml

@@ -25,10 +25,4 @@
         <Method name="placeTower"/>
         <Bug code="L,B,ISC"/>
     </Match>
-    <Match>
-        <!-- This will be used soon -->
-        <Class name="de.towerdefence.server.game.GameSession"/>
-        <Field name="hitpointsCallback"/>
-        <Bug code="L,P,UrF"/>
-    </Match>
 </FindBugsFilter>

ws/ws.yml

@@ -253,23 +253,8 @@ channels:
           required:
             - $id
             - playerHitpoints
-      EnemyUpdate:
+
-        description: All Information needed to updated the Enemy Information in Game
+
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            new:
-              type: array
-            changed:
-              type: array
-          required:
-            - $id
-            - new
-            - changed
 
 operations:
   requestConnectionToken:
@@ -358,13 +343,6 @@ operations:
       $ref: "#/channels/match"
     messages:
       - $ref: "#/channels/match/messages/PlayerHitpoints"
-  enemyUpdate:
-    title: EnemyUpdate
-    action: receive
-    channel:
-      $ref: "#/channels/match"
-    messages:
-      - $ref: "#/channels/match/messages/EnemyUpdate"