Game Math And Simulation

Game Math and Simulation

Turn mathematical intent into named coordinate spaces, explicit units, stable numerical methods, deterministic oracles, and player-visible behaviour that survives variable frame time.

Prerequisites

Load the approved mechanic or rendering requirement, gameplay-systems-architecture, and the selected engine skill before choosing engine-specific types or APIs.

Use When

• Specifying movement, aiming, cameras, animation blending, steering, trajectories, collision, procedural placement, spatial queries, simulation, or shader mathematics.
• Debugging jitter, drift, tunnelling, gimbal-like rotation defects, unstable springs, frame-rate dependence, or incorrect coordinate conversions.
• Writing deterministic mathematical test oracles for gameplay, tools, or rendering.

Do Not Use When

• The task is system ownership, persistence, or event architecture without a mathematical defect; use gameplay-systems-architecture.
• The task is render-pipeline, material, or GPU design; use real-time-game-graphics and return here for the mathematical contract.
• A built-in engine primitive already satisfies the requirement and profiling/tests show no gap; do not replace it with bespoke mathematics.

Inputs

Workflow

1. State the player-visible behaviour before selecting a formula.
2. Name every coordinate space, handedness, axis convention, unit, time source, angle unit, range and precision assumption.
3. Choose the smallest mathematical model that represents the behaviour; prefer engine-tested primitives when their contract fits.
4. Separate simulation state from presentation smoothing. Use fixed-step simulation where rule consistency requires it and render interpolation where visual continuity requires it.
5. Define boundary conditions, tolerances, degenerate inputs, clamping, normalisation, random seeds and recovery from non-finite values.
6. Work representative examples by hand, then encode property, boundary, invariant and frame-rate-independence tests.
7. Instrument the result with debug vectors, paths, bounds, state graphs or numeric traces; profile worst-case queries on target devices.

Quality Standards

• Treat local, world, view, clip, screen, UV and tangent spaces as different types even if the engine represents them with the same structure.
• Keep units explicit. Convert at boundaries; do not scatter scale factors through gameplay code.
• Use dot products for alignment/projection questions, cross products for perpendicular/orientation questions, and quaternions for composed 3D orientation without exposing raw components to designers.
• Compare floating-point results with requirement-derived tolerances, never blanket exact equality or an unexplained epsilon.
• Preserve determinism only where the product needs replay, save reconstruction, lockstep, seeded tests, or auditability; record platform limits.

Decision Rules

Capability Contract

Read and search access to the requirement and implementation are required. Execute tests and visual/debug captures when available. Editing follows the parent implementation scope; without execution, return the model and unverified test vectors rather than claiming correctness.

Degraded Mode

If the engine version, scale, timestep, or coordinate convention is unknown, stop formula-level implementation. Return the missing contract fields, provisional equations, and the exact experiments required to resolve them.

Anti-Patterns

• Mixing local and world vectors. Fix: name conversion boundaries and assert the expected space.
• Multiplying movement by both fixed and render delta time. Fix: assign one time domain to each state update.
• Euler-angle accumulation for arbitrary 3D orientation. Fix: compose rotations with engine quaternion operations and test wrap boundaries.
• Normalising a zero-length vector. Fix: define the zero-input behaviour before the operation.
• Magic epsilon everywhere. Fix: derive tolerances from game scale, solver precision and the observable acceptance condition.
• Random calls from shared global state. Fix: give each deterministic system an owned, serialisable random stream.
• Complex custom collision before profiling built-in queries. Fix: prove the engine primitive is insufficient first.

Outputs

References

• Spatial mathematics and coordinate contracts
• Numerical simulation and deterministic tests

Evidence Produced

Read Next

Use real-time-game-graphics for shader/rendering integration, the selected engine skill for implementation, and game-testing-polish for balance and player-facing verification.