refactor: have players store attacks

src/core/game/AttackImpl.ts

@@ -0,0 +1,49 @@
+import { Attack, Player, TerraNullius } from "./Game";
+import { TileRef } from "./GameMap";
+import { PlayerImpl } from "./PlayerImpl";
+
+export class AttackImpl implements Attack {
+  private _isActive = true;
+
+  constructor(
+    private _target: Player | TerraNullius,
+    private _attacker: Player,
+    private _troops: number,
+    private _sourceTile: TileRef | null
+  ) {}
+
+  sourceTile(): TileRef | null {
+    return this._sourceTile;
+  }
+
+  target(): Player | TerraNullius {
+    return this._target;
+  }
+  attacker(): Player {
+    return this._attacker;
+  }
+  troops(): number {
+    return this._troops;
+  }
+  setTroops(troops: number) {
+    this._troops = troops;
+  }
+
+  isActive() {
+    return this._isActive;
+  }
+
+  delete() {
+    if (this._target.isPlayer()) {
+      (this._target as PlayerImpl)._incomingAttacks = (
+        this._target as PlayerImpl
+      )._incomingAttacks.filter((a) => a != this);
+    }
+
+    (this._attacker as PlayerImpl)._outgoingAttacks = (
+      this._attacker as PlayerImpl
+    )._outgoingAttacks.filter((a) => a != this);
+
+    this._isActive = false;
+  }
+}

src/core/game/Game.ts

@@ -135,6 +135,17 @@ export interface Execution {
   owner(): Player;
 }
 
+export interface Attack {
+  target(): Player | TerraNullius;
+  attacker(): Player;
+  troops(): number;
+  setTroops(troops: number): void;
+  isActive(): boolean;
+  delete(): void;
+  // The tile the attack originated from, mostly used for boat attacks.
+  sourceTile(): TileRef | null;
+}
+
 export interface AllianceRequest {
   accept(): void;
   reject(): void;
@@ -284,12 +295,21 @@ export interface Player {
   canDonate(recipient: Player): boolean;
   donate(recipient: Player, troops: number): void;
 
+  // Attacking.
+  canAttack(tile: TileRef): boolean;
+  createAttack(
+    target: Player | TerraNullius,
+    troops: number,
+    sourceTile: TileRef
+  ): Attack;
+  outgoingAttacks(): Attack[];
+  incomingAttacks(): Attack[];
+
   // Misc
   executions(): Execution[];
   toUpdate(): PlayerUpdate;
   playerProfile(): PlayerProfile;
   canBoat(tile: TileRef): boolean;
-  canAttack(tile: TileRef);
 }
 
 export interface Game extends GameMap {
@@ -324,8 +344,6 @@ export interface Game extends GameMap {
   unitInfo(type: UnitType): UnitInfo;
   nearbyDefensePosts(tile: TileRef): Unit[];
 
-  // Events & Messages
-  executions(): Execution[];
   addExecution(...exec: Execution[]): void;
   displayMessage(
     message: string,

src/core/game/PlayerImpl.ts

@@ -17,6 +17,7 @@ import {
   Relation,
   EmojiMessage,
   PlayerProfile,
+  Attack,
 } from "./Game";
 import { PlayerUpdate } from "./GameUpdates";
 import { GameUpdateType } from "./GameUpdates";
@@ -37,6 +38,7 @@ import { renderTroops } from "../../client/Utils";
 import { TerraNulliusImpl } from "./TerraNulliusImpl";
 import { andFN, manhattanDistFN, TileRef } from "./GameMap";
 import { Emoji } from "discord.js";
+import { AttackImpl } from "./AttackImpl";
 
 interface Target {
   tick: Tick;
@@ -75,6 +77,9 @@ export class PlayerImpl implements Player {
 
   private relations = new Map<Player, number>();
 
+  public _incomingAttacks: Attack[] = [];
+  public _outgoingAttacks: Attack[] = [];
+
   constructor(
     private mg: GameImpl,
     private _smallID: number,
@@ -759,6 +764,25 @@ export class PlayerImpl implements Player {
     }
   }
 
+  createAttack(
+    target: Player | TerraNullius,
+    troops: number,
+    sourceTile: TileRef
+  ): Attack {
+    const attack = new AttackImpl(target, this, troops, sourceTile);
+    this._outgoingAttacks.push(attack);
+    if (target.isPlayer()) {
+      (target as PlayerImpl)._incomingAttacks.push(attack);
+    }
+    return attack;
+  }
+  outgoingAttacks(): Attack[] {
+    return this._outgoingAttacks;
+  }
+  incomingAttacks(): Attack[] {
+    return this._incomingAttacks;
+  }
+
   public canAttack(tile: TileRef): boolean {
     if (
       this.mg.hasOwner(tile) &&