attack working

src/client/ClientGameRunner.ts

@@ -14,7 +14,7 @@ import { DisplayMessageEvent } from '../core/game/Game';
 import { WorkerClient } from "../core/worker/WorkerClient";
 import { consolex, initRemoteSender } from "../core/Consolex";
 import { getConfig, getServerConfig } from "../core/configuration/Config";
-import { GameUpdateViewData, GameView } from "../core/GameView";
+import { GameUpdateViewData, GameView, PlayerView } from "../core/GameView";
 
 export interface LobbyConfig {
     playerName: () => string
@@ -99,7 +99,7 @@ export async function createClientGame(lobbyConfig: LobbyConfig, gameConfig: Gam
 }
 
 export class ClientGameRunner {
-    private myPlayer: Player
+    private myPlayer: PlayerView
     private isActive = false
 
     private turnsSeen = 0
@@ -124,7 +124,7 @@ export class ClientGameRunner {
         this.input.initialize()
         this.worker.start((gu: GameUpdateViewData) => {
             const size = gu.packedTileUpdates.length * 4 / 1000
-            console.log(`game update size: ${size}kb`)
+            // console.log(`game update size: ${size}kb`)
             this.gameView.update(gu)
             this.renderer.tick()
         })
@@ -204,9 +204,17 @@ export class ClientGameRunner {
 
         if (tile.terrain().isLand()) {
             if (tile.hasOwner()) {
-                if (this.myPlayer.sharesBorderWith(tile.owner())) {
-                    this.eventBus.emit(new SendAttackIntentEvent(targetID, this.myPlayer.troops() * this.renderer.uiState.attackRatio))
-                }
+                this.myPlayer.sharesBorderWithAsync(tile.owner()).then(sharesBorder => {
+                    if (sharesBorder) {
+                        this.eventBus.emit(
+
+                            new SendAttackIntentEvent(
+                                targetID,
+                                this.myPlayer.troops() * this.renderer.uiState.attackRatio
+                            )
+                        )
+                    }
+                })
             } else {
                 outer_loop: for (const t of bfs(tile, and(t => !t.hasOwner() && t.terrain().isLand(), dist(tile, 200)))) {
                     for (const n of t.neighbors()) {

src/core/GameView.ts

@@ -29,7 +29,7 @@ export class TileView {
     type(): TerrainType {
         return this._terrain.type()
     }
-    owner(): Player | TerraNullius {
+    owner(): PlayerView | TerraNullius {
         if (!this.hasOwner()) {
             return new TerraNulliusImpl()
         }
@@ -195,6 +195,11 @@ export class PlayerView implements Player {
     sharesBorderWith(other: Player | TerraNullius): boolean {
         return false
     }
+
+    async sharesBorderWithAsync(other: Player | TerraNullius): Promise<boolean> {
+        return this.game.worker.sharesBorderWith(this.id(), other.id())
+    }
+
     incomingAllianceRequests(): AllianceRequest[] {
         return []
     }
@@ -255,7 +260,7 @@ export class GameView {
     private tiles: TileView[][] = []
     private smallIDToID = new Map<number, PlayerID>()
 
-    constructor(private worker: WorkerClient, private _config: Config, private _terrainMap: TerrainMap) {
+    constructor(public worker: WorkerClient, private _config: Config, private _terrainMap: TerrainMap) {
         // Initialize the 2D array
         this.tiles = Array(_terrainMap.width()).fill(null).map(() => Array(_terrainMap.height()).fill(null));
 
@@ -289,21 +294,21 @@ export class GameView {
         return this.data.tileUpdates.filter(d => true).map(tu => new TileView(this, tu, this._terrainMap.terrain(new Cell(tu.x, tu.y))))
     }
 
-    player(id: PlayerID): Player {
+    player(id: PlayerID): PlayerView {
         if (id in this.data.players) {
             return new PlayerView(this, this.data.players[id])
         }
         throw Error(`player id ${id} not found`)
     }
 
-    playerBySmallID(id: number): Player {
+    playerBySmallID(id: number): PlayerView {
         if (!this.smallIDToID.has(id)) {
             throw new Error(`small id ${id} not found`)
         }
         return this.player(this.smallIDToID.get(id))
     }
 
-    playerByClientID(id: ClientID): Player | null {
+    playerByClientID(id: ClientID): PlayerView | null {
         const pd = Object.values(this.data.players).filter(p => p.clientID == id)[0] ?? null
         if (pd == null) {
             return null