2 Commits

Author	SHA1	Message	Date
Evan Pelle	a7f992e9b0	refactor: convert to npm-workspaces monorepo (engine/core-public/shared/client/server) ... Restructure the single src/ tree into an npm-workspaces monorepo under packages/, rename core -> engine, extract a types-only core-public layer, and break the pre-existing engine -> client dependency cycle. Structure (packages/): core-public public API/wire schemas + shared enums (clean leaf) shared framework-agnostic helpers (clean leaf) engine deterministic simulation (was src/core) client rendering/UI (was src/client) server coordination (was src/server) Dependency DAG: engine -> {core-public, shared}; client -> {core-public, shared, engine}; server -> {core-public, engine}. - npm workspaces: root package.json workspaces + per-package package.json; tsconfig.base.json holds shared options + path aliases (core-public/* shared/* engine/* client/* server/*) resolved uniformly by tsc, Vite (resolve.tsconfigPaths), Vitest, and tsx. Lockfile regenerated. - core-public: moved Schemas/ApiSchemas/CosmeticSchemas/StatsSchemas/ ClanApiSchemas/WorkerSchemas/Base64/PatternDecoder; extracted the enums (GameTypes), GameEvent type, emoji table, and GraphicsOverrides schema. Engine re-exports the moved enums/types so existing imports keep working. - Broke engine -> client cycle: - renderNumber/renderTroops -> shared/format - NameBoxCalculator moved into engine - username validation returns translation key + params; client translates - applyStateUpdate moved to client (operates on the render-only PlayerState) - Config/UnitGrid/execution-Util/GameImpl now use structural read interfaces (engine/game/ReadViews: PlayerLike/UnitLike/GameLike) instead of importing client view classes; client imports view classes from a new client/view barrel; deleted the engine/game/GameView re-export shim. - Build/deploy updated: vite.config, index.html, eslint, Dockerfile (copies packages/ + tsconfig.base.json before npm ci), .vscode, tests. Verified: tsc --noEmit clean; 1364 + 65 tests pass; production vite build succeeds; engine has zero client/server imports; core-public and shared are dependency leaves. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-10 16:51:03 +00:00
Arkadiusz Sygulski	0e3ced3bfa	Pathfinding Refactor pt. 2 (#2866) ... ## Playtest https://pf-pt-2.openfront.dev/ ## Pathfinding Refactor pt. 2 <img width="1536" height="1024" alt="image" src="https://github.com/user-attachments/assets/9477958e-54b7-4c83-b317-ba789e809e9e" /> This is a follow-up to a previous PR introducing pathfinding changes. This time, it introduces a complete refactor of `pathfinding` directory and breakdown into composable pieces. ### Unified PathFinder interface `PathFinder<T>` and `SteppingPathFinder<T>` are introduced to unify **all** pathfinding across the application. First one exposes complete path, while stepping variant allows the callee to iterate over the path by calling `.next`. All pathfinders share this one common interface, which makes them easy to use in any scenario - `PathFinding.Water(game).search(from, to)`. `SteppingPathFinder<T>` extends `PathFinder<T>` with an ability to iterate over the path. It handles caching, storing current index and invalidation. This allows the units to not care about the inner workings of the pathfinder and just call `pf.next(current, target)` and receive instructions on what to do next. ### Common entry point All pathfinders are now exposed from common `PathFinding` entrypoint: - `PathFinding.Water` - `PathFinding.Rail` - `PathFinding.Stations` - `PathFinding.Rail` Additional entry point is introduced for pathfinders which need to work both in the worker, but also on the frontend, which lacks `Game` interface. Currently only `UniversalPathFinding.Parabola` is available. ### Spatial Query New module has been introduced close to `pathfinding` - `SpatialQuery`. It aims to resolve any questions game may have about finding tiles meeting criteria. Currently `SpatialQuery.closestShore(player, target)` and `SpatialQuery.closestShoreByWater(player, target)` are available - they help answering questions about naval invasion: "What is the best landing location from user's click?" and "Which our tile should be used to launch the transport ship?". Under the hood they use very similar mechanics to pathfinding, so it felt right to put them close by. ### Modular architecture Pathfinders now support transformers: `MiniMapTransformer`, `ShoreCoercingTransformer`, `ComponentCheckTransformer`, `SmoothingTransformer`. Transformers functions like a middleware in the pathfinding chain. They wrap around the pathfinder and provide additional functionality. This allows the pathfinder to focus on actually finding the path instead of doing unrelated things. Example chain for simple (A*) water pathfinding: ```ts static WaterSimple(game: Game): SteppingPathFinder<TileRef> { const miniMap = game.miniMap(); const pf = new AStarWater(miniMap); return PathFinderBuilder.create(pf) .wrap((pf) => new ShoreCoercingTransformer(pf, miniMap)) .wrap((pf) => new MiniMapTransformer(pf, game.map(), miniMap)) .buildWithStepper(tileStepperConfig(game)); } ``` The Pathfinder - here `AStarWater` - does not care about the conversion between minimap and main map tiles. It also does not care if the source or destination is a land tile. The transformers take care of that. The pathfinder gets a set of valid coordinates and produces the path - that's it. Modular approach makes working on a particular set of utilities much easier - for example map upscaling is handled consistently across all pathfinders. Additionally, the pathfinders are not tied to the particular map resolution used. Pass them a different map and they will work the same. ### Algorithms Algorithms used are neatly organized inside `src/core/pathfinding/algorithms`. They are prefixed with the algorithm name and suffixed with the use case. File without suffix exposes generic version ready to traverse any graph with adapters. Specialized versions either use an adapter or inline logic when performance is critical - using adapters leads to 20-30% performance loss. The directory includes `A*` and `BFS` but also other useful utils, such as `AbstractGraph` used to generate... an abstract graph on top of the tile map and `ConnectedComponents` helping to identify whether two tiles are connected by a path without actually computing the path. ### Playground The playground have been updated with new algorithms, including tweaked very greedy `A*`. <img width="2175" height="1424" alt="image" src="https://github.com/user-attachments/assets/1f833651-0024-4299-bf86-882f5368358c" /> ### Tests Yeah, there are some, a little too many if I say so myself. But there are no useless tests. I had to ensure refactored code works somehow reliably. This PR comes with trust me bro guarantee, but I would appreciate someone confirming **naval invasions, nukes (esp. MIRV) and warships**. ### Discord `moleole` GL & HF	2026-01-11 20:11:14 -08:00