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.

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.

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.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.