Test the plan
Arrange the terrain, forces, formations, and opening intentions, then see how the complete setup behaves.
Diorama Battles
A planned iPad tactical battle builder for creating compact arenas, preparing fixed armies, and testing plans through automatic or high-level-command battles.
- Category
- Games & Simulations
- Platform
- iPadOS · planned
- Status
- Concept
What if a battle game began with a tactical hypothesis, not an economy?
Block-based battlefields, fixed forces, formations, group orders, several intervention styles, and rapid retries would make cause and effect easier to inspect.
User value
Build a tactical question. Run the battle. Change one thing.
The proposed experience turns preparation, observation, and revision into one compact battle loop without requiring an economy or constant unit control.
Command at group level
Work with units as formations and tactical groups instead of directing every soldier individually.
Revise quickly
Return from the result to an editable setup, change a meaningful condition, and try the battle again.
Features
The proposed tactical toolkit.
These capabilities belong to the documented concept. None is implemented in the current repository.
- 01
Compact battlefield editor
Place floors, walls, ramps, obstacles, spawn zones, and objectives in a bounded block-built arena.
- 02
Fixed-army preparation
Choose forces and equipment before combat without gathering resources, building production queues, or creating new units mid-battle.
- 03
Groups and formations
Organize units into named groups and arrange lines, columns, wedges, squares, or loose formations.
- 04
Battle plans
Assign opening intentions such as hold, advance, protect, prioritize, fall back, or enter later as a reserve.
- 05
Several levels of intervention
Use the same planned battle system for hands-off clashes, paused command rounds, live group commands, authored challenges, and local versus play.
- 06
Local saves and exchange
Save maps and complete battle setups locally, then exchange validated files or share codes without a required online service.
How it works
Prepare, observe, understand, revise.
The intended player journey keeps setup and replay close enough for one tactical change to remain legible.
- 01
Choose or build the arena
Start from a built-in battlefield or construct a compact space with terrain, spawn zones, and objectives.
- 02
Prepare both armies
Select fixed forces, equipment, placement, and any challenge constraints before the battle begins.
- 03
Create groups and formations
Turn individual units into readable tactical groups with named arrangements and roles.
- 04
Write the opening plan
Set group intentions, priorities, fallback points, guard relationships, timed actions, and reserves where supported.
- 05
Choose the command mode
Let the battle resolve automatically or permit paused or live group-level intervention.
- 06
Read the result and retry
Review the outcome, return to the setup, alter the map, army, formation, or plan, and run another experiment.
Product concept
A battle setup can be a tactical experiment.
The complete combination of terrain, fixed forces, formations, plans, mode rules, and victory conditions becomes the object a player builds and revises.
Tactics without an economy
Removing resource collection and production keeps attention on preparation, command, and the consequences of a plan.
The commander works with groups
Formations, objectives, priorities, and fallback points preserve tactical control without requiring individual micromanagement.
Observation is part of play
A result matters when the player can understand what changed, form a new hypothesis, and retry without a long recovery cycle.
Architecture
The intended system is one local battle pipeline.
The documented scope implies a self-contained Unity client, but no software architecture, schema, simulation model, or persistence implementation exists yet.
- 01Versioned battle setup
- 02Battlefield and import validation
- 03Army groups and formations
- 04Plan, mode, and victory rules
- 05Shared battle simulation
- 06Result and editable retry
One simulation, configurable intervention
Hands-off, paused-command, live-command, challenge, and local-versus modes are intended to configure one battle system rather than fork separate games.
Data before presentation
Maps, armies, equipment, formations, plans, mode rules, and victory conditions would need explicit versioned models before the renderer consumes them.
Local exchange needs hard boundaries
Offline files or share codes require schema validation, compatibility rules, migration policy, size limits, and safe failure for damaged or hostile input.
Simulation behavior remains unresolved
Pathfinding, formation keeping, automated targeting, opponent decisions, reproducibility, performance, and replay guarantees are not yet designed in technical detail.
Technology
Planned rather than implemented.
Target
- iPadOS landscape (planned)
- Touch-first interaction (planned)
- Target devices not selected
Application
- Unity (planned)
- Universal Render Pipeline (planned)
- Exact versions undecided
Battle system
- Group-level commands (planned)
- Data-driven modes (planned)
- Automated unit behavior unresolved
Local data
- Versioned saves (planned)
- JSON-style exchange (planned)
- Schemas and migrations not defined
Current evidence
- No source code
- No build
- No tests
- No performance measurements
- No runtime generative AI planned
Development
The product is documented, not implemented.
The repository defines the promise, core loop, pillars, non-goals, seven proposed modes, broad v0.9 scope, and release ladder. It contains no Unity project, source code, build, tests, prototype, media, or committed history, and its own product-definition milestone remains incomplete.
- Stage
- Concept
- Player-facing code
- None in repository
- Automated tests
- None
- Product media
- None
Documented so far
- Working title, one-sentence pitch, product promise, and iPad-first direction
- Core loop from battlefield construction through preparation, battle, result, and iteration
- Twelve design pillars and fifteen explicit non-goals
- Seven proposed modes with setup ownership, intervention rules, and acceptance criteria
- Broad v0.9 feature and content targets
- Milestone ladder from product definitions to a possible App Store submission
Next evidence
Complete the missing product and technical definitions, select the smallest playable slice, establish the Unity and iPad foundation, define versioned battle-setup data and import validation, then test one editor-to-battle-to-retry loop before expanding the mode or content scope.
Diorama Battles lab notes
The project, over time.
Notes about the thinking, architecture, development, and decisions behind this work.
Development notes for this project will begin here.