fix: tile ownership changes

gameserver/commands/OnLeaveCommand.ts

@@ -7,6 +7,5 @@ export class OnLeaveCommand extends Command<SessionRoom, CommandPayload> {
  execute({ client, message, gameManager }: CommandPayload) {
  const sessionId = client.sessionId;
  this.state.removePlayer(sessionId, gameManager!);
- this.state.tilemap.updateOwnershipMap(this.state.getPlayers());
  }
 }

gameserver/commands/OnSpawnPointSelectCommand.ts

@@ -42,7 +42,8 @@ export class OnSpawnPointSelectCommand extends Command<
  return;
  }
  const player = this.state.getPlayer(client.id);
- player?.updatePosition(requestedPoint.x, requestedPoint.y);
+ if(!player) return;
+ player.updatePosition(requestedPoint.x, requestedPoint.y);
  this.state.tilemap.updateOwnershipMap(this.state.getPlayers());
  }
 }

gameserver/schema/PlayerState.ts

@@ -145,7 +145,6 @@ export class PlayerState extends Schema implements ISceneItem {
 
  sessionState.onCaptureFlagRemoved(flagId);
  this.resourceGrowthRateHz = 2 * (1 + 0.2 * this.captureFlags.length);
- sessionState.tilemap.updateOwnershipMap(sessionState.getPlayers());
  }
  removeBulkCaptureFlag(
  flagIds: string[],

gameserver/schema/SessionState.ts

@@ -34,11 +34,7 @@ export class SessionState extends Schema {
  return this.players.get(sessionId);
  }
  public getPlayers() {
- let playersArr = [];
- for (let player of this.players.entries()) {
- playersArr.push(player[1]);
- }
- return playersArr;
+ return this.players;
  }
 
  onCaptureFlagAdded(flagId: string, parentId: string) {

gameserver/schema/SoldierState.ts

@@ -391,18 +391,21 @@ export class SoldierState extends Schema implements ISceneItem, IBoidAgent {
  flagQuatree.id
  );
  if (!flagOwnerId) return;
- const flag = sessionState
- .getPlayer(flagOwnerId)
- ?.captureFlags.toArray()
+
+ const flagOwner = sessionState.getPlayer(flagOwnerId);
+ if (!flagOwner) return;
+
+ const [flag] = sessionState
+ .getPlayer(flagOwnerId)!
+ .captureFlags.toArray()
  .filter((flag) => flag.id === flagQuatree.id);
 
- if (flag && flag?.[0]) {
- flag[0].setHealth(flag[0].health - 0.5 * delta);
- if(flag[0].health === 0)
- sessionState
- .getPlayer(flagOwnerId)
- ?.removeCaptureFlag(flag[0].id, sessionState, stateManager);
- }
+ if (!flag) return;
+
+ flag.setHealth(flag.health - 0.5 * delta);
+ if (flag.health > 0) return;
+ flagOwner.removeCaptureFlag(flag.id, sessionState, stateManager);
+ sessionState.tilemap.updateOwnershipMap(sessionState.getPlayers());
  });
 
  this.stateMachine.tick({ delta, stateManager, soldier: this });

gameserver/schema/TilemapState.ts

@@ -1,8 +1,7 @@
-import { Schema, type, ArraySchema } from "@colyseus/schema";
+import { Schema, type, MapSchema, ArraySchema } from "@colyseus/schema";
 import { createNoise2D } from "simplex-noise";
 import { PlayerState } from "./PlayerState";
 import SAT from "sat";
-
 export enum ETileType {
  DIRT = "dirt",
  GRASS = "grass",
@@ -50,62 +49,87 @@ export class TilemapState extends Schema {
  return new SAT.Vector(col, row);
  }
 
- getTileTypeAt(index: number) {
+ getTileTypeAt(index: number) : ETileType {
  const tileId = this.tilemap1D.at(index);
  return TilesTypeById[tileId];
  }
 
- updateOwnershipMap(players: PlayerState[]) {
+ updateOwnershipMap(players: MapSchema<PlayerState, string>) {
  for (
  let tileIndex1D = 0;
  tileIndex1D < this.ownershipTilemap1D.length;
  tileIndex1D++
  ) {
  const tileType = this.getTileTypeAt(tileIndex1D);
- if (tileType === "water") continue;
-
- const currentOwner = this.ownershipTilemap1D.at(tileIndex1D);
- const newOwner = this.selectTileOwner(tileIndex1D, players);
+ if (tileType === ETileType.WATER) continue;
 
- if (newOwner !== "NONE" && currentOwner !== "NONE") {
- continue;
- }
- if (newOwner === currentOwner) continue;
- this.ownershipTilemap1D[tileIndex1D] = newOwner;
+ this.ownershipTilemap1D[tileIndex1D] = this.getTileOwner(
+ tileIndex1D,
+ players
+ );
  }
  }
 
- private selectTileOwner(
- tileIndex: number,
- players: PlayerState[]
+ private isTileWithinPlayerReach(
+ player: PlayerState | undefined,
+ tile1DIndex: number
+ ): boolean {
+ if (!player) return false;
+ const minDistance = TilemapState.TILE_INFLUENCE_DISTANCE;
+ let isValidOwner = false;
+ const castleAndCaptureFlagPos = player.captureFlags.map((flag) =>
+ flag.pos.getVector()
+ );
+ castleAndCaptureFlagPos.push(player.pos.getVector());
+
+ const tilePos = this.get2DIndex(tile1DIndex);
+ for (const pos of castleAndCaptureFlagPos) {
+ pos.x = Math.floor(pos.x / this.tilewidth);
+ pos.y = Math.floor(pos.y / this.tileheight);
+ const distanceFromTile = pos.sub(tilePos).len();
+ if (distanceFromTile >= minDistance) continue;
+ isValidOwner = true;
+ break;
+ }
+
+ return isValidOwner;
+ }
+ private getTileOwner(
+ tile1DIndex: number,
+ players: MapSchema<PlayerState, string>
  ): string | "NONE" {
- let ownerId = "NONE";
+ const currentOwner = this.ownershipTilemap1D.at(tile1DIndex);
+ let ownerId = players.has(currentOwner) ? currentOwner : "NONE";
+ let isTileWithinCurrentOwnerReach = this.isTileWithinPlayerReach(
+ players.get(ownerId),
+ tile1DIndex
+ );
+
+ // if tile currently has an active owner that satisfies the ownership creteria
+ if (isTileWithinCurrentOwnerReach) return ownerId;
+
+ ownerId = 'NONE';
  let minDistance = TilemapState.TILE_INFLUENCE_DISTANCE;
 
- for (const player of players) {
- const captureFlagPos = player.captureFlags.map((flag) =>
+ let hasOwner: boolean = false;
+ for (const [_, player] of players) {
+ const castleAndCaptureFlagPos = player.captureFlags.map((flag) =>
  flag.pos.getVector()
  );
- const territoryFlagPositions = [
- player.pos.getVector(),
- ...captureFlagPos,
- ];
+ castleAndCaptureFlagPos.push(player.pos.getVector());
 
- territoryFlagPositions.forEach((pos) => {
-  // Convert to tile coordinates
+ const tilePos = this.get2DIndex(tile1DIndex);
+ for (const pos of castleAndCaptureFlagPos) {
  pos.x = Math.floor(pos.x / this.tilewidth);
  pos.y = Math.floor(pos.y / this.tileheight);
-
- const tilePos = this.get2DIndex(tileIndex);
-
  const distanceFromTile = pos.sub(tilePos).len();
- if (distanceFromTile >= minDistance) return;
-
+ if (distanceFromTile >= minDistance) continue;
+ hasOwner = true;
  minDistance = distanceFromTile;
  ownerId = player.id;
- });
+ }
  }
- return ownerId;
+ return hasOwner ? ownerId : "NONE";
  }
 
  async generateTilemap() {

public/gameObjects/CaptureFlag.ts

@@ -91,7 +91,8 @@ export class CaptureFlag
  y: number,
  radius: number
  ) {
- this.circleOfInfluence = scene.add.graphics();
+ if(!this.circleOfInfluence)
+ this.circleOfInfluence = scene.add.graphics();
  this.circleOfInfluence.lineStyle(3, 0xffffff);
  this.circleOfInfluence.strokeCircle(x, y, radius);
  }

public/scenes/GameScene.ts

@@ -459,8 +459,8 @@ export class GameScene extends BaseScene {
  // update tilemap for every tile update received.
  this.AddStateChangeListener(
  GameSessionState.tilemap.ownershipTilemap1D.onChange(
- (owner, tileIndex) => {
- this.updateTilemap(networkManager, owner, tileIndex);
+ (owner, tile1DIndex) => {
+ this.updateTilemap(networkManager, owner, tile1DIndex);
  }
  )
  );
@@ -531,7 +531,6 @@ export class GameScene extends BaseScene {
 
  this.AddSceneEvent(
  GAMEEVENTS.DELETE_SELECTED_OBJECTS, () => {
- console.log('requested to delete seelcted objects');
  const selectedObjectsMap = this.data.get(
  DataKey.SELECTED_OBJECTS_MAP
  ) as Map<string, BaseSoldier | CaptureFlag>;
@@ -704,9 +703,9 @@ export class GameScene extends BaseScene {
  `obj_captureFlag_${player.id}_${newFlag.id}`
  );
  if (!flag) return;
- this.DestroyObjectById(`obj_captureFlag_${player.id}_${newFlag.id}`);
+ this.DestroyObjectById(`obj_captureFlag_${player.id}_${flag.id}`);
  this.DestroyStateChangeListener(
- `statechange_captureFlag_${player.id}_${newFlag.id}`
+ `statechange_captureFlag_${player.id}_${flag.id}`
  );
  })
  );
@@ -715,10 +714,10 @@ export class GameScene extends BaseScene {
  this.AddStateChangeListener(
  state.players.onRemove((player) => {
  const kingdomId = `obj_playerCastle_${player.id}`;
+ this.DestroyObjectById(kingdomId);
  this.events.emit(PacketType.ByServer.PLAYER_LEFT, {
  playerState: player,
  });
- this.DestroyObjectById(kingdomId);
  })
  );
 

public/scenes/PlayerStatisticHUD.ts

@@ -9,6 +9,7 @@ import { NetworkManager } from "../NetworkManager";
 import { PlayerState } from "../../gameserver/schema/PlayerState";
 import { Spearman } from "../soldiers/Spearman";
 import CONSTANTS from "../constant";
+import { CaptureFlag } from "../gameObjects/CaptureFlag";
 
 const textStyle: Phaser.Types.GameObjects.Text.TextStyle = {
  color: "#fff",
@@ -198,6 +199,11 @@ export class PlayerStatisticHUD extends BaseScene {
  gameScene.onSoldierRemoved(soldier.id, playerObject.id);
  });
 
+ const captureFlags = gameScene.GetObjectsWithKeyPrefix<CaptureFlag>(
+ `obj_captureFlag_${playerObject.id}`
+ );
+ captureFlags.forEach((flag) => flag.destroy(true));
+
  soldierCount.setText(
  `Total Soldiers: ${[...state.players.values()].reduce((acc, curr) => {
  acc = acc + curr.soldiers.size;