mirror of
https://github.com/openfrontio/OpenFrontIO.git
synced 2026-06-27 12:34:17 +00:00
scamiv
33810e41c5
## Description:
This PR optimizes how the rail network looks up railroads connecting two
stations by introducing an O(1) neighbor→railroad map on `TrainStation`.
It also updates `getOrientedRailroad` and railroad deletion to use this
new API, avoiding repeated linear scans over all railroads attached to a
station.
### What changed
- **TrainStation neighbor→railroad index**
- Added `railroadByNeighbor: Map<TrainStation, Railroad>` to
`TrainStation` for quick edge lookup.
- Kept `railroads: Set<Railroad>` for iteration and existing APIs.
- Updated lifecycle methods to keep both data structures in sync:
- `addRailroad(railRoad: Railroad)` now:
- Adds to `railroads`.
- Computes the neighbor station (`railRoad.from === this ? railRoad.to :
railRoad.from`).
- Stores the mapping in `railroadByNeighbor`.
- `removeRailroad(railRoad: Railroad)` now:
- Removes from `railroads`.
- Removes the corresponding entry from `railroadByNeighbor`.
- `clearRailroads()` now clears both `railroads` and
`railroadByNeighbor`.
- Added `getRailroadTo(station: TrainStation): Railroad | null` to
retrieve the connecting railroad in O(1).
- **Use the new API in `TrainStation` and `Railroad`**
- `TrainStation.removeNeighboringRails(station)` now calls
`removeRailroad(toRemove)` instead of manually deleting from the set,
ensuring the map stays in sync.
- `Railroad.delete(game)` now calls `from.removeRailroad(this)` and
`to.removeRailroad(this)` instead of mutating the sets directly.
- **Refactor `getOrientedRailroad` to use O(1) lookup**
- Replaced a linear scan over `from.getRailroads()` with a direct
lookup:
```ts
export function getOrientedRailroad(
from: TrainStation,
to: TrainStation,
): OrientedRailroad | null {
const railroad = from.getRailroadTo(to);
if (!railroad) return null;
// If tiles are stored from -> to, we go forward when railroad.to === to
const forward = railroad.to === to;
return new OrientedRailroad(railroad, forward);
}
```
- Behavior is preserved:
- `getRailroadTo` returns the same `Railroad` instance that was
previously found by scanning `getRailroads()`.
- Direction (`forward` vs reversed) is still derived from the
`Railroad.from` / `.to` fields in the same way as before.
### Motivation
- `getOrientedRailroad` and upcoming logic both need to resolve “the
railroad between station A and station B” frequently.
- The old pattern (`for (const railroad of from.getRailroads()) { ...
}`) was:
- O(degree) per lookup,
- Repeated in multiple places,
- Harder to maintain as more features (like fare-based costs) touch this
code.
- Centralizing edge lookup in a dedicated `railroadByNeighbor` map makes
this:
- **O(1)** per lookup,
- Less error-prone (one source of truth),
- Easier to reuse from new systems (e.g. train pathfinding, fare-aware
logic).
### Impact / Risk
- **Public behavior:** No functional change in how railroads are
created, deleted, or oriented; only the lookup mechanism changed.
- **Internal invariants:** Correctness relies on:
- All railroad creations using `addRailroad` on both endpoints (already
true via `RailNetworkImpl.connect`).
- All removals (`Railroad.delete`,
`TrainStation.removeNeighboringRails`, `disconnectFromNetwork`) using
`removeRailroad` / `clearRailroads`, which this PR updates.
- **Tests:** Existing `TrainStation` tests still pass; they exercise
`addRailroad`, `removeNeighboringRails`, and `getRailroads()`, which
continue to behave the same from the outside.
## 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:
DISCORD_USERNAME
65 lines
1.5 KiB
TypeScript
65 lines
1.5 KiB
TypeScript
import { Game } from "./Game";
|
|
import { TileRef } from "./GameMap";
|
|
import { GameUpdateType, RailTile, RailType } from "./GameUpdates";
|
|
import { TrainStation } from "./TrainStation";
|
|
|
|
export class Railroad {
|
|
constructor(
|
|
public from: TrainStation,
|
|
public to: TrainStation,
|
|
public tiles: TileRef[],
|
|
) {}
|
|
|
|
delete(game: Game) {
|
|
const railTiles: RailTile[] = this.tiles.map((tile) => ({
|
|
tile,
|
|
railType: RailType.VERTICAL,
|
|
}));
|
|
game.addUpdate({
|
|
type: GameUpdateType.RailroadEvent,
|
|
isActive: false,
|
|
railTiles,
|
|
});
|
|
this.from.removeRailroad(this);
|
|
this.to.removeRailroad(this);
|
|
}
|
|
}
|
|
|
|
export function getOrientedRailroad(
|
|
from: TrainStation,
|
|
to: TrainStation,
|
|
): OrientedRailroad | null {
|
|
const railroad = from.getRailroadTo(to);
|
|
if (!railroad) return null;
|
|
// If tiles are stored from -> to, we go forward when railroad.to === to
|
|
const forward = railroad.to === to;
|
|
return new OrientedRailroad(railroad, forward);
|
|
}
|
|
|
|
/**
|
|
* Wrap a railroad with a direction so it always starts at tiles[0]
|
|
*/
|
|
export class OrientedRailroad {
|
|
private tiles: TileRef[] = [];
|
|
constructor(
|
|
private railroad: Railroad,
|
|
private forward: boolean,
|
|
) {
|
|
this.tiles = this.forward
|
|
? this.railroad.tiles
|
|
: [...this.railroad.tiles].reverse();
|
|
}
|
|
|
|
getTiles(): TileRef[] {
|
|
return this.tiles;
|
|
}
|
|
|
|
getStart(): TrainStation {
|
|
return this.forward ? this.railroad.from : this.railroad.to;
|
|
}
|
|
|
|
getEnd(): TrainStation {
|
|
return this.forward ? this.railroad.to : this.railroad.from;
|
|
}
|
|
}
|