Cancel nukes when accepting alliance via radial menu (#3155)

Resolves #3154

## Description:

#2716 introduced nuke cancellation logic on alliance acceptance via
`AllianceRequestReplyExecution`. The radial menu action, though, calls
`AllianceRequestExecution` instead, which accepts the alliance if a
request has already been made by the other player.

This PR moves the nuke cancellation logic to `GameImpl`, hooking into
the `acceptAllianceRequest` method, therefore accounting for every
alliance acceptance, regardless of the specific action that brought to
that.

## Please complete the following:

- [x] I have added screenshots for all UI updates
- [x] I process any text displayed to the user through translateText()
and I've added it to the en.json file
- [x] I have added relevant tests to the test directory
- [x] I confirm I have thoroughly tested these changes and take full
responsibility for any bugs introduced

## Please put your Discord username so you can be contacted if a bug or
regression is found:

deshack_82603

src/client/Transport.ts

@@ -55,13 +55,8 @@ export class SendUpgradeStructureIntentEvent implements GameEvent {
   ) {}
 }
 
-export class SendAllianceReplyIntentEvent implements GameEvent {
-  constructor(
-    // The original alliance requestor
-    public readonly requestor: PlayerView,
-    public readonly recipient: PlayerView,
-    public readonly accepted: boolean,
-  ) {}
+export class SendAllianceRejectIntentEvent implements GameEvent {
+  constructor(public readonly requestor: PlayerView) {}
 }
 
 export class SendAllianceExtensionIntentEvent implements GameEvent {
@@ -204,8 +199,8 @@ export class Transport {
     this.eventBus.on(SendAllianceRequestIntentEvent, (e) =>
       this.onSendAllianceRequest(e),
     );
-    this.eventBus.on(SendAllianceReplyIntentEvent, (e) =>
-      this.onAllianceRequestReplyUIEvent(e),
+    this.eventBus.on(SendAllianceRejectIntentEvent, (e) =>
+      this.onAllianceRejectUIEvent(e),
     );
     this.eventBus.on(SendAllianceExtensionIntentEvent, (e) =>
       this.onSendAllianceExtensionIntent(e),
@@ -447,11 +442,10 @@ export class Transport {
     });
   }
 
-  private onAllianceRequestReplyUIEvent(event: SendAllianceReplyIntentEvent) {
+  private onAllianceRejectUIEvent(event: SendAllianceRejectIntentEvent) {
     this.sendIntent({
-      type: "allianceRequestReply",
+      type: "allianceReject",
       requestor: event.requestor.id(),
-      accept: event.accepted,
     });
   }
 

src/client/graphics/layers/EventsDisplay.ts

@@ -24,7 +24,8 @@ import {
 } from "../../../core/game/GameUpdates";
 import {
   SendAllianceExtensionIntentEvent,
-  SendAllianceReplyIntentEvent,
+  SendAllianceRejectIntentEvent,
+  SendAllianceRequestIntentEvent,
 } from "../../Transport";
 import { Layer } from "./Layer";
 
@@ -468,16 +469,14 @@ export class EventsDisplay extends LitElement implements Layer {
           className: "btn",
           action: () =>
             this.eventBus.emit(
-              new SendAllianceReplyIntentEvent(requestor, recipient, true),
+              new SendAllianceRequestIntentEvent(recipient, requestor),
             ),
         },
         {
           text: translateText("events_display.reject_alliance"),
           className: "btn-info",
           action: () =>
-            this.eventBus.emit(
-              new SendAllianceReplyIntentEvent(requestor, recipient, false),
-            ),
+            this.eventBus.emit(new SendAllianceRejectIntentEvent(requestor)),
         },
       ],
       highlight: true,

src/core/Schemas.ts

@@ -34,7 +34,7 @@ export type Intent =
   | BoatAttackIntent
   | CancelBoatIntent
   | AllianceRequestIntent
-  | AllianceRequestReplyIntent
+  | AllianceRejectIntent
   | AllianceExtensionIntent
   | BreakAllianceIntent
   | TargetPlayerIntent
@@ -60,9 +60,7 @@ export type BoatAttackIntent = z.infer<typeof BoatAttackIntentSchema>;
 export type EmbargoAllIntent = z.infer<typeof EmbargoAllIntentSchema>;
 export type CancelBoatIntent = z.infer<typeof CancelBoatIntentSchema>;
 export type AllianceRequestIntent = z.infer<typeof AllianceRequestIntentSchema>;
-export type AllianceRequestReplyIntent = z.infer<
-  typeof AllianceRequestReplyIntentSchema
->;
+export type AllianceRejectIntent = z.infer<typeof AllianceRejectIntentSchema>;
 export type BreakAllianceIntent = z.infer<typeof BreakAllianceIntentSchema>;
 export type TargetPlayerIntent = z.infer<typeof TargetPlayerIntentSchema>;
 export type EmojiIntent = z.infer<typeof EmojiIntentSchema>;
@@ -316,10 +314,9 @@ export const AllianceRequestIntentSchema = z.object({
   recipient: ID,
 });
 
-export const AllianceRequestReplyIntentSchema = z.object({
-  type: z.literal("allianceRequestReply"),
-  requestor: ID, // The one who made the original alliance request
-  accept: z.boolean(),
+export const AllianceRejectIntentSchema = z.object({
+  type: z.literal("allianceReject"),
+  requestor: ID,
 });
 
 export const BreakAllianceIntentSchema = z.object({
@@ -431,7 +428,7 @@ const IntentSchema = z.discriminatedUnion("type", [
   BoatAttackIntentSchema,
   CancelBoatIntentSchema,
   AllianceRequestIntentSchema,
-  AllianceRequestReplyIntentSchema,
+  AllianceRejectIntentSchema,
   BreakAllianceIntentSchema,
   TargetPlayerIntentSchema,
   EmojiIntentSchema,

src/core/execution/ExecutionManager.ts

@@ -3,8 +3,8 @@ import { PseudoRandom } from "../PseudoRandom";
 import { ClientID, GameID, StampedIntent, Turn } from "../Schemas";
 import { simpleHash } from "../Util";
 import { AllianceExtensionExecution } from "./alliance/AllianceExtensionExecution";
+import { AllianceRejectExecution } from "./alliance/AllianceRejectExecution";
 import { AllianceRequestExecution } from "./alliance/AllianceRequestExecution";
-import { AllianceRequestReplyExecution } from "./alliance/AllianceRequestReplyExecution";
 import { BreakAllianceExecution } from "./alliance/BreakAllianceExecution";
 import { AttackExecution } from "./AttackExecution";
 import { BoatRetreatExecution } from "./BoatRetreatExecution";
@@ -75,12 +75,8 @@ export class Executor {
         return new TransportShipExecution(player, intent.dst, intent.troops);
       case "allianceRequest":
         return new AllianceRequestExecution(player, intent.recipient);
-      case "allianceRequestReply":
-        return new AllianceRequestReplyExecution(
-          intent.requestor,
-          player,
-          intent.accept,
-        );
+      case "allianceReject":
+        return new AllianceRejectExecution(intent.requestor, player);
       case "breakAlliance":
         return new BreakAllianceExecution(player, intent.recipient);
       case "targetPlayer":

src/core/execution/alliance/AllianceRejectExecution.ts

@@ -0,0 +1,49 @@
+import { Execution, Game, Player, PlayerID } from "../../game/Game";
+
+export class AllianceRejectExecution implements Execution {
+  private active = true;
+
+  constructor(
+    private requestorID: PlayerID,
+    private recipient: Player,
+  ) {}
+
+  init(mg: Game, ticks: number): void {
+    if (!mg.hasPlayer(this.requestorID)) {
+      console.warn(
+        `[AllianceRejectExecution] Requestor ${this.requestorID} not found`,
+      );
+      this.active = false;
+      return;
+    }
+    const requestor = mg.player(this.requestorID);
+
+    if (requestor.isFriendly(this.recipient)) {
+      console.warn(
+        `[AllianceRejectExecution] Player ${this.requestorID} cannot reject alliance with ${this.recipient.id}, already allied`,
+      );
+    } else {
+      const request = requestor
+        .outgoingAllianceRequests()
+        .find((ar) => ar.recipient() === this.recipient);
+      if (request === undefined) {
+        console.warn(
+          `[AllianceRejectExecution] Player ${this.requestorID} cannot reject alliance with ${this.recipient.id}, no alliance request found`,
+        );
+      } else {
+        request.reject();
+      }
+    }
+    this.active = false;
+  }
+
+  tick(ticks: number): void {}
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+}

src/core/execution/alliance/AllianceRequestExecution.ts

@@ -2,8 +2,10 @@ import {
   AllianceRequest,
   Execution,
   Game,
+  MessageType,
   Player,
   PlayerID,
+  UnitType,
 } from "../../game/Game";
 
 export class AllianceRequestExecution implements Execution {
@@ -39,6 +41,19 @@ export class AllianceRequestExecution implements Execution {
         // then accept it instead of creating a new one.
         this.active = false;
         incoming.accept();
+
+        // Update player relations
+        this.requestor.updateRelation(recipient, 100);
+        recipient.updateRelation(this.requestor, 100);
+
+        // Automatically remove embargoes only if they were automatically created
+        if (this.requestor.hasEmbargoAgainst(recipient))
+          this.requestor.endTemporaryEmbargo(recipient);
+        if (recipient.hasEmbargoAgainst(this.requestor))
+          recipient.endTemporaryEmbargo(this.requestor);
+
+        // Cancel incoming nukes between players
+        this.cancelNukesBetweenAlliedPlayers(recipient);
       } else {
         this.req = this.requestor.createAllianceRequest(recipient);
       }
@@ -69,4 +84,51 @@ export class AllianceRequestExecution implements Execution {
   activeDuringSpawnPhase(): boolean {
     return false;
   }
+
+  cancelNukesBetweenAlliedPlayers(recipient: Player): void {
+    const neutralized = new Map<Player, number>();
+
+    const players = [this.requestor, recipient];
+
+    for (const launcher of players) {
+      for (const unit of launcher.units(
+        UnitType.AtomBomb,
+        UnitType.HydrogenBomb,
+      )) {
+        if (!unit.isActive() || unit.reachedTarget()) continue;
+
+        const targetTile = unit.targetTile();
+        if (!targetTile) continue;
+
+        const targetOwner = this.mg.owner(targetTile);
+        if (!targetOwner.isPlayer()) continue;
+
+        const other = launcher === this.requestor ? recipient : this.requestor;
+        if (targetOwner !== other) continue;
+
+        unit.delete(false);
+        neutralized.set(launcher, (neutralized.get(launcher) ?? 0) + 1);
+      }
+    }
+
+    for (const [launcher, count] of neutralized) {
+      const other = launcher === this.requestor ? recipient : this.requestor;
+
+      this.mg.displayMessage(
+        "events_display.alliance_nukes_destroyed_outgoing",
+        MessageType.ALLIANCE_ACCEPTED,
+        launcher.id(),
+        undefined,
+        { name: other.displayName(), count },
+      );
+
+      this.mg.displayMessage(
+        "events_display.alliance_nukes_destroyed_incoming",
+        MessageType.ALLIANCE_ACCEPTED,
+        other.id(),
+        undefined,
+        { name: launcher.displayName(), count },
+      );
+    }
+  }
 }

src/core/execution/alliance/AllianceRequestReplyExecution.ts

@@ -1,117 +0,0 @@
-import {
-  Execution,
-  Game,
-  MessageType,
-  Player,
-  PlayerID,
-  UnitType,
-} from "../../game/Game";
-
-export class AllianceRequestReplyExecution implements Execution {
-  private active = true;
-  private requestor: Player | null = null;
-
-  constructor(
-    private requestorID: PlayerID,
-    private recipient: Player,
-    private accept: boolean,
-  ) {}
-
-  private cancelNukesBetweenAlliedPlayers(
-    mg: Game,
-    p1: Player,
-    p2: Player,
-  ): void {
-    const neutralized = new Map<Player, number>();
-
-    const players = [p1, p2];
-
-    for (const launcher of players) {
-      for (const unit of launcher.units(
-        UnitType.AtomBomb,
-        UnitType.HydrogenBomb,
-      )) {
-        if (!unit.isActive() || unit.reachedTarget()) continue;
-
-        const targetTile = unit.targetTile();
-        if (!targetTile) continue;
-
-        const targetOwner = mg.owner(targetTile);
-        if (!targetOwner.isPlayer()) continue;
-
-        const other = launcher === p1 ? p2 : p1;
-        if (targetOwner !== other) continue;
-
-        unit.delete(false);
-        neutralized.set(launcher, (neutralized.get(launcher) ?? 0) + 1);
-      }
-    }
-
-    for (const [launcher, count] of neutralized) {
-      const other = launcher === p1 ? p2 : p1;
-
-      mg.displayMessage(
-        "events_display.alliance_nukes_destroyed_outgoing",
-        MessageType.ALLIANCE_ACCEPTED,
-        launcher.id(),
-        undefined,
-        { name: other.displayName(), count },
-      );
-
-      mg.displayMessage(
-        "events_display.alliance_nukes_destroyed_incoming",
-        MessageType.ALLIANCE_ACCEPTED,
-        other.id(),
-        undefined,
-        { name: launcher.displayName(), count },
-      );
-    }
-  }
-
-  init(mg: Game, ticks: number): void {
-    if (!mg.hasPlayer(this.requestorID)) {
-      console.warn(
-        `AllianceRequestReplyExecution requester ${this.requestorID} not found`,
-      );
-      this.active = false;
-      return;
-    }
-    this.requestor = mg.player(this.requestorID);
-
-    if (this.requestor.isFriendly(this.recipient)) {
-      console.warn("already allied");
-    } else {
-      const request = this.requestor
-        .outgoingAllianceRequests()
-        .find((ar) => ar.recipient() === this.recipient);
-      if (request === undefined) {
-        console.warn("no alliance request found");
-      } else {
-        if (this.accept) {
-          request.accept();
-          this.requestor.updateRelation(this.recipient, 100);
-          this.recipient.updateRelation(this.requestor, 100);
-
-          this.cancelNukesBetweenAlliedPlayers(
-            mg,
-            this.requestor,
-            this.recipient,
-          );
-        } else {
-          request.reject();
-        }
-      }
-    }
-    this.active = false;
-  }
-
-  tick(ticks: number): void {}
-
-  isActive(): boolean {
-    return this.active;
-  }
-
-  activeDuringSpawnPhase(): boolean {
-    return false;
-  }
-}

src/core/game/GameImpl.ts

@@ -332,12 +332,6 @@ export class GameImpl implements Game {
       request,
     );
 
-    // Automatically remove embargoes only if they were automatically created
-    if (requestor.hasEmbargoAgainst(recipient))
-      requestor.endTemporaryEmbargo(recipient);
-    if (recipient.hasEmbargoAgainst(requestor))
-      recipient.endTemporaryEmbargo(requestor);
-
     this.addUpdate({
       type: GameUpdateType.AllianceRequestReply,
       request: request.toUpdate(),