FS.GG.Game.Core 0.13.0

FS.GG.Game.Core

BCL-only deterministic simulation core for FS.GG.Game — the platform's bottom layer. Depends on nothing but FSharp.Core and reaches up to no other FS-GG package.

The sim vocabulary

The shared types — Point, Rect, Circle, ConvexPolygon, and the detection values Contact (a single-axis penetration manifold), Manifold (its multi-point form) and RayHit (a segment-cast result) — live directly in the FS.GG.Game.Core namespace, so open FS.GG.Game.Core is all a caller needs. The tile index Cell is namespace-level too. Everything below is a [<RequireQualifiedAccess>] module, called as Grids.cellAt, Rng.nextInt, and so on.

• Rng — SplitMix64 seeded RNG (ofSeed/nextInt/nextFloat/nextBool/split), byte-identical across runs.
• FixedStep — fixed-timestep accumulator drain (drain/drainWith). No wall-clock read, so a scripted frame time replays exactly.
• Loop — the fixed-step double-buffered loop built on FixedStep.drain (advance/alpha): the world as of the last completed step (Current), the one before it (Previous), and the carried sub-step time (Accumulator). Renderers interpolate Previous → Current by alpha, so motion is smooth at any frame rate while the sim only ever advances by whole fixed steps. The default for any continuously-moving simulation.
• InputCommand — the abstract, device-free vocabulary of input intents (Command.MoveNorth/…/Fire/Pause) as pure data. The policy half of the input split: Game.Core owns which commands exist; the render/input layer owns how a device makes one and never learns a game action.

Collision — detection, then response

• Geometry — the detection surface: overlap and containment for AABB, circle, and convex polygon (intersects/contains/aabbContact/circleContact/polygonContact/obbPolygon), swept tests (sweptIntersects), and segment casts (segmentAabbHit/segmentCircleHit/segmentPolygonHit/…). It returns manifests as values and never resolves them.
• Resolution — the response layer that consumes a detection Contact and produces transforms (pushOut/slide/push; knockback is a deprecated shim over push). Deliberately separate from detection; it never re-detects.
• SpatialGrid — uniform spatial partitioning for the broad phase (build/query/queryRadius).
• Physics — an opt-in mini rigid-body engine: a world of bodies, a broad phase, a narrow phase, and a semi-implicit Euler step with a warm-started sequential-impulse contact solver over bodies that sleep once they settle. Mass is derived from a shape's area, not given. Arcade Resolution stays the first-class default; neither module knows the other.

The grid

• Pathfinding — grid A*/BFS over walkable cells (astar/bfs), the turn-based-tactics move range (reachable/pathTo), and the many-to-one AI substrate distanceField/flowField/reachableWithin. Pick by the question: astar minimises steps and takes no cost, so it is the wrong tool for a unit spending a movement budget over non-uniform terrain — reachable costs the highlight and the path in one search, and pathTo walks it. reachableWithin is that search with the predecessors dropped: the costed set, for scoring cells or a threat overlay, not for pathing to one.
• Grids — the parts of a square grid: Edge, Vertex, GridSpec, the six adjacency conversions, and the pixel↔cell map (cellRect/cellCenter/edgeSegment/cellAt). Names the boundary between two tiles, which is where a wall lives.

Sight

• Los — point-to-point grid line of sight over a caller-supplied opacity predicate (line/supercover/trace/lineOfSight).
• Fov — grid field of view by symmetric shadowcasting (fov). Opacity is not walkability: this module consults opacity only.
• Visibility — the continuous-space sibling: exact point-to-point sight against arbitrary occluder segments, and the full angular-sweep visibility polygon (raySegment/isVisible/polygon). It can answer occlusion between two moving bodies, which a tile walk cannot.

Pathfinding, Los, and Fov all take terrain as a pure Cell -> bool predicate — the framework holds no map, so one terrain plugs into all three.

Combat and decision

• Ballistics — projectile weapons over continuous space: a swept advance that cannot tunnel (a fast round is a segment, never a point), a lead / intercept solve, and a splash query with a caller-chosen falloff. Lifetimes are counted in whole ticks, not float seconds, so a replay cannot drift.
• Effects — the mitigation layer: what one incoming hit becomes at the target. It separates the damage Source (a Declared attack — the only thing cover and armor reduce — vs Collision/Environmental/Periodic) from the damage kind, which stays generic in 'K (Game.Core never learns what Frost is).
• Ai — the decision layer's vocabulary: a comparable AgentId that fixes iteration order (never hash order, which would diverge a replay), and the fog-of-war TeamView — an abstract value of what a team knows, whose sightings decay from spotted into ghosts. Its LOS is a caller-supplied oracle, so perception policy stays with the game.

Where it came from

Three provenances:

• Extracted from FS.GG.UI.Canvas / FS.GG.UI.Scene and reimplemented BCL-only, per ADR-0022 — the shared types, Geometry, Rng, FixedStep, Pathfinding, SpatialGrid.
• Promoted from the frozen starter fragments in FS.GG.Rendering (template/fragments/*), which every game that wanted them previously had to copy and diverge from — Los, Visibility, Grids.
• Authored here through the SDD lifecycle, because the org had nothing to promote — Fov, Resolution, Loop, InputCommand, Ballistics, Effects, Ai, and Physics.

Guarantees

Headlessly testable — zero Skia, zero Scene. Purity, totality (degenerate and non-finite input degrades to a documented value rather than throwing), and determinism (integer logic / float presentation) are the contract each module's .fsi states and its tests hold it to — so identical input replays byte-identically across runs, and a module is safe to call from a replayed simulation step. Cross-platform byte-identity is unconditional for the integer / grid layer; the float-heavy modules scope it (Visibility to |coord| <= 1e6) or defer full lockstep to a later fixed-point ADR (Physics.checksum), so trust the per-module .fsi, not one blanket claim.

Fable compatibility

The NuGet package carries a bounded Fable source view containing the canonical Primitives, Pathfinding, Edges, and Los source files used by the .NET assembly; it does not contain copied algorithms. The package's fable-compatibility/ directory records the versioned profile, authored input vectors, canonical binary oracle, fixture schema, and pinned toolchain.

Cell ordering, Edges.edgeBetween, Los.lineOfSightBy, and Pathfinding.astar are LockstepExact under profile fs-gg-game-core-fable-lockstep-v1. The packed .NET assembly and package-derived Fable source must emit byte-identical records for the shared boundary corpus. Floating value types are Portable, not exact; implementation surfaces excluded from the source view are DotNetOnly. Every other operation remains unclassified even when its source file is present.

To project sim state onto drawables, add FS.GG.Game.Render.

House style: .fsi is the sole public surface; net10.0; -preview channel. See FS-GG/FS.GG.Game and ADR-0022.