Simultaneous hit resolution & N-body collision convergence

Clash Royale Simulator — system-level invariant verification for two engine subsystems

This is a deterministic multi-agent combat simulator written in Rust — 20 ticks per second, integer-only arithmetic, fully reproducible bit-for-bit. Built as practice for distributed systems and multi-agent simulation research, this document focuses on two system-level invariants I stress-tested with 100× reproducibility: simultaneous hit resolution (proving that symmetric agents trade damage on the exact same tick — the distributed consensus problem of "who goes first") and N-body collision convergence to stable separation (proving that N overlapping agents reach equilibrium spacing — the swarm formation problem). These mirror exactly the challenges of concurrent event ordering in distributed systems and multi-robot formation control in cloud-native edge deployments.

1. The simultaneous hit problem data-driven

When two identical agents face each other at equal distance, both enter attack windup on the same tick. The question: does the engine resolve both hits on the same tick (mutual trade), or does iteration order cause one to die before dealing its hit? This is the distributed conflict resolution problem — identical to two nodes transmitting simultaneously.

Data model (Knight, tournament standard level 11)

Parameter	JSON field	Value	Engine units
Hitpoints	`hitpoints_per_level[10]`	1766	HP
Damage	`damage_per_level[10]`	202	HP per hit
Hit speed	`hit_speed`	1200 ms	24 ticks (full cycle)
Load time (windup)	`load_time`	700 ms	14 ticks
Backswing	`hit_speed − load_time`	500 ms	10 ticks
Movement speed	`speed`	60 → 30 u/tick	after `speed_to_units_per_tick()`
Attack range	`range`	1200	internal units
Collision radius	`collision_radius`	500	internal units

Attack phase state machine

Each troop has a 3-state attack animation model, driven by load_time and hit_speed from the JSON data. Damage is only applied at the Windup→Backswing transition. If the target becomes invalid during Windup, the attack is cancelled and the troop returns to Idle without dealing damage.

Figure 1 — Three-phase attack state machine. Damage fires only at the Windup→Backswing transition. All timing from JSON load_time and hit_speed.

The symmetric scenario

Place two Knights at equal distance from each other, both deployed simultaneously. They walk toward each other at identical speed (30 u/tick), enter range on the same tick, start Windup on the same tick, and the 14-tick timer expires on the same tick. The question is whether the engine processes A's damage before B's — which would kill B before B's hit resolves.

Figure 2 — Frame-by-frame trace of two symmetric Knights. Both enter Windup on tick t₁+1, both deal damage on tick t₁+14. The engine iterates entities in order, but damage is applied after all combat is resolved — no first-mover advantage.

Why this works: deferred damage application

The engine's tick loop (step 7 in engine.rs) processes combat in two phases. First, all entities evaluate their attack state machines — advancing timers, detecting Windup completion, computing damage amounts. Then, accumulated damage is applied to targets. This means entity A's hit doesn't kill entity B before B's own hit resolves in the same tick.

tick_combat: ∀ entity → advance_phase(entity) → collect_hits()

then: ∀ hit ∈ collected → apply_damage(hit.target, hit.amount)

This is the synchronous update pattern — identical to how distributed simulations handle concurrent state mutations. All agents observe the previous tick's state, compute their actions, and commit simultaneously.

Determinism proof: 100× identical outcomes

The test spawns the same scenario 100 times and SHA256-hashes the complete entity state (position, HP, buffs, attack phase, target) after 300 ticks. All 100 hashes are identical, proving zero non-determinism in the combat resolution path.

Figure 3 — 100-run determinism verification. The full entity state snapshot is hashed at tick 300. All 100 hashes match — the trade resolution is deterministic.

2. Ranged trade: projectile flight symmetry data-driven

The same property holds for ranged units. Two Musketeers (range = 6000, projectile speed = 1000) fire projectiles on the same tick. Both projectiles travel independently and deal damage on impact. We verify both took damage after 150 ticks, consistent 100×.

Figure 4 — HP traces of two symmetric Musketeers. Both lines overlap exactly — projectile flight is symmetric and deterministic. Both die on the same tick (mutual kill). Verified 100×.

Two Knights meet at the bridge and trade damage on the exact same tick. Two Musketeers duel at range with perfectly mirrored HP. No first-mover advantage from entity iteration order.

Melee (Knight vs Knight):
tick 181: both enter Windup → tick 195: both deal 202 dmg → HP: 1766 → 1564 (same tick)
Ranged (Musketeer vs Musketeer):
tick 20: both enter Windup → tick 24: both fire → tick 31: both projectiles land (−263 each)
HP trace: 870 → 607 → 344 → 81 — perfectly mirrored every hit

PASS — Melee first-hit tick diff = 0 ✓ Ranged first-hit tick diff = 0 ✓ No first-mover advantage from entity iteration order.

⏱ Deploy timer: Troops have a ~1 second deploy animation (~20 ticks) before they become active. The Knights sit idle until tick 20, then walk ~160 ticks to meet at the bridge. Combat begins at tick 181. The Musketeers are within range immediately after deploy, so they start windup at tick 20 (first tick after deploy completes).

3. N-body collision convergence data-driven

When N agents spawn at the exact same position, the collision resolution system must separate them to stable equilibrium positions. This is the swarm formation control problem — identical to drones initializing at a shared depot and fanning out to surveillance positions.

The convergence dynamics

Each tick, the collision system computes pairwise overlap between all non-flying entities within 1.2 × (r_i + r_j) distance. For Knights (collision_radius = 500), the interaction radius is:

r_interaction = 1.2 × (500 + 500) = 1200 iu

The push force is proportional to the penetration depth:

overlap = r_interaction − dist(p_i, p_j)

push_magnitude = overlap / 2 (split equally, adjusted by mass ratio)

At exact overlap (dist = 0), the symmetry-break rule fires: entity with even ID pushes +X, odd pushes −X. This seeds the initial separation.

Figure 5 — Minimum pairwise distance over time for N=5 and N=10 Knights spawned at the same point. Both converge to ~998 iu (≈ 2 × collision_radius). N=10 takes ~60% longer. Dots are measured tick-level values from the test harness.

Equilibrium spacing

The stable separation distance converges to approximately 2 × collision_radius. This is because the push force reaches zero when entities are exactly at the interaction boundary. For Knights:

d_equilibrium ≈ 2 × collision_radius = 2 × 500 = 1000 iu

Measured: 998 iu (test 1830c). The 2-unit discrepancy comes from integer truncation in the push vector computation — consistent with the integer-only arithmetic invariant.

5 Knights spawned at the same point fan out and stabilize within 2 ticks of deploy completing. N=5 converges at tick 22, N=10 at tick 29. Both reach equilibrium at 998 iu (≈ 2 × collision_radius).

N=5 Knights: min pairwise dist: 0 → 841 → 963 → 998 (converged tick 22)
N=10 Knights: min pairwise dist: 0 → 226 → 608 → 935 → 998 (converged tick 29)
Equilibrium: 998 iu for both (2-unit integer truncation from theoretical 1000)

PASS — N=5 equilibrium 998 ✓ N=10 equilibrium 998 ✓ N=10 converges slower than N=5 ✓ All agents separated, zero overlaps.

⏱ Deploy timer: The ~20 tick deploy animation accounts for the flat zero region at the start. The graph's "Tick (after deploy)" axis maps to absolute ticks minus ~20. Post-deploy, N=5 converges in just 2 ticks — even faster than the diagram's conservative estimate of ~10.

4. Layer isolation: flying ignores ground data-driven

The collision system operates on two independent layers: ground (z = 0) and air (z > 0). Ground entities only collide with ground entities; flying entities only collide with flying entities. A ground Knight and a flying Mega Minion at the exact same (x, y) do not push each other.

Entity	`flying_height`	Layer	Collides with
Knight	0	Ground	Ground troops + buildings
Mega Minion	1500	Air	Air troops only
Cannon (building)	0	Ground	Ground troops

Figure 6 — Layer isolation. Ground entities collide with ground entities. Air entities pass through ground entities and buildings. Same (x,y) ≠ same collision layer.

The collision check in combat.rs enforces this with an explicit layer guard:

// combat.rs — tick_collisions(), layer guard
// Flying/ground layer check: flying only collides with flying,
// ground only with ground (and buildings which are always ground).
if a.is_flying != b.is_flying && !b.is_building {
    continue;
}
// Flying troops don't collide with ground buildings
if a.is_flying && b.is_building {
    continue;
}

Left: Knight + Mega Minion at same position walk overlapped (no collision push). Right: two Knights at same position instantly separate. At tick 20: cross-layer dist = 4, same-layer dist = 1015.

Cross-layer (Knight + Mega Minion): tick 20: dist=4 → tick 40: dist=576 (gradual drift, no push)
Same-layer control (Knight + Knight): tick 20: dist=1015 → tick 40: dist=999 (instant push, stable)

PASS — Cross-layer pair: no collision push ✓ Same-layer control: instant separation to 999 ✓ Clear contrast of 423 units at tick 40 ✓

The cross-layer pair's gradual drift (4 → 576 over 20 ticks) comes from different movement speeds and pathfinding — the Knight walks on the ground toward a bridge while the Mega Minion flies straight. This is not collision. The proof is at tick 20: same-layer jumps 0→1015 in one tick while cross-layer moves only 0→4.

5. Design constraints data-driven

Constraint	How satisfied
Deterministic conflict resolution	Deferred damage application: all hits computed before any applied. Verified 100× with SHA256 hash.
No first-mover advantage	Entity iteration order doesn't affect outcomes. Symmetric agents produce symmetric results.
Collision convergence	N=5 converges in ~10 ticks, N=10 in ~16 ticks. Equilibrium at 2 × `collision_radius`.
Layer isolation	Explicit `is_flying` guard. Zero cross-layer push forces.
Integer-only arithmetic	Push vectors use `i64` intermediate products, truncated to `i32`. No floating-point drift.
All parameters from JSON	`collision_radius`, `mass`, `flying_height`, `load_time`, `hit_speed` — zero hardcoded heuristics.

6. Validation results

RESULTS: 96 passed, 0 failed out of 96 assertions

Simultaneous hit resolution:
  ✓ Mirror Knights: both trade same tick (diff=0), consistent 100×
  ✓ Mirror Musketeers: both projectiles deal damage, consistent 100×
  ✓ Simultaneous princess tower destruction: consistent 50×
  ✓ Melee vs ranged first-hit: Musketeer always hits first, consistent 100×

Collision convergence:
  ✓ 5 Knights at same point: all 5 separated, no overlaps
  ✓ Min pairwise distance = 998 iu (≈ 2 × collision_radius)
  ✓ 10 Knights at same point: ≥5 unique positions, all alive
  ✓ Flying + Ground same position: no collision (layer isolation)
  ✓ Building blocks troop pathing (no clip-through)

System-level determinism:
  ✓ 4v4 combat: 100× identical SHA256 hashes
  ✓ Complex mixed scenario: 50× identical
  ✓ Full 9600-tick match: 10× identical
  ✓ Entity ID monotonicity: 200 spawns strictly increasing
  ✓ Entity pool cleanup: 200-entity combat, dead removed correctly