feat: allow trade ships to trade with own ports at reduced gold

src/core/configuration/Config.ts

@@ -129,6 +129,7 @@ export interface Config {
   unitInfo(type: UnitType): UnitInfo;
   tradeShipShortRangeDebuff(): number;
   tradeShipGold(dist: number, player: Player | PlayerView): Gold;
+  tradeShipSelfGoldMultiplier(): number;
   tradeShipSpawnRate(
     tradeShipSpawnRejections: number,
     numTradeShips: number,

src/core/configuration/DefaultConfig.ts

@@ -322,6 +322,10 @@ export class DefaultConfig implements Config {
     return BigInt(Math.floor(baseGold * this.goldMultiplierFor(player)));
   }
 
+  tradeShipSelfGoldMultiplier(): number {
+    return 0.4;
+  }
+
   // Probability of trade ship spawn = 1 / tradeShipSpawnRate
   tradeShipSpawnRate(
     tradeShipSpawnRejections: number,

src/core/execution/PortExecution.ts

@@ -103,10 +103,18 @@ export class PortExecution implements Execution {
       const comp = this.mg.getWaterComponent(neighbor);
       if (comp !== null) sourceComponents.add(comp);
     }
-    const ports = this.mg
+    const owner = this.port!.owner();
+
+    // Other players' ports (existing logic)
+    const otherPorts = this.mg
       .players()
-      .filter((p) => p !== this.port!.owner() && p.canTrade(this.port!.owner()))
-      .flatMap((p) => p.units(UnitType.Port))
+      .filter((p) => p !== owner && p.canTrade(owner))
+      .flatMap((p) => p.units(UnitType.Port));
+
+    // Own ports (excluding the source port itself)
+    const ownPorts = owner.units(UnitType.Port).filter((p) => p !== this.port!);
+
+    const ports = [...otherPorts, ...ownPorts]
       .filter((p) => {
         for (const comp of sourceComponents) {
           if (this.mg.hasWaterComponent(p.tile(), comp)) return true;
@@ -123,8 +131,11 @@ export class PortExecution implements Execution {
     const weightedPorts: Unit[] = [];
 
     for (const [i, otherPort] of ports.entries()) {
+      const isSelfTrade = otherPort.owner() === owner;
       const expanded = new Array(otherPort.level()).fill(otherPort);
+      // Self-trade ports get base weight only (no proximity/friendly bonuses)
       weightedPorts.push(...expanded);
+      if (isSelfTrade) continue;
       const tooClose =
         this.mg.manhattanDist(this.port!.tile(), otherPort.tile()) <
         this.mg.config().tradeShipShortRangeDebuff();
@@ -135,7 +146,7 @@ export class PortExecution implements Execution {
         // to increase the chances of trading with it.
         weightedPorts.push(...expanded);
       }
-      if (!tooClose && this.port!.owner().isFriendly(otherPort.owner())) {
+      if (!tooClose && owner.isFriendly(otherPort.owner())) {
         weightedPorts.push(...expanded);
       }
     }

src/core/execution/TradeShipExecution.ts

@@ -21,14 +21,17 @@ export class TradeShipExecution implements Execution {
   private tilesTraveled = 0;
   private motionPlanId = 1;
   private motionPlanDst: TileRef | null = null;
+  private readonly isSelfTrade: boolean;
 
   private static _staggerCounter = 0;
 
   constructor(
     private origOwner: Player,
     private srcPort: Unit,
     private _dstPort: Unit,
-  ) {}
+  ) {
+    this.isSelfTrade = srcPort.owner() === _dstPort.owner();
+  }
 
   init(mg: Game, ticks: number): void {
     this.mg = mg;
@@ -72,22 +75,30 @@ export class TradeShipExecution implements Execution {
     }
 
     // If a player captures another player's port while trading we should delete
-    // the ship.
-    if (dstPortOwner.id() === this.srcPort.owner().id()) {
+    // the ship — but not if it was intentionally a self-trade.
+    if (!this.isSelfTrade && dstPortOwner.id() === this.srcPort.owner().id()) {
       this.tradeShip.delete(false);
       this.active = false;
       return;
     }
 
     if (
       !this.wasCaptured &&
+      !this.isSelfTrade &&
       (!this._dstPort.isActive() || !tradeShipOwner.canTrade(dstPortOwner))
     ) {
       this.tradeShip.delete(false);
       this.active = false;
       return;
     }
 
+    // For self-trade, still check if the destination port is active
+    if (this.isSelfTrade && !this._dstPort.isActive()) {
+      this.tradeShip.delete(false);
+      this.active = false;
+      return;
+    }
+
     const curTile = this.tradeShip.tile();
 
     if (
@@ -168,7 +179,7 @@ export class TradeShipExecution implements Execution {
   private complete() {
     this.active = false;
     this.tradeShip!.delete(false);
-    const gold = this.mg
+    let gold = this.mg
       .config()
       .tradeShipGold(this.tilesTraveled, this.tradeShip!.owner());
 
@@ -188,6 +199,25 @@ export class TradeShipExecution implements Execution {
       this.mg
         .stats()
         .boatCapturedTrade(this.tradeShip!.owner(), this.origOwner, gold);
+    } else if (this.isSelfTrade) {
+      // Self-trade: reduced gold, credited once
+      const multiplier = this.mg.config().tradeShipSelfGoldMultiplier();
+      gold = BigInt(Math.floor(Number(gold) * multiplier));
+      this.srcPort.owner().addGold(gold, this._dstPort.tile());
+      this.mg.displayMessage(
+        "events_display.received_gold_from_trade",
+        MessageType.RECEIVED_GOLD_FROM_TRADE,
+        this.srcPort.owner().id(),
+        gold,
+        {
+          gold: renderNumber(gold),
+          name: this.srcPort.owner().displayName(),
+        },
+      );
+      // Record stats
+      this.mg
+        .stats()
+        .boatArriveTrade(this.srcPort.owner(), this._dstPort.owner(), gold);
     } else {
       this.srcPort.owner().addGold(gold);
       this._dstPort.owner().addGold(gold, this._dstPort.tile());

tests/PortExecution.test.ts

@@ -104,4 +104,76 @@ describe("PortExecution", () => {
 
     expect(ports.length).toBe(1);
   });
+
+  test("Self-trade: own ports appear as destinations", () => {
+    game.config().proximityBonusPortsNb = () => 0;
+    game.config().tradeShipShortRangeDebuff = () => 0;
+    game.config().structureMinDist = () => 0;
+
+    player.conquer(game.ref(7, 5));
+    player.conquer(game.ref(7, 15));
+    const spawn1 = player.canBuild(UnitType.Port, game.ref(7, 5));
+    const spawn2 = player.canBuild(UnitType.Port, game.ref(7, 15));
+    if (spawn1 === false || spawn2 === false) {
+      throw new Error("Unable to build ports for test");
+    }
+    const port1 = player.buildUnit(UnitType.Port, spawn1, {});
+    player.buildUnit(UnitType.Port, spawn2, {});
+
+    const execution = new PortExecution(port1);
+    execution.init(game, 0);
+    execution.tick(0);
+
+    const ports = execution.tradingPorts();
+
+    // Should include the player's other port
+    expect(ports.length).toBeGreaterThanOrEqual(1);
+    expect(ports.some((p) => p.owner() === player)).toBe(true);
+  });
+
+  test("Self-trade: port does not trade with itself", () => {
+    game.config().proximityBonusPortsNb = () => 0;
+    game.config().tradeShipShortRangeDebuff = () => 0;
+
+    player.conquer(game.ref(7, 10));
+    const spawn = player.canBuild(UnitType.Port, game.ref(7, 10));
+    if (spawn === false) {
+      throw new Error("Unable to build port for test");
+    }
+    const port = player.buildUnit(UnitType.Port, spawn, {});
+
+    const execution = new PortExecution(port);
+    execution.init(game, 0);
+    execution.tick(0);
+
+    const ports = execution.tradingPorts();
+
+    // With only one own port and no other player ports, no destinations available
+    expect(ports.length).toBe(0);
+  });
+
+  test("Self-trade: own ports do not get proximity or friendly bonuses", () => {
+    game.config().proximityBonusPortsNb = () => 10;
+    game.config().tradeShipShortRangeDebuff = () => 0;
+    game.config().structureMinDist = () => 0;
+
+    player.conquer(game.ref(7, 5));
+    player.conquer(game.ref(7, 15));
+    const spawn1 = player.canBuild(UnitType.Port, game.ref(7, 5));
+    const spawn2 = player.canBuild(UnitType.Port, game.ref(7, 15));
+    if (spawn1 === false || spawn2 === false) {
+      throw new Error("Unable to build ports for test");
+    }
+    const port1 = player.buildUnit(UnitType.Port, spawn1, {});
+    player.buildUnit(UnitType.Port, spawn2, {});
+
+    const execution = new PortExecution(port1);
+    execution.init(game, 0);
+    execution.tick(0);
+
+    const ports = execution.tradingPorts();
+
+    // Own port at level 1 should appear once (base weight only, no bonuses)
+    expect(ports.length).toBe(1);
+  });
 });