Skip to main content

Changelog

This page is curated from the Git history of the server, public frontend, Python SDK, documentation, and Arena Hero Skill repositories. It records changes that players or developers can observe. Pure refactors, CI maintenance, and internal security fixes are grouped instead of copied commit by commit.

Gameplay rule versions are independent from the Python SDK version. The public HTTP and WebSocket API is still v0.1. For the exact currently reviewed source, see Source and version policy.

6 August 2026​

Gameplay rules v0.14 — dynamic Unit prices replace maintenance​

  • The per-Tick maintenance charge and all maintenance damage are gone. The population_tier, upkeep_next_tick, UPKEEP_PAID, and UPKEEP_DEFICIT protocol concepts have been removed rather than kept as deprecated fields.
  • Worker, Vanguard, and Ranger keep base prices 5, 10, and 12 for Units 1-20. Starting with the 21st Unit, price is round_half_up(base_price × (13/10)^k), where k = max(0, floor((population - 20) / 5) + 1). The exact fraction is rounded only once at the end.
  • Spawn pricing uses living population after same-Tick Unit self-destruction and combat deaths. The initial and respawn Worker remain free.
  • CORE_SPAWN_SUCCEEDED.values.cost and CORE_SPAWN_FAILED/INSUFFICIENT_RESOURCES.values.required report the actual settled price.
  • Both official web clients remove maintenance warnings and results, and show dynamic prices from the current state. Same-Tick deaths can make the server charge less than that preview.
  • Python SDK v0.2.9 removes the old state fields and adds the typed, exact unit_cost(unit_type, population) helper plus read-only UNIT_BASE_COSTS.

This is a breaking state/event-model cleanup for clients that require the two removed state fields or enumerate maintenance events. HTTP and WebSocket remain API v0.1 because their endpoints and envelope shapes are unchanged.

Source: server b24cfcd, frontend 00f4093, and SDK 423d252.

3 August 2026​

Gameplay rules v0.13 — true Ranger cell fire​

  • SHOOT keeps its name and always uses expected_cell, but target_id is now optional. Existing precision-target commands remain fully compatible.
  • Without target_id, a Ranger may fire at any unobstructed horizontal, vertical, or exact-diagonal cell at range 1–3, even when it is empty when the command is submitted.
  • Movement resolves first. The server hits the lowest-HP hostile then present in that cell, breaking HP ties by raw UUID order; an empty cell resolves as the normal indistinguishable SHOT_MISSED.
  • Both web clients now always enable Ranger shooting and highlight every legal firing cell instead of requiring the frontend to invent a target UUID.
  • Python SDK v0.2.8 adds ranger.shoot_cell(position) and makes ShootAction.target_id optional while retaining ranger.shoot(...).

This fixes the 2 August web-only approximation: that version looked like a cell selector but still refused to fire unless it could nominate a visible enemy as target_id. HTTP and WebSocket remain API v0.1; gameplay rules advance to v0.13 because server combat selection changed.

Source: server 57c2a5b, frontend ceaf2b6, and SDK e32ff94.

Gameplay rules v0.12 — unconditional Core self-destruction​

  • Every living Core can submit {"type":"SELF_DESTRUCT"} with no resource, Unit, movement-state, or cooldown restriction.
  • Movement and combat resolve first. A lethal enemy attack keeps normal destruction participation and resource capture; otherwise the surviving Core destroys its inventory and all owned Units before healing, repair, or spawn.
  • Worker cargo and the Champion Beacon drop at each carrier's actual position. Core self-destruction awards no damage, destruction participation, or loot.
  • The private CORE_DESTROYED result uses reason_code: SELF_DESTRUCT without destroyed_by, then follows the normal same-Tick respawn flow.
  • Both web clients add a destructive Core action with confirmation and dedicated Tick-result/respawn feedback.
  • Python SDK v0.2.7 adds core.self_destruct() and accepts SelfDestructAction as a strict Core action.

This adds a new strict core_action.type enum value while keeping HTTP and WebSocket API v0.1. Clients with a closed Core-action union must update before parsing a canonical received.plan containing this action.

Source: server bdd68e8, frontend 9d2d553, and SDK 880e3a3.

2 August 2026​

Official web client — aimed cell attacks​

  • Vanguard manual controls now allow any adjacent cell to be selected, including an empty cell an enemy may enter during resolution.
  • Ranger manual controls now select a highlighted firing cell. The client keeps the existing target_id plus expected_cell protocol and automatically picks the lowest-HP visible enemy already in that cell, or the lowest-HP enemy one move away when predicting movement into an empty cell.
  • This is a web-client and tutorial improvement. Server combat rules and command JSON are unchanged.

This client-only implementation was later superseded by rules v0.13 above, which allows genuine target-free cell shots.

Public lifetime leaderboards​

  • Added one public leaderboard endpoint and web page for exactly three lifetime statistics: Champion Beacon Ticks held, damage dealt, and Core destruction participations.
  • Each board shows the top 100 non-zero scores. Equal scores share a competition rank, with username order keeping ties stable.
  • Only public usernames, ranks, and scores are exposed. Private statistics, email addresses, and internal user IDs remain private.

Gameplay rules v0.11 — unpaid upkeep damages excess Units​

  • Upkeep still spends available Core resources first, but an unpaid point now deals 1 HP of damage to an excess Unit instead of damaging the Core.
  • The 19 Units nearest the current Core are protected. Other Units are ordered farthest first by Manhattan distance, with raw UUID order breaking ties; damage is concentrated in that order.
  • Upkeep deaths resolve before movement and combat. Worker cargo and a carried Beacon drop normally, no enemy receives destruction participation, and a surviving damaged Unit may still act and heal later in the Tick.
  • UPKEEP_PAID continues to report due, paid, and deficit. UNIT_DAMAGED / UPKEEP_DEFICIT reports the affected Unit, damage, and HP.
  • The frontend explains upkeep damage and destruction in Tick results. It also warns when the next Tick's upkeep exceeds current Core resources, showing the exact shortfall and which Units are at risk. The Python SDK documentation shows how to read the forward-compatible event.

Source: server 83ae972, frontend Tick results 0a673f1, frontend warning 4d2808c, and SDK 8f967aa.

Gameplay rules v0.10 — post-combat HP recovery​

  • Every Unit can use HEAL while sharing a cell with its own stationary Core; the Core can also use HEAL as its action.
  • Healing runs after simultaneous combat damage and costs 1 Core resource per HP actually restored. One action may spend several resources to reach full HP.
  • Unit heals resolve by Unit UUID before the Core action. Fatal damage cannot be healed, and a failed heal spends nothing.
  • Core healing, shield repair, and spawning now resolve after combat. Newly spawned Units cannot be attacked during their birth Tick, and repaired shield cannot absorb damage from the Tick that just ended.
  • Inventory captured from a destroyed enemy Core can immediately fund Unit healing and the surviving Core action in the same Tick.
  • Added private healing result events, lifetime HP-recovery counters, frontend controls and feedback, plus Python SDK v0.2.6 with unit.heal(), core.heal(), HealAction, and typed HealingResult values.

Source: server 5a3bcdf, frontend 789cf1b, and SDK 4a29585.

1 August 2026​

Gameplay rules v0.9 — Core resource capture​

  • A Core destroyed in combat offers its complete stored inventory to the player who dealt the most damage to that Core during the destruction Tick.
  • Tied damage uses raw player UUID order. Every attacker still receives normal destruction participation; that statistic does not decide resource ownership.
  • The winner stores only what fits under the post-combat max(10, population × 5) capacity. Overflow is destroyed.
  • If the winner's Core also dies in the same combat Tick, all victim resources are destroyed. Upkeep-deficit destruction never yields loot.
  • Added private CORE_RESOURCES_CAPTURED results, frontend feedback, and the typed SDK CoreResourceCapture model.

Source: server a998d8d, frontend 0daf69a, SDK 9cfe088, docs 9a881bf, and Skill 1c4b126.

Gameplay rules v0.8 — diagonal Ranger fire​

  • Rangers may shoot horizontally, vertically, or on an exact 45-degree diagonal at range 1-3.
  • Only obstacles in intermediate shot cells block the shot. Objects beside the line do not.

Source: server 59268f3.

Gameplay rules v0.7 — piercing fire and immediate respawn​

  • Ranger shots pass through Units and Cores; only terrain obstacles block them.
  • The respawn cooldown was removed. A destroyed Core normally gets its replacement attempt later in the same resolution Tick.
  • The web client also fixed deposit priority around Core movement and restored visible Core shield state on the arena map.

Source: piercing fire fb7680f and immediate respawn 2b32550.

30 July 2026​

Gameplay rules v0.6 — minimum Core capacity​

  • Core storage became max(10, population × 5), so zero, one, and two living Units still provide 10 capacity.
  • Deposits stop at the strict limit and population loss immediately destroys existing overflow.

Source: server f81b6c9.

Gameplay rules v0.5 — population-based storage​

  • Core resource capacity became dependent on the current living Unit population.
  • The frontend and SDK exposed capacity and remaining resource space.

Source: server bc16014.

29 July 2026​

Gameplay rules v0.4 — recoverable Worker cargo​

  • A dead Worker drops all carried resources on its final cell.
  • Cargo piles persist separately from natural chunk quotas and can be harvested until empty.

Source: server f98e22e.

Gameplay rules v0.3 — Unit self-destruct​

  • Every Unit may self-destruct before upkeep.
  • Self-destruct gives no refund, damage, or enemy destruction participation; Worker cargo and a carried Beacon still drop normally.

Source: server 16b152b.

Gameplay rules v0.2 — finite resources​

  • Natural resource points became consumable instead of permanent.
  • Each 32×32 chunk maintains a fixed distance-based quota and replenishes missing positions every four resolved Ticks.
  • Same-cell harvest contention became deterministic.

Source: server c655315.

Frontend and visible-state changes​

  • Terrain rendering was cached by chunk and the arena moved toward a sharper, smoother canvas renderer, especially on Retina displays and during zoom.
  • Visible Cores began exposing owner_username, displayed as @username; Unit ownership remained private.

Source: terrain caching e2e2ba5, Retina rendering ca2eea4, and Core usernames 4d6454f.

28 July 2026​

  • The official typed Python SDK launched with synchronous and asynchronous clients, Turn controllers, retries, receipts, and WebSocket reconnection.
  • The bilingual Docusaurus documentation site launched, followed by dedicated Python SDK and Arena Hero Skill sections.
  • The Arena Hero Skill launched with tactic-script and direct-play modes, then bundled the complete gameplay and developer documentation for offline use.

Source: SDK b784c81, docs d66a0b8, and Skill 7e0422d.

26 July 2026​

  • Replaced the long-lived SSE game stream with server-to-client WebSocket messages while keeping command submission on HTTP.
  • Added canonical received plan messages to every connected client for the same player, including reconnect snapshots.

Source: WebSocket transport 243a05b and cross-client receipts b9d4de7.

23–25 July 2026​

  • Completed the production-aligned rules, Champion Beacon, deterministic movement and combat, PostgreSQL persistence, authentication, and deployment foundation.
  • Removed the global state-publication barrier: each player can submit as soon as their own complete state is published.
  • Scaled the single-world server design for 5,000 concurrent players.
  • Added the interactive web tutorial and completed two security-hardening rounds.

Source: production alignment a707f66, state publication 694c4c0, 5,000-player scaling fb5a3cd, and tutorial 3a9535c.

15–17 July 2026​

  • Created the shared persistent world, deterministic Tick engine, initial tick / state / command protocol, Go server, PostgreSQL storage, and web client.
  • Added autonomous client-side routes that submit only the next legal step each Tick.

Source: initial implementation c32c144 and movement routes d9c7d2d.

Python SDK releases​

SDK versions are separate from gameplay rule versions.

VersionDateDeveloper-visible change
0.2.96 Aug 2026PyPI release removing maintenance state fields and adding exact dynamic Unit-price helpers.
0.2.83 Aug 2026Adds ranger.shoot_cell(position) and accepts ShootAction without target_id; released on PyPI.
0.2.73 Aug 2026Adds core.self_destruct() and accepts strict SelfDestructAction plans for Cores.
0.2.62 Aug 2026PyPI release adding Unit/Core healing, typed HealingResult, and the CoreResourceCapture model from the unreleased 0.2.5 source.
0.2.5 source1 Aug 2026Adds typed CoreResourceCapture; committed but not yet published to PyPI.
0.2.430 Jul 2026Adds the minimum Core-capacity contract and release metadata.
0.2.330 Jul 2026Exposes Core resource capacity and available storage space.
0.2.229 Jul 2026Exposes public Core owner_username.
0.2.129 Jul 2026Packaging and Apache-2.0 release update; no gameplay protocol change.
0.2.029 Jul 2026Adds self-destruct and cargo recovery event support.
0.1.028 Jul 2026First PyPI release of the official synchronous and asynchronous SDK.