mirror of
https://github.com/openfrontio/OpenFrontIO.git
synced 2026-06-21 09:30:45 +00:00
Packed unit updates / MotionPlans (#3292)
## Description: Reduce per-step `Unit` update traffic by shipping packed motion plans and letting the client advance plan-driven units locally. Changes: - Add packed motion plan records (`packedMotionPlans?: Uint32Array`) to game updates and transfer the buffer worker -> main. - Introduce `src/core/game/MotionPlans.ts` (schema + pack/unpack) for grid + train motion plans. - Extend `Game` with `recordMotionPlan(...)` and `drainPackedMotionPlans()`, and implement buffering/packing in `GameImpl`. - Treat units with motion plans as “plan-driven”: suppress per-tile `Unit` updates on `move()` and advance positions client-side. - Emit motion plans from executions: - `TradeShipExecution`: record/update grid motion plans and `touch()` when changing target after capture. - `TransportShipExecution`: record initial plan and update it when destination changes. - `TrainExecution`: record a train plan on init (engine + cars). - Client: apply motion plans in `GameView` and ensure `UnitLayer` updates sprites for motion-planned units even when no `Unit` updates arrived. ## Please complete the following: - [ ] I have added screenshots for all UI updates - [ ] I process any text displayed to the user through translateText() and I've added it to the en.json file - [ ] I have added relevant tests to the test directory - [ ] 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: DISCORD_USERNAME
This commit is contained in:
scamiv
@@ -65,11 +65,27 @@ export class UnitLayer implements Layer {
|
||||
}
|
||||
|
||||
tick() {
|
||||
const unitIds = this.game
|
||||
.updatesSinceLastTick()
|
||||
?.[GameUpdateType.Unit]?.map((unit) => unit.id);
|
||||
const updatedUnitIds =
|
||||
this.game
|
||||
.updatesSinceLastTick()
|
||||
?.[GameUpdateType.Unit]?.map((unit) => unit.id) ?? [];
|
||||
|
||||
this.updateUnitsSprites(unitIds ?? []);
|
||||
const motionPlanUnitIds = this.game.motionPlannedUnitIds();
|
||||
|
||||
if (updatedUnitIds.length === 0) {
|
||||
this.updateUnitsSprites(motionPlanUnitIds);
|
||||
return;
|
||||
}
|
||||
if (motionPlanUnitIds.length === 0) {
|
||||
this.updateUnitsSprites(updatedUnitIds);
|
||||
return;
|
||||
}
|
||||
|
||||
const unitIds = new Set<number>(updatedUnitIds);
|
||||
for (const id of motionPlanUnitIds) {
|
||||
unitIds.add(id);
|
||||
}
|
||||
this.updateUnitsSprites(Array.from(unitIds));
|
||||
}
|
||||
|
||||
init() {
|
||||
|
||||
@@ -170,10 +170,12 @@ export class GameRunner {
|
||||
}
|
||||
|
||||
const packedTileUpdates = this.game.drainPackedTileUpdates();
|
||||
const packedMotionPlans = this.game.drainPackedMotionPlans();
|
||||
|
||||
this.callBack({
|
||||
tick: this.game.ticks(),
|
||||
packedTileUpdates,
|
||||
...(packedMotionPlans ? { packedMotionPlans } : {}),
|
||||
updates: updates,
|
||||
playerNameViewData: this.playerViewData,
|
||||
tickExecutionDuration: tickExecutionDuration,
|
||||
|
||||
@@ -19,6 +19,8 @@ export class TradeShipExecution implements Execution {
|
||||
private wasCaptured = false;
|
||||
private pathFinder: SteppingPathFinder<TileRef>;
|
||||
private tilesTraveled = 0;
|
||||
private motionPlanId = 1;
|
||||
private motionPlanDst: TileRef | null = null;
|
||||
|
||||
constructor(
|
||||
private origOwner: Player,
|
||||
@@ -93,6 +95,8 @@ export class TradeShipExecution implements Execution {
|
||||
} else {
|
||||
this._dstPort = ports[0];
|
||||
this.tradeShip.setTargetUnit(this._dstPort);
|
||||
// Plan-driven units don't emit per-tick unit updates, so force a sync for the new target.
|
||||
this.tradeShip.touch();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -102,14 +106,29 @@ export class TradeShipExecution implements Execution {
|
||||
return;
|
||||
}
|
||||
|
||||
const result = this.pathFinder.next(curTile, this._dstPort.tile());
|
||||
const dst = this._dstPort.tile();
|
||||
const result = this.pathFinder.next(curTile, dst);
|
||||
|
||||
switch (result.status) {
|
||||
case PathStatus.PENDING:
|
||||
// Fire unit event to rerender.
|
||||
this.tradeShip.move(curTile);
|
||||
break;
|
||||
case PathStatus.NEXT:
|
||||
if (dst !== this.motionPlanDst) {
|
||||
this.motionPlanId++;
|
||||
const from = result.node;
|
||||
const path = this.pathFinder.findPath(from, dst) ?? [from];
|
||||
if (path.length === 0 || path[0] !== from) {
|
||||
path.unshift(from);
|
||||
}
|
||||
|
||||
this.mg.recordMotionPlan({
|
||||
kind: "grid",
|
||||
unitId: this.tradeShip.id(),
|
||||
planId: this.motionPlanId,
|
||||
startTick: ticks + 1,
|
||||
ticksPerStep: 1,
|
||||
path,
|
||||
});
|
||||
this.motionPlanDst = dst;
|
||||
}
|
||||
// Update safeFromPirates status
|
||||
if (this.mg.isWater(result.node) && this.mg.isShoreline(result.node)) {
|
||||
this.tradeShip.setSafeFromPirates();
|
||||
@@ -119,14 +138,14 @@ export class TradeShipExecution implements Execution {
|
||||
break;
|
||||
case PathStatus.COMPLETE:
|
||||
this.complete();
|
||||
break;
|
||||
return;
|
||||
case PathStatus.NOT_FOUND:
|
||||
console.warn("captured trade ship cannot find route");
|
||||
if (this.tradeShip.isActive()) {
|
||||
this.tradeShip.delete(false);
|
||||
}
|
||||
this.active = false;
|
||||
break;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -7,6 +7,7 @@ import {
|
||||
UnitType,
|
||||
} from "../game/Game";
|
||||
import { TileRef } from "../game/GameMap";
|
||||
import { MotionPlanRecord } from "../game/MotionPlans";
|
||||
import { RailNetwork } from "../game/RailNetwork";
|
||||
import { getOrientedRailroad, OrientedRailroad } from "../game/Railroad";
|
||||
import { TrainStation } from "../game/TrainStation";
|
||||
@@ -63,6 +64,36 @@ export class TrainExecution implements Execution {
|
||||
return;
|
||||
}
|
||||
this.train = this.createTrainUnits(spawn);
|
||||
|
||||
const carUnitIds = this.cars.map((c) => c.id());
|
||||
const pathTiles: TileRef[] = [];
|
||||
for (let i = 0; i + 1 < this.stations.length; i++) {
|
||||
const segment = getOrientedRailroad(
|
||||
this.stations[i],
|
||||
this.stations[i + 1],
|
||||
);
|
||||
if (!segment) {
|
||||
this.active = false;
|
||||
return;
|
||||
}
|
||||
pathTiles.push(...segment.getTiles());
|
||||
}
|
||||
const startTile = this.train.tile();
|
||||
if (pathTiles.length === 0 || pathTiles[0] !== startTile) {
|
||||
pathTiles.unshift(startTile);
|
||||
}
|
||||
|
||||
const plan: MotionPlanRecord = {
|
||||
kind: "train",
|
||||
engineUnitId: this.train.id(),
|
||||
carUnitIds,
|
||||
planId: 1,
|
||||
startTick: ticks + 1,
|
||||
speed: this.speed,
|
||||
spacing: this.spacing,
|
||||
path: pathTiles,
|
||||
};
|
||||
this.mg.recordMotionPlan(plan);
|
||||
}
|
||||
|
||||
tick(ticks: number): void {
|
||||
|
||||
@@ -9,6 +9,7 @@ import {
|
||||
UnitType,
|
||||
} from "../game/Game";
|
||||
import { TileRef } from "../game/GameMap";
|
||||
import { MotionPlanRecord } from "../game/MotionPlans";
|
||||
import { targetTransportTile } from "../game/TransportShipUtils";
|
||||
import { PathFinding } from "../pathfinding/PathFinder";
|
||||
import { PathStatus, SteppingPathFinder } from "../pathfinding/types";
|
||||
@@ -31,6 +32,8 @@ export class TransportShipExecution implements Execution {
|
||||
private src: TileRef | null;
|
||||
private retreatDst: TileRef | false | null = null;
|
||||
private boat: Unit;
|
||||
private motionPlanId = 1;
|
||||
private motionPlanDst: TileRef | null = null;
|
||||
|
||||
private originalOwner: Player;
|
||||
|
||||
@@ -110,6 +113,22 @@ export class TransportShipExecution implements Execution {
|
||||
targetTile: this.dst,
|
||||
});
|
||||
|
||||
const fullPath = this.pathFinder.findPath(this.src, this.dst) ?? [this.src];
|
||||
if (fullPath.length === 0 || fullPath[0] !== this.src) {
|
||||
fullPath.unshift(this.src);
|
||||
}
|
||||
|
||||
const motionPlan: MotionPlanRecord = {
|
||||
kind: "grid",
|
||||
unitId: this.boat.id(),
|
||||
planId: this.motionPlanId,
|
||||
startTick: ticks + this.ticksPerMove,
|
||||
ticksPerStep: this.ticksPerMove,
|
||||
path: fullPath,
|
||||
};
|
||||
this.mg.recordMotionPlan(motionPlan);
|
||||
this.motionPlanDst = this.dst;
|
||||
|
||||
// Notify the target player about the incoming naval invasion
|
||||
if (this.target.id() !== mg.terraNullius().id()) {
|
||||
mg.displayIncomingUnit(
|
||||
@@ -229,8 +248,6 @@ export class TransportShipExecution implements Execution {
|
||||
case PathStatus.NEXT:
|
||||
this.boat.move(result.node);
|
||||
break;
|
||||
case PathStatus.PENDING:
|
||||
break;
|
||||
case PathStatus.NOT_FOUND: {
|
||||
// TODO: add to poisoned port list
|
||||
const map = this.mg.map();
|
||||
@@ -244,6 +261,26 @@ export class TransportShipExecution implements Execution {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (this.dst !== null && this.dst !== this.motionPlanDst) {
|
||||
this.motionPlanId++;
|
||||
const fullPath = this.pathFinder.findPath(this.boat.tile(), this.dst) ?? [
|
||||
this.boat.tile(),
|
||||
];
|
||||
if (fullPath.length === 0 || fullPath[0] !== this.boat.tile()) {
|
||||
fullPath.unshift(this.boat.tile());
|
||||
}
|
||||
|
||||
this.mg.recordMotionPlan({
|
||||
kind: "grid",
|
||||
unitId: this.boat.id(),
|
||||
planId: this.motionPlanId,
|
||||
startTick: ticks + this.ticksPerMove,
|
||||
ticksPerStep: this.ticksPerMove,
|
||||
path: fullPath,
|
||||
});
|
||||
this.motionPlanDst = this.dst;
|
||||
}
|
||||
}
|
||||
|
||||
owner(): Player {
|
||||
|
||||
@@ -190,9 +190,6 @@ export class WarshipExecution implements Execution {
|
||||
case PathStatus.NEXT:
|
||||
this.warship.move(result.node);
|
||||
break;
|
||||
case PathStatus.PENDING:
|
||||
this.warship.touch();
|
||||
break;
|
||||
case PathStatus.NOT_FOUND: {
|
||||
console.log(`path not found to target`);
|
||||
break;
|
||||
@@ -221,9 +218,6 @@ export class WarshipExecution implements Execution {
|
||||
case PathStatus.NEXT:
|
||||
this.warship.move(result.node);
|
||||
break;
|
||||
case PathStatus.PENDING:
|
||||
this.warship.touch();
|
||||
return;
|
||||
case PathStatus.NOT_FOUND: {
|
||||
console.log(`path not found to target`);
|
||||
break;
|
||||
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
PlayerUpdate,
|
||||
UnitUpdate,
|
||||
} from "./GameUpdates";
|
||||
import { MotionPlanRecord } from "./MotionPlans";
|
||||
import { RailNetwork } from "./RailNetwork";
|
||||
import { Stats } from "./Stats";
|
||||
import { UnitPredicate } from "./UnitGrid";
|
||||
@@ -777,6 +778,8 @@ export interface Game extends GameMap {
|
||||
inSpawnPhase(): boolean;
|
||||
executeNextTick(): GameUpdates;
|
||||
drainPackedTileUpdates(): Uint32Array;
|
||||
recordMotionPlan(record: MotionPlanRecord): void;
|
||||
drainPackedMotionPlans(): Uint32Array | null;
|
||||
setWinner(winner: Player | Team, allPlayersStats: AllPlayersStats): void;
|
||||
getWinner(): Player | Team | null;
|
||||
config(): Config;
|
||||
|
||||
@@ -43,6 +43,7 @@ import {
|
||||
} from "./Game";
|
||||
import { GameMap, TileRef } from "./GameMap";
|
||||
import { GameUpdate, GameUpdateType } from "./GameUpdates";
|
||||
import { MotionPlanRecord, packMotionPlans } from "./MotionPlans";
|
||||
import { PlayerImpl } from "./PlayerImpl";
|
||||
import { RailNetwork } from "./RailNetwork";
|
||||
import { createRailNetwork } from "./RailNetworkImpl";
|
||||
@@ -95,6 +96,8 @@ export class GameImpl implements Game {
|
||||
|
||||
private updates: GameUpdates = createGameUpdatesMap();
|
||||
private tileUpdatePairs: number[] = [];
|
||||
private motionPlanRecords: MotionPlanRecord[] = [];
|
||||
private planDrivenUnitIds = new Set<number>();
|
||||
private unitGrid: UnitGrid;
|
||||
|
||||
private playerTeams: Team[] = [];
|
||||
@@ -444,6 +447,46 @@ export class GameImpl implements Game {
|
||||
return packed;
|
||||
}
|
||||
|
||||
recordMotionPlan(record: MotionPlanRecord): void {
|
||||
switch (record.kind) {
|
||||
case "grid":
|
||||
this.planDrivenUnitIds.add(record.unitId);
|
||||
break;
|
||||
case "train":
|
||||
this.planDrivenUnitIds.add(record.engineUnitId);
|
||||
for (const unitId of record.carUnitIds) {
|
||||
this.planDrivenUnitIds.add(unitId);
|
||||
}
|
||||
break;
|
||||
}
|
||||
this.motionPlanRecords.push(record);
|
||||
}
|
||||
|
||||
private isUnitPlanDriven(unitId: number): boolean {
|
||||
return this.planDrivenUnitIds.has(unitId);
|
||||
}
|
||||
|
||||
maybeAddUnitUpdate(unit: Unit): void {
|
||||
if (!this.isUnitPlanDriven(unit.id())) {
|
||||
this.addUpdate(unit.toUpdate());
|
||||
}
|
||||
}
|
||||
|
||||
onUnitMoved(unit: Unit): void {
|
||||
this.updateUnitTile(unit);
|
||||
this.maybeAddUnitUpdate(unit);
|
||||
}
|
||||
|
||||
drainPackedMotionPlans(): Uint32Array | null {
|
||||
const records = this.motionPlanRecords;
|
||||
if (records.length === 0) {
|
||||
return null;
|
||||
}
|
||||
const packed = packMotionPlans(records);
|
||||
records.length = 0;
|
||||
return packed;
|
||||
}
|
||||
|
||||
private hash(): number {
|
||||
let hash = 1;
|
||||
this._players.forEach((p) => {
|
||||
@@ -887,6 +930,7 @@ export class GameImpl implements Game {
|
||||
}
|
||||
removeUnit(u: Unit) {
|
||||
this.unitGrid.removeUnit(u);
|
||||
this.planDrivenUnitIds.delete(u.id());
|
||||
if (u.hasTrainStation()) {
|
||||
this._railNetwork.removeStation(u);
|
||||
}
|
||||
|
||||
@@ -24,6 +24,13 @@ export interface GameUpdateViewData {
|
||||
* state (`uint16`) stored in a `uint32` lane.
|
||||
*/
|
||||
packedTileUpdates: Uint32Array;
|
||||
/**
|
||||
* Optional packed motion plan records.
|
||||
*
|
||||
* When present, this buffer is expected to be transferred worker -> main
|
||||
* (similar to `packedTileUpdates`) to avoid structured-clone copies.
|
||||
*/
|
||||
packedMotionPlans?: Uint32Array;
|
||||
playerNameViewData: Record<string, NameViewData>;
|
||||
tickExecutionDuration?: number;
|
||||
pendingTurns?: number;
|
||||
|
||||
@@ -34,6 +34,7 @@ import {
|
||||
PlayerUpdate,
|
||||
UnitUpdate,
|
||||
} from "./GameUpdates";
|
||||
import { MotionPlanRecord, unpackMotionPlans } from "./MotionPlans";
|
||||
import { TerrainMapData } from "./TerrainMapLoader";
|
||||
import { TerraNulliusImpl } from "./TerraNulliusImpl";
|
||||
import { UnitGrid, UnitPredicate } from "./UnitGrid";
|
||||
@@ -83,6 +84,17 @@ export class UnitView {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
applyDerivedPosition(pos: TileRef) {
|
||||
const prev = this.data.pos;
|
||||
this.lastPos.push(pos);
|
||||
this._wasUpdated = true;
|
||||
this.data = {
|
||||
...this.data,
|
||||
lastPos: prev,
|
||||
pos,
|
||||
};
|
||||
}
|
||||
|
||||
id(): number {
|
||||
return this.data.id;
|
||||
}
|
||||
@@ -582,6 +594,20 @@ export class PlayerView {
|
||||
}
|
||||
}
|
||||
|
||||
type TrainPlanState = {
|
||||
planId: number;
|
||||
startTick: number;
|
||||
speed: number;
|
||||
spacing: number;
|
||||
carUnitIds: Uint32Array;
|
||||
path: Uint32Array;
|
||||
cursor: number;
|
||||
usedTilesBuf: Uint32Array;
|
||||
usedHead: number;
|
||||
usedLen: number;
|
||||
lastAdvancedTick: Tick;
|
||||
};
|
||||
|
||||
export class GameView implements GameMap {
|
||||
private lastUpdate: GameUpdateViewData | null;
|
||||
private smallIDToID = new Map<number, PlayerID>();
|
||||
@@ -592,6 +618,17 @@ export class GameView implements GameMap {
|
||||
private _myPlayer: PlayerView | null = null;
|
||||
|
||||
private unitGrid: UnitGrid;
|
||||
private unitMotionPlans = new Map<
|
||||
number,
|
||||
{
|
||||
planId: number;
|
||||
startTick: number;
|
||||
ticksPerStep: number;
|
||||
path: Uint32Array;
|
||||
}
|
||||
>();
|
||||
private trainMotionPlans = new Map<number, TrainPlanState>();
|
||||
private trainUnitToEngine = new Map<number, number>();
|
||||
|
||||
private toDelete = new Set<number>();
|
||||
|
||||
@@ -637,6 +674,51 @@ export class GameView implements GameMap {
|
||||
return this.lastUpdate?.updates ?? null;
|
||||
}
|
||||
|
||||
public motionPlans(): ReadonlyMap<
|
||||
number,
|
||||
{
|
||||
planId: number;
|
||||
startTick: number;
|
||||
ticksPerStep: number;
|
||||
path: Uint32Array;
|
||||
}
|
||||
> {
|
||||
return this.unitMotionPlans;
|
||||
}
|
||||
|
||||
private motionPlannedUnitIdsCache: number[] = [];
|
||||
private motionPlannedUnitIdsDirty = true;
|
||||
|
||||
private markMotionPlannedUnitIdsDirty(): void {
|
||||
this.motionPlannedUnitIdsDirty = true;
|
||||
}
|
||||
|
||||
private rebuildMotionPlannedUnitIdsCacheIfDirty(): void {
|
||||
if (!this.motionPlannedUnitIdsDirty) {
|
||||
return;
|
||||
}
|
||||
this.motionPlannedUnitIdsDirty = false;
|
||||
|
||||
const out = this.motionPlannedUnitIdsCache;
|
||||
out.length = 0;
|
||||
|
||||
for (const unitId of this.unitMotionPlans.keys()) {
|
||||
out.push(unitId);
|
||||
}
|
||||
for (const [engineId, plan] of this.trainMotionPlans) {
|
||||
out.push(engineId);
|
||||
for (let i = 0; i < plan.carUnitIds.length; i++) {
|
||||
const id = plan.carUnitIds[i] >>> 0;
|
||||
if (id !== 0) out.push(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public motionPlannedUnitIds(): number[] {
|
||||
this.rebuildMotionPlannedUnitIdsCacheIfDirty();
|
||||
return this.motionPlannedUnitIdsCache;
|
||||
}
|
||||
|
||||
public isCatchingUp(): boolean {
|
||||
return (this.lastUpdate?.pendingTurns ?? 0) > 1;
|
||||
}
|
||||
@@ -656,6 +738,11 @@ export class GameView implements GameMap {
|
||||
this.updatedTiles.push(tile);
|
||||
}
|
||||
|
||||
if (gu.packedMotionPlans) {
|
||||
const records = unpackMotionPlans(gu.packedMotionPlans);
|
||||
this.applyMotionPlanRecords(records);
|
||||
}
|
||||
|
||||
if (gu.updates === null) {
|
||||
throw new Error("lastUpdate.updates not initialized");
|
||||
}
|
||||
@@ -704,8 +791,244 @@ export class GameView implements GameMap {
|
||||
if (!unit.isActive()) {
|
||||
// Wait until next tick to delete the unit.
|
||||
this.toDelete.add(unit.id());
|
||||
if (this.unitMotionPlans.delete(unit.id())) {
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
}
|
||||
this.clearTrainPlanForUnit(unit.id());
|
||||
}
|
||||
});
|
||||
|
||||
this.advanceMotionPlannedUnits(gu.tick);
|
||||
this.rebuildMotionPlannedUnitIdsCacheIfDirty();
|
||||
}
|
||||
|
||||
private advanceMotionPlannedUnits(currentTick: Tick): void {
|
||||
for (const [unitId, plan] of this.unitMotionPlans) {
|
||||
const unit = this._units.get(unitId);
|
||||
if (!unit || !unit.isActive()) {
|
||||
if (this.unitMotionPlans.delete(unitId)) {
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const oldTile = unit.tile();
|
||||
const dt = currentTick - plan.startTick;
|
||||
const stepIndex =
|
||||
dt <= 0 ? 0 : Math.floor(dt / Math.max(1, plan.ticksPerStep));
|
||||
const lastIndex = plan.path.length - 1;
|
||||
const idx = Math.max(0, Math.min(lastIndex, stepIndex));
|
||||
const newTile = plan.path[idx] as TileRef;
|
||||
|
||||
if (newTile !== oldTile) {
|
||||
unit.applyDerivedPosition(newTile);
|
||||
this.unitGrid.updateUnitCell(unit);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Once a plan is past its final step, `newTile` remains clamped to the last path tile.
|
||||
// Drop finished plans to avoid repeatedly marking static units as updated each tick.
|
||||
if (dt > 0 && stepIndex >= lastIndex) {
|
||||
if (this.unitMotionPlans.delete(unitId)) {
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.advanceTrainMotionPlannedUnits(currentTick);
|
||||
}
|
||||
|
||||
private clearTrainPlanForUnit(unitId: number): void {
|
||||
const engineId =
|
||||
this.trainUnitToEngine.get(unitId) ??
|
||||
(this.trainMotionPlans.has(unitId) ? unitId : null);
|
||||
if (engineId === null) {
|
||||
return;
|
||||
}
|
||||
const plan = this.trainMotionPlans.get(engineId);
|
||||
if (!plan) {
|
||||
this.trainUnitToEngine.delete(unitId);
|
||||
return;
|
||||
}
|
||||
if (this.trainMotionPlans.delete(engineId)) {
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
}
|
||||
this.trainUnitToEngine.delete(engineId);
|
||||
for (let i = 0; i < plan.carUnitIds.length; i++) {
|
||||
const id = plan.carUnitIds[i] >>> 0;
|
||||
if (id !== 0) this.trainUnitToEngine.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
private advanceTrainMotionPlannedUnits(currentTick: Tick): void {
|
||||
const staleEngineIds: number[] = [];
|
||||
for (const [engineId, plan] of this.trainMotionPlans) {
|
||||
const engine = this._units.get(engineId);
|
||||
if (!engine || !engine.isActive()) {
|
||||
staleEngineIds.push(engineId);
|
||||
continue;
|
||||
}
|
||||
|
||||
const steps = currentTick - plan.lastAdvancedTick;
|
||||
if (steps <= 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const path = plan.path;
|
||||
const lastIndex = path.length - 1;
|
||||
const cap = plan.usedTilesBuf.length;
|
||||
|
||||
const pushUsed = (tile: TileRef) => {
|
||||
if (cap === 0) return;
|
||||
if (plan.usedLen < cap) {
|
||||
const idx = (plan.usedHead + plan.usedLen) % cap;
|
||||
plan.usedTilesBuf[idx] = tile >>> 0;
|
||||
plan.usedLen++;
|
||||
} else {
|
||||
plan.usedTilesBuf[plan.usedHead] = tile >>> 0;
|
||||
plan.usedHead = (plan.usedHead + 1) % cap;
|
||||
plan.usedLen = cap;
|
||||
}
|
||||
};
|
||||
|
||||
const usedGet = (index: number): TileRef | null => {
|
||||
if (index < 0 || index >= plan.usedLen || cap === 0) return null;
|
||||
const idx = (plan.usedHead + index) % cap;
|
||||
return plan.usedTilesBuf[idx] as TileRef;
|
||||
};
|
||||
|
||||
let didMove = false;
|
||||
for (let step = 0; step < steps; step++) {
|
||||
const cursor = plan.cursor;
|
||||
if (cursor >= lastIndex) {
|
||||
break;
|
||||
}
|
||||
for (let i = 0; i < plan.speed && cursor + i < path.length; i++) {
|
||||
pushUsed(path[cursor + i] as TileRef);
|
||||
}
|
||||
|
||||
plan.cursor = Math.min(lastIndex, cursor + plan.speed);
|
||||
|
||||
for (let i = plan.carUnitIds.length - 1; i >= 0; --i) {
|
||||
const carId = plan.carUnitIds[i] >>> 0;
|
||||
if (carId === 0) continue;
|
||||
const car = this._units.get(carId);
|
||||
if (!car || !car.isActive()) {
|
||||
continue;
|
||||
}
|
||||
const carTileIndex = (i + 1) * plan.spacing + 2;
|
||||
const tile = usedGet(carTileIndex);
|
||||
if (tile !== null) {
|
||||
const oldTile = car.tile();
|
||||
if (tile !== oldTile) {
|
||||
car.applyDerivedPosition(tile);
|
||||
this.unitGrid.updateUnitCell(car);
|
||||
didMove = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const newEngineTile = path[plan.cursor] as TileRef;
|
||||
const oldEngineTile = engine.tile();
|
||||
if (newEngineTile !== oldEngineTile) {
|
||||
engine.applyDerivedPosition(newEngineTile);
|
||||
this.unitGrid.updateUnitCell(engine);
|
||||
didMove = true;
|
||||
}
|
||||
}
|
||||
|
||||
plan.lastAdvancedTick = currentTick;
|
||||
|
||||
// Preserve the final-step redraw (plan remains for the tick where motion ends),
|
||||
// then clear once the train has settled and no longer moves.
|
||||
// Note: trains are currently deleted at the end of TrainExecution, and the ensuing
|
||||
// `Unit` update (isActive=false) also clears any associated motion plan records.
|
||||
// This expiry is defensive to avoid keeping stale plans around if that behavior changes.
|
||||
if (!didMove && plan.cursor >= lastIndex) {
|
||||
staleEngineIds.push(engineId);
|
||||
}
|
||||
}
|
||||
|
||||
for (const engineId of staleEngineIds) {
|
||||
this.clearTrainPlanForUnit(engineId);
|
||||
}
|
||||
}
|
||||
|
||||
private applyMotionPlanRecords(records: readonly MotionPlanRecord[]): void {
|
||||
for (const record of records) {
|
||||
switch (record.kind) {
|
||||
case "grid": {
|
||||
if (record.ticksPerStep < 1 || record.path.length < 1) {
|
||||
break;
|
||||
}
|
||||
const existing = this.unitMotionPlans.get(record.unitId);
|
||||
if (existing && record.planId <= existing.planId) {
|
||||
break;
|
||||
}
|
||||
|
||||
const path =
|
||||
record.path instanceof Uint32Array
|
||||
? record.path
|
||||
: Uint32Array.from(record.path);
|
||||
|
||||
this.unitMotionPlans.set(record.unitId, {
|
||||
planId: record.planId,
|
||||
startTick: record.startTick,
|
||||
ticksPerStep: record.ticksPerStep,
|
||||
path,
|
||||
});
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
break;
|
||||
}
|
||||
case "train": {
|
||||
if (record.speed < 1 || record.path.length < 1) {
|
||||
break;
|
||||
}
|
||||
const existing = this.trainMotionPlans.get(record.engineUnitId);
|
||||
if (existing && record.planId <= existing.planId) {
|
||||
break;
|
||||
}
|
||||
if (existing) {
|
||||
this.clearTrainPlanForUnit(record.engineUnitId);
|
||||
}
|
||||
|
||||
const carUnitIds =
|
||||
record.carUnitIds instanceof Uint32Array
|
||||
? record.carUnitIds
|
||||
: Uint32Array.from(record.carUnitIds);
|
||||
const path =
|
||||
record.path instanceof Uint32Array
|
||||
? record.path
|
||||
: Uint32Array.from(record.path);
|
||||
|
||||
const usedCap = carUnitIds.length * record.spacing + 3;
|
||||
const usedTilesBuf = new Uint32Array(Math.max(0, usedCap));
|
||||
|
||||
this.trainMotionPlans.set(record.engineUnitId, {
|
||||
planId: record.planId,
|
||||
startTick: record.startTick,
|
||||
speed: record.speed,
|
||||
spacing: record.spacing,
|
||||
carUnitIds,
|
||||
path,
|
||||
cursor: 0,
|
||||
usedTilesBuf,
|
||||
usedHead: 0,
|
||||
usedLen: 0,
|
||||
lastAdvancedTick: record.startTick,
|
||||
});
|
||||
this.markMotionPlannedUnitIdsDirty();
|
||||
|
||||
this.trainUnitToEngine.set(record.engineUnitId, record.engineUnitId);
|
||||
for (let i = 0; i < carUnitIds.length; i++) {
|
||||
const carId = carUnitIds[i] >>> 0;
|
||||
if (carId !== 0)
|
||||
this.trainUnitToEngine.set(carId, record.engineUnitId);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
recentlyUpdatedTiles(): TileRef[] {
|
||||
|
||||
@@ -0,0 +1,212 @@
|
||||
import { TileRef } from "./GameMap";
|
||||
|
||||
export enum PackedMotionPlanKind {
|
||||
GridPathSet = 1,
|
||||
TrainRailPathSet = 2,
|
||||
}
|
||||
|
||||
export interface GridPathPlan {
|
||||
kind: "grid";
|
||||
unitId: number;
|
||||
planId: number;
|
||||
startTick: number;
|
||||
ticksPerStep: number;
|
||||
/**
|
||||
* TileRef path where `path[0]` is the unit tile at `startTick`.
|
||||
*/
|
||||
path: readonly TileRef[] | Uint32Array;
|
||||
}
|
||||
|
||||
export interface TrainRailPathPlan {
|
||||
kind: "train";
|
||||
engineUnitId: number;
|
||||
/**
|
||||
* TrainExecution `cars[]` order (tail engine + carriages).
|
||||
*/
|
||||
carUnitIds: readonly number[] | Uint32Array;
|
||||
planId: number;
|
||||
startTick: number;
|
||||
speed: number;
|
||||
spacing: number;
|
||||
/**
|
||||
* Concatenated rail tile path across all segments, without de-duplicating at stations.
|
||||
*/
|
||||
path: readonly TileRef[] | Uint32Array;
|
||||
}
|
||||
|
||||
export type MotionPlanRecord = GridPathPlan | TrainRailPathPlan;
|
||||
|
||||
export function packMotionPlans(
|
||||
records: readonly MotionPlanRecord[],
|
||||
): Uint32Array {
|
||||
let totalWords = 1;
|
||||
for (const record of records) {
|
||||
switch (record.kind) {
|
||||
case "grid": {
|
||||
const pathLen = (record.path.length >>> 0) as number;
|
||||
totalWords += 2 + 5 + pathLen;
|
||||
break;
|
||||
}
|
||||
case "train": {
|
||||
const carCount = (record.carUnitIds.length >>> 0) as number;
|
||||
const pathLen = (record.path.length >>> 0) as number;
|
||||
totalWords += 2 + 7 + carCount + pathLen;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const out = new Uint32Array(totalWords);
|
||||
out[0] = records.length >>> 0;
|
||||
|
||||
let offset = 1;
|
||||
for (const record of records) {
|
||||
switch (record.kind) {
|
||||
case "grid": {
|
||||
const path = record.path as ArrayLike<number>;
|
||||
const pathLen = path.length >>> 0;
|
||||
const wordCount = 2 + 5 + pathLen;
|
||||
|
||||
out[offset++] = PackedMotionPlanKind.GridPathSet;
|
||||
out[offset++] = wordCount >>> 0;
|
||||
out[offset++] = record.unitId >>> 0;
|
||||
out[offset++] = record.planId >>> 0;
|
||||
out[offset++] = record.startTick >>> 0;
|
||||
out[offset++] = record.ticksPerStep >>> 0;
|
||||
out[offset++] = pathLen >>> 0;
|
||||
|
||||
for (let i = 0; i < pathLen; i++) {
|
||||
out[offset++] = path[i] >>> 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "train": {
|
||||
const carUnitIds = record.carUnitIds as ArrayLike<number>;
|
||||
const carCount = carUnitIds.length >>> 0;
|
||||
|
||||
const path = record.path as ArrayLike<number>;
|
||||
const pathLen = path.length >>> 0;
|
||||
|
||||
const wordCount = 2 + 7 + carCount + pathLen;
|
||||
out[offset++] = PackedMotionPlanKind.TrainRailPathSet;
|
||||
out[offset++] = wordCount >>> 0;
|
||||
out[offset++] = record.engineUnitId >>> 0;
|
||||
out[offset++] = record.planId >>> 0;
|
||||
out[offset++] = record.startTick >>> 0;
|
||||
out[offset++] = record.speed >>> 0;
|
||||
out[offset++] = record.spacing >>> 0;
|
||||
out[offset++] = carCount >>> 0;
|
||||
out[offset++] = pathLen >>> 0;
|
||||
|
||||
for (let i = 0; i < carCount; i++) {
|
||||
out[offset++] = carUnitIds[i] >>> 0;
|
||||
}
|
||||
for (let i = 0; i < pathLen; i++) {
|
||||
out[offset++] = path[i] >>> 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (offset !== out.length) {
|
||||
throw new Error(
|
||||
`packMotionPlans size mismatch: wrote ${offset}, expected ${out.length}`,
|
||||
);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function unpackMotionPlans(packed: Uint32Array): MotionPlanRecord[] {
|
||||
if (packed.length < 1) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const recordCount = packed[0] >>> 0;
|
||||
const records: MotionPlanRecord[] = [];
|
||||
let offset = 1;
|
||||
|
||||
for (let i = 0; i < recordCount && offset + 1 < packed.length; i++) {
|
||||
const kind = packed[offset] >>> 0;
|
||||
const wordCount = packed[offset + 1] >>> 0;
|
||||
|
||||
if (wordCount < 2 || offset + wordCount > packed.length) {
|
||||
break;
|
||||
}
|
||||
|
||||
switch (kind) {
|
||||
case PackedMotionPlanKind.GridPathSet: {
|
||||
if (wordCount < 2 + 5) {
|
||||
break;
|
||||
}
|
||||
const unitId = packed[offset + 2] >>> 0;
|
||||
const planId = packed[offset + 3] >>> 0;
|
||||
const startTick = packed[offset + 4] >>> 0;
|
||||
const ticksPerStep = packed[offset + 5] >>> 0;
|
||||
const pathLen = packed[offset + 6] >>> 0;
|
||||
|
||||
const expectedWordCount = 2 + 5 + pathLen;
|
||||
if (expectedWordCount !== wordCount) {
|
||||
break;
|
||||
}
|
||||
|
||||
const pathStart = offset + 7;
|
||||
const pathEnd = pathStart + pathLen;
|
||||
const path = packed.slice(pathStart, pathEnd);
|
||||
|
||||
records.push({
|
||||
kind: "grid",
|
||||
unitId,
|
||||
planId,
|
||||
startTick,
|
||||
ticksPerStep,
|
||||
path,
|
||||
});
|
||||
break;
|
||||
}
|
||||
case PackedMotionPlanKind.TrainRailPathSet: {
|
||||
if (wordCount < 2 + 7) {
|
||||
break;
|
||||
}
|
||||
const engineUnitId = packed[offset + 2] >>> 0;
|
||||
const planId = packed[offset + 3] >>> 0;
|
||||
const startTick = packed[offset + 4] >>> 0;
|
||||
const speed = packed[offset + 5] >>> 0;
|
||||
const spacing = packed[offset + 6] >>> 0;
|
||||
const carCount = packed[offset + 7] >>> 0;
|
||||
const pathLen = packed[offset + 8] >>> 0;
|
||||
|
||||
const expectedWordCount = 2 + 7 + carCount + pathLen;
|
||||
if (expectedWordCount !== wordCount) {
|
||||
break;
|
||||
}
|
||||
|
||||
const carStart = offset + 9;
|
||||
const carEnd = carStart + carCount;
|
||||
const pathStart = carEnd;
|
||||
const pathEnd = pathStart + pathLen;
|
||||
const carUnitIds = packed.slice(carStart, carEnd);
|
||||
const path = packed.slice(pathStart, pathEnd);
|
||||
|
||||
records.push({
|
||||
kind: "train",
|
||||
engineUnitId,
|
||||
carUnitIds,
|
||||
planId,
|
||||
startTick,
|
||||
speed,
|
||||
spacing,
|
||||
path,
|
||||
});
|
||||
break;
|
||||
}
|
||||
default:
|
||||
// Unknown kind: skip.
|
||||
break;
|
||||
}
|
||||
|
||||
offset += wordCount;
|
||||
}
|
||||
|
||||
return records;
|
||||
}
|
||||
@@ -159,8 +159,7 @@ export class UnitImpl implements Unit {
|
||||
}
|
||||
this._lastTile = this._tile;
|
||||
this._tile = tile;
|
||||
this.mg.updateUnitTile(this);
|
||||
this.mg.addUpdate(this.toUpdate());
|
||||
this.mg.onUnitMoved(this);
|
||||
}
|
||||
|
||||
setTroops(troops: number): void {
|
||||
@@ -336,7 +335,10 @@ export class UnitImpl implements Unit {
|
||||
if (this.type() !== UnitType.TransportShip) {
|
||||
throw new Error(`Cannot retreat ${this.type()}`);
|
||||
}
|
||||
this._retreating = true;
|
||||
if (!this._retreating) {
|
||||
this._retreating = true;
|
||||
this.mg.addUpdate(this.toUpdate());
|
||||
}
|
||||
}
|
||||
|
||||
isUnderConstruction(): boolean {
|
||||
|
||||
@@ -4,14 +4,12 @@
|
||||
*/
|
||||
|
||||
export enum PathStatus {
|
||||
NEXT,
|
||||
PENDING,
|
||||
COMPLETE,
|
||||
NOT_FOUND,
|
||||
NEXT = 0,
|
||||
COMPLETE = 2,
|
||||
NOT_FOUND = 3,
|
||||
}
|
||||
|
||||
export type PathResult<T> =
|
||||
| { status: PathStatus.PENDING }
|
||||
| { status: PathStatus.NEXT; node: T }
|
||||
| { status: PathStatus.COMPLETE; node: T }
|
||||
| { status: PathStatus.NOT_FOUND };
|
||||
|
||||
@@ -33,7 +33,13 @@ function sendMessage(message: WorkerMessage) {
|
||||
if (message.type === "game_update") {
|
||||
// Transfer the packed tile updates buffer to avoid structured-clone copies and
|
||||
// reduce worker-side memory churn during long runs / catch-up.
|
||||
ctx.postMessage(message, [message.gameUpdate.packedTileUpdates.buffer]);
|
||||
const transfers: Transferable[] = [
|
||||
message.gameUpdate.packedTileUpdates.buffer,
|
||||
];
|
||||
if (message.gameUpdate.packedMotionPlans) {
|
||||
transfers.push(message.gameUpdate.packedMotionPlans.buffer);
|
||||
}
|
||||
ctx.postMessage(message, transfers);
|
||||
return;
|
||||
}
|
||||
ctx.postMessage(message);
|
||||
|
||||
@@ -74,9 +74,11 @@ describe("TradeShipExecution", () => {
|
||||
tradeShip = {
|
||||
isActive: vi.fn(() => true),
|
||||
owner: vi.fn(() => origOwner),
|
||||
id: vi.fn(() => 123),
|
||||
move: vi.fn(),
|
||||
setTargetUnit: vi.fn(),
|
||||
setSafeFromPirates: vi.fn(),
|
||||
touch: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
tile: vi.fn(() => 2001),
|
||||
} as any;
|
||||
@@ -85,6 +87,7 @@ describe("TradeShipExecution", () => {
|
||||
tradeShipExecution.init(game, 0);
|
||||
tradeShipExecution["pathFinder"] = {
|
||||
next: vi.fn(() => ({ status: PathStatus.NEXT, node: 2001 })),
|
||||
findPath: vi.fn((from: number) => [from]),
|
||||
} as any;
|
||||
tradeShipExecution["tradeShip"] = tradeShip;
|
||||
});
|
||||
@@ -116,6 +119,7 @@ describe("TradeShipExecution", () => {
|
||||
it("should complete trade and award gold", () => {
|
||||
tradeShipExecution["pathFinder"] = {
|
||||
next: vi.fn(() => ({ status: PathStatus.COMPLETE, node: 2001 })),
|
||||
findPath: vi.fn((from: number) => [from]),
|
||||
} as any;
|
||||
tradeShipExecution.tick(1);
|
||||
expect(tradeShip.delete).toHaveBeenCalledWith(false);
|
||||
|
||||
Reference in New Issue
Block a user