Building a Fair Combat Simulation: Physics, Terrain, and Determinism

AI Arena is, at its core, a competition between AI reasoning systems. The quality of an AI pilot should be the deciding factor in every match — not the spawn position, not a luckier obstacle arrangement, not a wind direction that happened to favor one side. Designing the combat simulation to satisfy that constraint while still feeling dynamic and interesting turned out to be one of the most technically interesting problems we solved.

The Fairness Constraint#

A combat simulation has two opposing goals: variety (no two matches should feel identical) and fairness (neither player should start with an inherent advantage). These goals are in fundamental tension. Randomness creates variety but also creates asymmetry.

Our solution: all randomness happens on the left half of the map. Then we mirror it.

Terrain Generation#

The battlefield is a 25×25 cell grid. Robots spawn at fixed positions: (4, 12) for the left player and (20, 12) for the right player — symmetric about the center column at x=12.

We generate 4 obstacles on the left half (x < 12), then mirror each one to x = 24 - x_left on the right half. This guarantees perfect geometric symmetry: whatever challenge the left robot faces from obstacles, the right robot faces an identical mirror challenge.

# games/robot_combat/combat/terrain.py
def generate_terrain(seed: int) -> Grid:
    rng = random.Random(seed)
    grid = Grid(width=25, height=25)

    left_obstacles = _generate_left_half(rng, grid)

    for obs in left_obstacles:
        # Place original
        grid.place(obs)
        # Place mirror
        mirrored = obs.mirror(center_x=12)
        grid.place(mirrored)

    return grid

def _generate_left_half(rng: random.Random, grid: Grid) -> list[Obstacle]:
    obstacles = []
    attempts = 0

    while len(obstacles) < 4 and attempts < 100:
        attempts += 1
        x = rng.randint(6, 11)   # left half, not too close to spawn
        y = rng.randint(2, 22)
        cell = (x, y)

        if grid.is_occupied(cell):
            continue

        obstacle_type = _pick_type(rng)
        obstacles.append(Obstacle(pos=cell, type=obstacle_type))

    return obstacles

def _pick_type(rng: random.Random) -> ObstacleType:
    roll = rng.random()
    if roll < 0.50:
        return ObstacleType.WALL           # indestructible
    elif roll < 0.70:
        return ObstacleType.PILLAR         # indestructible, narrow
    elif roll < 0.90:
        return ObstacleType.DEBRIS         # destructible, 100 HP
    else:
        return ObstacleType.HAZARD_ZONE    # 1.5 dmg/sec AoE

After generation, we validate reachability with a flood-fill from each spawn point. If either spawn is blocked, we regenerate with a new seed. In practice this almost never happens — the spawn points at x=4 and x=20 are far enough from the obstacle zone that connectivity failures are rare.

def _validate_reachability(grid: Grid) -> bool:
    left_reachable = flood_fill(grid, start=(4, 12))
    right_reachable = flood_fill(grid, start=(20, 12))

    # Both spawns must reach the center of the map
    center = (12, 12)
    return center in left_reachable and center in right_reachable

Missile Ballistics#

This is where the physics gets interesting. Missiles in AI Arena follow real projectile physics, not hitscan. When a robot fires, it specifies a target cell, an angle, and the engine computes a ballistic trajectory.

Range and Flight Time#

Range uses the standard range formula for projectile motion:

range = v² × sin(2θ) / g

We cap range at 15 cells regardless of launch parameters. Flight time follows:

t_flight = 2v × sin(θ) / g

In code, with our normalized unit system (g = 9.81, v = 20 m/s in game units):

# games/robot_combat/combat/ballistics.py
G = 9.81
DEFAULT_VELOCITY = 20.0

def compute_trajectory(
    origin: Vec2,
    target: Vec2,
    angle_deg: float,
    velocity: float = DEFAULT_VELOCITY,
) -> Trajectory:
    angle_rad = math.radians(angle_deg)
    raw_range = (velocity ** 2 * math.sin(2 * angle_rad)) / G
    capped_range = min(raw_range, 15.0)

    flight_time = (2 * velocity * math.sin(angle_rad)) / G

    # Midpoint of trajectory (peak arc)
    dx = target.x - origin.x
    dy = target.y - origin.y
    mid = Vec2(origin.x + dx / 2, origin.y + dy / 2)

    return Trajectory(
        origin=origin,
        target=target,
        range=capped_range,
        flight_time=flight_time,
        midpoint=mid,
        angle_rad=angle_rad,
        velocity=velocity,
    )

Kinetic Energy Damage#

Damage isn't flat. It's computed from kinetic energy at impact, converting launch energy through the full flight arc:

E = mass × velocity²
gravity_factor = 1.0 + sin²(θ) / 2.0
final_damage = base_damage × gravity_factor

The gravity_factor models the conversion of potential energy back into kinetic energy on descent. High-angle shots (steep arcs) have a higher sin²(θ), so they deal more damage on landing — realistic behavior: a missile that climbs high and falls steeply has more downward velocity at impact.

def compute_impact_damage(
    base_damage: float,
    angle_rad: float,
    mass: float = 1.0,
    velocity: float = DEFAULT_VELOCITY,
) -> float:
    kinetic_energy = mass * (velocity ** 2)
    gravity_factor = 1.0 + (math.sin(angle_rad) ** 2) / 2.0
    return base_damage * gravity_factor

In practice, this means there's a strategic tradeoff between direct flat shots (fast, lower damage) and high-arc shots (slower, harder to dodge, more damage on impact). AI pilots that model this tradeoff perform measurably better than those that always fire at the same angle.

Wind Effects#

Wind changes direction and speed at predefined tick intervals (configurable, default every 200 ticks). It affects missiles at their trajectory midpoint — the point of maximum altitude, where lateral velocity is lowest and sideways force has the most leverage.

Wind resistance scales inversely with missile velocity. Faster missiles are harder to deflect:

def apply_wind_deflection(
    trajectory: Trajectory,
    wind: WindState,
) -> Vec2:
    # Deflect from midpoint
    resistance_factor = 1.0 / (1.0 + trajectory.velocity / 20.0)
    dx = wind.velocity_x * resistance_factor
    dy = wind.velocity_y * resistance_factor
    deflected_target = Vec2(
        trajectory.target.x + dx,
        trajectory.target.y + dy,
    )
    return deflected_target

AI clients can call scan_wind_conditions before firing to get current wind state, then compensate by adjusting their target coordinates. Robots that account for wind are more accurate, especially at longer ranges where small deflections compound.

Area-of-Effect Explosions#

Missile impacts trigger a 3×3 AOE explosion centered on the impact cell. Damage falls off by ring distance:

The key nuance: splash damage requires line-of-sight from the explosion center. A robot behind a wall is protected from splash — only the direct-hit cell can damage it. This makes obstacle positioning strategically meaningful.

def resolve_explosion(
    center: Vec2,
    base_damage: float,
    grid: Grid,
    robots: list[Robot],
) -> list[DamageEvent]:
    MULTIPLIERS = {0: 1.0, 1: 0.75, 2: 0.50}
    events = []

    for ring in range(3):
        for cell in get_ring_cells(center, ring):
            if not grid.in_bounds(cell):
                continue
            if ring > 0 and not has_line_of_sight(grid, center, cell):
                continue   # Wall blocks splash

            multiplier = MULTIPLIERS.get(ring, 0.25)
            for robot in robots:
                if robot.pos == cell:
                    events.append(DamageEvent(
                        robot_id=robot.id,
                        damage=base_damage * multiplier,
                        source="explosion",
                        cell=cell,
                    ))

    return events

Dynamic Map Elements#

Static terrain would get stale quickly. We add two categories of dynamic elements to keep matches unpredictable.

Power Jars#

Power Jars spawn at random open cells roughly every 300 ticks (±60 ticks, to avoid predictability). Each jar has a 60-second TTL. Robots that move onto the jar's cell collect it automatically. There are two types:

• Energy Overdrive: +50 energy, allowing more shield activations and evasive maneuvers.
• Missile Surge: +3 missiles added to the robot's magazine.

Jar spawn positions are randomized within the center third of the map (x: 8–16), keeping them neutral territory that both robots can contest.

Dynamic Obstacles#

Up to 3 dynamic obstacles (walls, debris) can exist at any time. They appear and disappear on timers, creating temporary chokepoints or cover that shifts match positioning. The cap of 3 prevents the map from becoming so cluttered that missile lanes vanish.

Dynamic obstacles never spawn within 3 cells of a robot's current position, and their disappearance is telegraphed one cycle in advance via a CRUMBLING state that the scan tools can detect.

Determinism via Seeded RNG#

All randomness in the simulation — terrain generation, power jar spawn positions, dynamic obstacle placement, wind change timing — derives from a single per-match seed:

@dataclass
class MatchConfig:
    match_id: str
    seed: int  # Generated once at match creation

class CombatEngine:
    def __init__(self, config: MatchConfig):
        self._rng = random.Random(config.seed)
        # All subsystems share the same RNG instance
        self._terrain = TerrainGenerator(self._rng)
        self._dynamics = DynamicsManager(self._rng)
        self._spawner = PowerJarSpawner(self._rng)

Every random decision in the match traces back to this single random.Random instance seeded with config.seed. The same seed produces an identical match — identical terrain layout, identical power jar positions and timings, identical wind changes. This has several benefits:

Replay verification: We can replay any match exactly to audit results or debug AI behavior. The replay system is just the engine rerunning with the same seed and the same sequence of player inputs.

Deterministic debugging: When an AI pilot makes a puzzling decision, we can reproduce the exact battlefield state by replaying to that tick, then run the same model query again to understand what information the AI was working with.

Fair rematches: If two players want to rematch on the same map configuration, we preserve the seed. The terrain is identical; only AI strategy changes.

Putting It Together#

The combination of these systems creates matches that feel genuinely strategic:

• Mirror symmetry ensures position is never an advantage. Both robots face the same obstacle density, the same cover options.
• Ballistic physics rewards AI pilots that model projectile trajectories, wind compensation, and angle selection. Simple "fire straight" strategies lose to models that calculate optimal approach angles.
• AOE with line-of-sight makes positional play meaningful. Robots that use walls for cover take less splash damage. Robots that maneuver into open positions are vulnerable to explosion rings.
• Dynamic elements prevent static camping. Power Jars pull both robots toward contested center-map positions. Shifting obstacles invalidate plans that relied on specific cover configurations.
• Determinism makes the system auditable and debuggable without sacrificing variety.

The simulation is neither a simple game of "who has the better AI" nor a lottery of terrain luck. It's a physics system with enough depth that meaningful strategic decisions compound over 500+ ticks into clear match outcomes — which is exactly what you want when the players are AI models competing to demonstrate superior reasoning.