Compare commits

..

No commits in common. "story/td-5-gegnerwellen" and "trunk" have entirely different histories.

28 changed files with 135 additions and 503 deletions

View file

@ -28,17 +28,6 @@ jobs:
- name: "Stop Gradle" - name: "Stop Gradle"
run: gradle --stop 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: linting:
name: "Linting" name: "Linting"
runs-on: stable runs-on: stable

View file

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

View file

@ -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;
}

View file

@ -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);
}
}

View file

@ -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() {
}
}

View file

@ -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);
}

View file

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

View file

@ -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
)
);
}
}

View file

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

View file

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

View file

@ -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
}

View file

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

View file

@ -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;
}

View file

@ -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);
}
}

View file

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

View file

@ -1,25 +1,17 @@
package de.towerdefence.server.match; 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 de.towerdefence.server.player.Player;
import org.joml.Vector2i;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Optional; 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 @Service
public class MatchService { public class MatchService {
@ -53,18 +45,17 @@ public class MatchService {
if (opponent.isEmpty()) { if (opponent.isEmpty()) {
throw new NotInMatchException(); throw new NotInMatchException();
} }
playerSession.get().placeTower(new Tower(), new Vector2i(x, y)); playerSession.get().placeTower(new Tower(), x, y);
return opponent.get(); return opponent.get();
} }
public void playerConnected( public void playerConnected(
Player player, Player player,
PlayerMoneyCallback moneyCallback, PlayerMoneyCallback moneyCallback,
PlayerHitpointsCallback hitpointsCallback, PlayerHitpointsCallback hitpointsCallback
EnemiesChangedCallback enemyCallback
) { ) {
Match match = playerMatches.get(player); Match match = playerMatches.get(player);
match.connectPlayer(player, moneyCallback, hitpointsCallback, enemyCallback); match.connectPlayer(player, moneyCallback, hitpointsCallback);
Optional<GameSession> optionalPlayerSession = match.getPlayerGameSession(player); Optional<GameSession> optionalPlayerSession = match.getPlayerGameSession(player);
if (optionalPlayerSession.isEmpty()) { if (optionalPlayerSession.isEmpty()) {
return; return;

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -1,13 +1,11 @@
package de.towerdefence.server.server.channels.match; package de.towerdefence.server.server.channels.match;
import com.fasterxml.jackson.databind.ObjectMapper; 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.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.player.Player;
import de.towerdefence.server.server.JsonWebsocketHandler; 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.hitpoints.PlayerHitpointsMessage;
import de.towerdefence.server.server.channels.match.money.PlayerMoneyMessage; import de.towerdefence.server.server.channels.match.money.PlayerMoneyMessage;
import de.towerdefence.server.server.channels.match.placing.GamePlayerMap; 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.server.channels.match.placing.TowerPlacedMessage;
import de.towerdefence.server.session.Channel; import de.towerdefence.server.session.Channel;
import de.towerdefence.server.session.SessionsService; 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.io.IOException;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap; 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 { public class MatchWebsocketHandler extends JsonWebsocketHandler {
@ -42,18 +41,10 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
matchService.playerConnected( matchService.playerConnected(
sessionPlayers.get(session), sessionPlayers.get(session),
this::onPlayerMoneyChanged, 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) { private void onPlayerMoneyChanged(Player player, int playerMoney) {
WebSocketSession session = playerSessions.get(player); WebSocketSession session = playerSessions.get(player);
try { 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 @Override
@ -93,12 +83,14 @@ public class MatchWebsocketHandler extends JsonWebsocketHandler {
} catch (IOException ignored) { } catch (IOException ignored) {
this.closeSession(session, CloseStatus.BAD_DATA); 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; Player opponent;
try { try {
opponent = this.matchService.placeTower( opponent = this.matchService.placeTower(

View file

@ -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)
);
}
}

View file

@ -1,14 +1,14 @@
package de.towerdefence.server.server.channels.match.placing; package de.towerdefence.server.server.channels.match.placing;
import java.util.Map;
import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory; 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 de.towerdefence.server.server.JsonMessage;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import java.util.Map;
@AllArgsConstructor @AllArgsConstructor
public class InvalidPlacementMessage extends JsonMessage { public class InvalidPlacementMessage extends JsonMessage {
@ -26,7 +26,6 @@ public class InvalidPlacementMessage extends JsonMessage {
return Map.of( 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()));
);
} }
} }

View file

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

View file

@ -253,23 +253,8 @@ channels:
required: required:
- $id - $id
- playerHitpoints - 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: operations:
requestConnectionToken: requestConnectionToken:
@ -358,13 +343,6 @@ operations:
$ref: "#/channels/match" $ref: "#/channels/match"
messages: messages:
- $ref: "#/channels/match/messages/PlayerHitpoints" - $ref: "#/channels/match/messages/PlayerHitpoints"
enemyUpdate:
title: EnemyUpdate
action: receive
channel:
$ref: "#/channels/match"
messages:
- $ref: "#/channels/match/messages/EnemyUpdate"