Skip to content

Panzer Island: Development Log

Project codename: Tank Tactics 2D

Public name: Panzer Island

Engine: Godot 4.6

Targets: Windows, macOS, Linux, Android, iOS (will come later)

Current release candidate: v0.1.1.rc0

Author: rhedak

1. Overview

What it is

Panzer Island is an anime-styled 2D top-down semi-turn-based strategy game. You play Erika, a scientist with amnesia stranded on an abandoned island whose automated defenses are still online. She remembers only her own name. Three AI-piloted units, Katyusha (tank), Nadeshiko (helicopter), and Maria (ship), recognize her and follow her voluntarily. Together they fight their way across the island, recovering memory fragments that gradually reveal what Erika built, what went wrong, and who her husband Wilhelm has become.

The main idea

The defining mechanic is the reactive turn system. There is no clock and no enemy "phase." Drones only move, fire, or pursue when the player does something. Look at a stage as long as you want; plan as carefully as you like; the world holds its breath until you commit to a move or an attack. The challenge comes from positioning, action budgeting, and reading drone behavior, not from reaction speed.

Layered on top of that: a stage is split into sectors. Crossing a sector boundary triggers an inter-sector cutscene and re-uses your surviving units in a fresh tactical situation. Persistent HP, XP, and skill choices carry across sectors and across stages.

How to play

  • Click a unit to select it; the move and attack ranges fan out.
  • Click a cell to plan a route. Multi-waypoint paths with confirm / cancel, with an amber marker on cells that put you inside a drone's reaction range.
  • Click an enemy in range to attack. After a manual attack you can auto-chain follow-up attacks until the target dies or you cancel.
  • Limit breaks charge during a stage and trigger per-character signature abilities: Katyusha's Iron Curtain (counter-fire wall), Nadeshiko's Storm Run (dash + AoE), Maria's Broadside (line attack from sea).
  • Level-up choices at L4, L7, L14, L17 pick between cascading skill branches; growth rates are flat per-stat per-level.
  • Difficulty tiers: Normal, Hard, Expert, Extreme, Lunatic. Beating Stage 10 on a tier unlocks the next.

What's available

  • What's available (v0.1.1.rc0)
  • Chapter 1 ("Cold Start")
    • 10 stages, playable end-to-end.
  • Chapter 2 ("Signal")
    • Early stages drafted; in active development (subject to change).
  • Core Systems:
    • Reactive turn system, units, drones, and combat are fully implemented.
  • Progression:
    • Skill trees, limit breaks, and level-up choices are finalized.
  • Difficulty Tiers:
    • 5 tiers available for replayability.
  • Story Content:
    • Cutscenes, memory fragments, and credits roll are in place.
  • Audio:
    • 11 chiptune tracks (CC) and procedural SFX.
  • Player Support:
    • Full Non Invasive Tutorial system and Archive.
  • Localization:
    • EN / JA / DE (The languages I speak) scaffolding is done; content overlays are ongoing.
  • Data Management:
    • Save/load systems and schema migrations (v11) are stable.
  • Development Tools:
    • Stage, cutscene, and balance editors (Python/Tkinter) plus the campaign-wide feasibility solver are complete.

2. Development philosophy

This project is human-driven, gen-AI-assisted. Every design call, balance verdict, story beat, and shipped commit comes from a human (me); gen-AI is used as a power tool to compress the implementation gap between "I want to try X" and "X is in my hands and I can feel whether it's any good."

A few specific places that shapes:

  • Art assets. I can't draw. So every in-game sprite (units, drones, terrain tiles, props, UI icons, the world map, the boot splash, the studio logo) is generated programmatically with Python and matplotlib, reproducibly via ./generate.sh. The character portraits (Erika, Katyusha, Nadeshiko, Maria, Wilhelm, and Chapter 2's alpha cast) are generated with Google Gemini against a tightly specified prompt set in docs/assets/portraits.md, then post-processed (bust crops, etc.) by Python tooling. Same constraint applies to SFX: generated by a tiny Python wave-package synth from presets in data/audio/sfx_params/.
  • Balancing tools. The Python balance editor, stage editor, cutscene editor, and feasibility solver in tank_tactics_tools/ were built with heavy gen-AI assistance because I'd rather spend my time using those tools to tune the game than writing Tk dialogs. The tools exist so a human can iterate on balance and content fast; the design decisions they enable are still mine to make and to live with.
  • Code. Gen-AI accelerates the boring parts (parsers, refactors, test scaffolding) and asks good questions during design discussions. It does not pick the design. Every merged change is one I've validated by actually playing the game.

Two rules I lean on hard:

  1. Parity over cleverness. The Python solver mirrors the live game's combat, movement, drone, and progression rules. Every gameplay change updates both sides in the same commit. Drift between the two would make the solver lie about whether a stage is clearable.
  2. Playable trumps planned. Chapter 1 went through a full rewrite stage-by-stage in early May after I could finally sit down and play the whole sequence on hardware. Chapter 2's current shape is a draft, and it will get the same treatment.

3. Development log

Development started on 2026-04-19, that's about four weeks.

Below I recap on my work based on the git history. Skip ahead if you find that boring.

Phase 1: Foundation (Apr 19-22)

  • Initial commit (Apr 19). Empty Godot 4.6 project scaffolding.
  • Chapter 1 game logic, reactive step system, GUT test suite (Apr 20). The first real commit. Units, drones, the turn model, and the harness that would catch every regression afterward.
  • Milestone 1 + 2: Ch1 playable + story integration (Apr 20).
  • Milestone 3: stage redesign, layer system, balance tooling, bug fixes (Apr 21). The sector / layer concept showed up here.
  • UI / menu system (Apr 22). Pause, title screen, options, unit inspect, drone inspect, stage result.

Phase 2: Chapter 1 content slices (Apr 22)

A single very productive day delivered the entire Chapter 1 narrative spine, in "slices" landed one at a time:

  • Slice 1-2: Ch1 polish M0, narrative direction docs.
  • Slice 3: unit unlock gating ("???" silhouettes for locked units).
  • Slice 4 / 4b: Nadeshiko intro + Stage 2 "The Hangar" reworked around a mountain ridge that forces helicopter-only routes; reactive drone movement engine.
  • Slice 5: Hold objective primitive + Stage 4 "The Bridge."
  • Slice 6a / 6b: Escort primitive + Stage 5 "Shoreline" + Maria intro + Stage 6 "Coastal Sweep."
  • Slice 7: multi-log memory system + Stage 8 "The Archive."
  • Slice 8: Stage 7 "Tower Network" + Stage 9 "Approach."
  • Slice 9: Stage 10 "The Nest" + Wilhelm reveal + Chapter Complete card.
  • Slice 10: balance pass, tooltip sweep, roadmap status refresh.

End of day, the demo was playable start to finish. Rough, but coherent.

Phase 3: JSON migration + Python tooling (Apr 22-23)

  • T1: JSON loaders, locale fallback, layer-aware StageFromData.
  • T2: migrated all Chapter 1 content to JSON; stage .gd files became thin wrappers.
  • T3 / T4: first Python Tkinter editors. Stage editor MVP, cutscene editor MVP.
  • pyproject + uv: proper Python project setup, renamed tools/ to tank_tactics_tools/.

This was the inflection point where editing content stopped meaning "editing GDScript" and started meaning "open the Python editor."

Phase 4: HUD overhaul + limit-break rework (Apr 23)

  • HUD got bar labels, HP numbers, limit %, per-unit XP bar.
  • Limit-break overhaul: per-unit HUD buttons, real effects, reactive triggering.
  • Stage editor themes A through D: delete / move / drag-paint, grid overlays, dirty flag with save-prompt, multi-step undo, shortcuts, presets, drone list, hover coords. The editor became actually pleasant to use.
  • BalanceDB: extracted gameplay constants to data/balance/*.json.

Phase 5: NEXUS boss + art passes (Apr 23-24)

  • NEXUS drone: Chapter 1 final-boss type with summon behavior.
  • Bust-shot portrait pipeline: new crop tool, 28 pre-cropped files, iterated crop ratio (40% to 55% to 65%).
  • Cutscene backdrops: Python generator + 10 scene PNGs wired into the dialogue player.
  • Stage props: 20 decorative sprites + per-stage placement.
  • Landmark props: multi-cell prop system. lab_garage, hangar_helipad, broken_bridge, sandbag_revetment, campsite.
  • Road autotile: 10 variant tiles + neighbor-based picker.
  • Terrain skins + playtest level overrides per stage.

Phase 6: Balance system + routing overhaul (Apr 27-28)

  • Multi-waypoint routing: Confirm / Cancel, amber danger markers, re-tap-to-execute, click-transparent overlays to keep HUD clicks from leaking through.
  • Balance editor with unit + drone growth tabs.
  • Active skills cascading across L4 / L7 / L14 / L17.
  • Level-up celebration dialog mid-stage after each action settles.
  • Python feasibility solver added; old balance.sh retired.
  • Limit-break elective upgrades rewritten as stack-based picks.
  • Story rework: Drona's silent presence threaded through every stage; island factoid arc planted in post-stage cutscenes; Wilhelm escalation arc through Ch5-9; Ch10 finale rewritten ambiguous.

Phase 7: Mobile prep, XP system, drone fixes (Apr 29-30)

  • XP formula: replaced threshold table with formula; XP scales by drone level.
  • Join-XP: Nadeshiko and Maria get retroactive XP on first unlock so they're not under-leveled on arrival.
  • Tutorial system + Archive.
  • Android back button + touch inspect gesture; APK support.
  • Patrol pursuit bugs (occupancy corruption, input freeze, ring visibility) fixed and covered by regression tests.
  • Click interception: MOUSE_FILTER_IGNORE on all drone/unit Control nodes (the source of many "why won't my tap register" bugs).
  • Difficulty tiers introduced (Normal through Lunatic).
  • Cheats added in four passes for playtesting (UNLOCK_ALL etc.).
  • World map revamp; zoom / drag polish.

Phase 8: UX, animation, projectiles, music (May 1-2)

  • New Game now drops straight into Stage 1 (no landing page, no world map detour).
  • Top HUD polish, difficulty selection, panzer-island logo.
  • Auto-attack loop with cancel after manual first attack.
  • Multi-waypoint route simplification when paths cross themselves.
  • XP death penalty + result screen on quit.
  • UNLOCK_ALL cheat that does a full reload (cleaner than in-place).
  • Iron Curtain change: don't halt on cap; flash label and keep moving / attacking.
  • Unit + drone auto-rotation to face movement / attack direction.
  • Animation 1.0 through 1.2: full polish pass.
  • Music added (11 chiptune tracks by Patrick de Arteaga).
  • Projectiles rendered properly.

Phase 9: Chapter 1 stage-by-stage polish (May 3-5)

The first end-to-end hardware playthrough exposed every rough edge in Chapter 1. Each stage got its own polish commit, then each got a visual polish commit, then each got a backdrop polish commit:

  • Story rework pt1, then ten consecutive ch01 - stage01 … stage10 commits.
  • Then stage01 visual polish, stage02-04 visual polish, visual polish up to stage10.
  • Then seven backdrop polish commits.
  • Boot splash + theme polish.
  • Leveling balancing system implemented with full documentation.

Phase 10: Bug squash + Japanese localization (May 5-8)

  • Iron Curtain activation made a free action.
  • Auto-attack keeps hitting the same enemy bug fixed.
  • Pursuit triggers rewritten: never path to a unit's occupied cell; fix break-off pursuit; per-step movement rather than per-action.
  • Defensive guards for units / drones becoming untappable.
  • Always show chapter + stage number on screen.
  • umi no ie landmark prop added.
  • Stage 5 missing drones fixed; Stage 3 interceptors removed.
  • Save game transfer across schema versions (added in three passes).
  • Win message + credits system: JSON-driven scroll, fires once per first-clear-per-tier, also reachable from title.
  • Marketing gen + marketing screenshots.
  • Japanese translations for Stage 1, then Stage 2, then the rest, with a per-character register / pronoun styleguide at docs/localization/styleguide_ja.md. Includes the Katyusha-doesn't-use- お前-with-Erika rule.
  • Cutscene replay from the title menu.

Phase 11: Release engineering for v0.1.1 (May 9-10)

  • UI overhaul: many modals re-flowed to fit phone screens.
  • Build configurations + build.sh that stamps version from VERSION into project.godot and export_presets.cfg.
  • Desktop icon set.
  • Build script update for Google Play verification.
  • VERSION bumped to 0.1.1.
  • German styleguide + initial German translations.

Phase 12: Chapter 2 begins + rc/v0.1.1-dev (May 11-14)

This is the current branch. Chapter 2 is being drafted; the demo (Chapter 1) remains the playable spine.

  • Localization panel in stage editor.
  • Story polish.
  • Erika field repair mechanic prepared (and iterated across many polish commits).
  • Chapter 2 draft, alpha character art, alpha unit fixes.
  • Range theme + more themes for stage visuals.
  • Chapter 2 stage 01 redesigned, polished, then stage 03 added.
  • Cutscene rewrite + narration mode in dialogs.
  • New drones: SPOTTER and REPAIR.
  • Overlevel XP penalty: discourages farming low stages with high-level units; mirrored in Python solver.
  • Memory log asset + animation added.
  • Stage editor: polish ranges, generate options, theme review + completeness check.
  • Google Play payment preparation.
  • Android release notes added.

Where things stand at v0.1.1.rc0

  • Tests: 414 GDScript tests passing, 200 Python solver tests passing (3 skipped behind PARITY_CHECK=1).
  • Chapter 1 is content-complete and shipped end-to-end through the Wilhelm reveal. It is eligible for redesign if Chapter 2 production exposes pacing or balance problems that propagate backwards.
  • Chapter 2 is in early development. Story, level design, drone roster, and balancing are all draft and expected to change. The alpha character art is in place but not final.
  • Release engineering remaining: Google Play store-page setup, Steam page, iOS provisioning. Build pipeline itself is wired up.

4. Tooling that made this possible

Four pieces of Python tooling carry a disproportionate amount of weight:

  • tank_tactics_tools/solver/: feasibility solver that mirrors the live engine and produces clearing action logs for each stage. The campaign-wide "is this stage actually beatable?" oracle.
  • tank_tactics_tools/stage_editor/: Tkinter UI for placing terrain, drones, props, objectives, patrol waypoints, layer transitions, and playtest overrides.
  • tank_tactics_tools/cutscene_editor/: locale-aware authoring for pre-stage / inter-layer / post-stage dialogue.
  • tank_tactics_tools/balance_editor/: flat-rate growth schemas, XP-budget tab, parity tab against the live game.

All four were built with gen-AI assistance. None of them make balance decisions for me; they make those decisions cheap to try.

The art pipeline:

  • ./generate.sh: rebuilds every pixel-art asset from Python / matplotlib source.
  • ./generate_sfx.sh: rebuilds every SFX from data/audio/sfx_params/ presets.
  • docs/assets/portraits.md: exact Gemini prompts used to generate character art, with a bust-crop tool to produce the dialog-framed variants.

The discipline rules:

  • ./check.sh after every code change (Godot parse-check).
  • ./test.sh after any logic change (GUT suite).
  • uv run python -m unittest discover -s tank_tactics_tools/tests -v after any change to a solver-mirrored file.

5. Credits

(Same as the in-game credits roll.)

PANZER ISLAND

Chapter 1: Cold Start

Design, Programming & Story rhedak

Sound Effects rhedak – Created with Python wave package

Art Assets rhedak – Created with matplotlib Character Portraits – Created with Google Gemini

Music Chiptune by Patrick de Arteaga https://patrickdearteaga.com

Special Thanks The Godot community The Python community Anthropic Claude (programming support) Google Gemini (portrait art support)

Thank you for reading and playing.