Page 1 of 1

ZunTzu: A Possible Evolution of the Project

Posted: 22 Aug 2026, 09:34
by maxfin
Recently, I found myself unable to use the computer and yet had some free time to think. I was subsequently able to get back to using it and tried some interesting experiments. I've tried to summarize the fruits of these reflections and experiments, as they relate to ZunTzu, in the following text:

ZunTzu: A Possible Evolution of the Project
Introduction

ZunTzu was built around a simple idea—one that remains remarkably valid today: reproduce the experience of playing a board game on a computer without turning the game into a computer game.

The map remains a map. The counters remain counters. Players move them, build stacks, roll dice, draw cards, and apply the rules just as they would around a physical table. The software provides the table and the tools needed to use it, but it does not attempt to replace either the players or the game's designer.

In my view, this philosophy is one of ZunTzu's greatest strengths and should remain at the heart of any future development.

In recent years, however, advances in artificial intelligence and software development have made it possible to imagine capabilities that would have been extremely difficult—or simply impossible—when ZunTzu was originally conceived.

The idea is not to abandon ZunTzu's original philosophy, but to extend it.

The goal could be to create a platform capable not only of reproducing a paper wargame digitally, but also of adding, on an optional basis, capabilities that the physical medium cannot provide, or can provide only through cumbersome procedures.

The result could be significant: making the enormous legacy of board wargames produced over the past sixty years more accessible, playable, and open to experimentation.

1. The Fundamental Principle: Preserve the Game

The project should begin with one non-negotiable principle:

ZunTzu should not turn a board wargame into a computer game.

The historical model, rules, tables, units, sequence of play, and design choices must remain those of the original game's designer.

The software should intervene primarily where the digital medium offers possibilities unavailable on the physical tabletop, or where it can free players from mechanical tasks without taking decisions away from them.

In other words:

Automate the workload, not the decisions.

Players should, of course, be able to choose how much automation they want. ZunTzu's traditional mode of play should remain available.

2. A Modular System

The new capabilities should not form a single mandatory system.

Each Game Box could specify which modules it supports, and players could choose which ones to activate whenever appropriate.

One game might use only ZunTzu's traditional features. Another might add Fog of War. Another might use both Fog of War and logistics. A more advanced Game Box might also contain a formalized description of its rules and support a digital assistant or opponent.

This modular approach would also allow the project itself to evolve gradually.

3. Fog of War

One of the inherent limitations of traditional wargaming is the difficulty of fully representing battlefield uncertainty.

Two players sitting across the same map inevitably know a great deal that the actual commanders would not have known.

Dummy counters, blocks, inverted counters, and other mechanisms have attempted to reduce this problem, but a digital environment makes a fundamentally different solution possible.

ZunTzu could maintain a true state of the battlefield while simultaneously showing each player only the perceived state available to that player.

An enemy unit might therefore be:

completely unknown;
detected but unidentified;
partially identified;
fully identified;
known only by its last observed position.

Reconnaissance, intelligence, and concealment could thus become genuine elements of play without requiring referees or cumbersome procedures.

4. Assisted Logistics

Logistics is another example of an essential aspect of warfare that many wargames are forced to represent in simplified form.

The problem is not merely one of simulation design. A detailed logistical model can impose so much bookkeeping on the player that it interferes with the enjoyment of the game.

A digital system could instead manage the production, accumulation, transportation, and consumption of supplies automatically.

The player would continue to make the important decisions: which fronts to prioritize, where to establish depots, which offensives to support, and which units can temporarily operate with fewer resources.

The computer would handle the calculations.

The system would need to be configurable because logistics cannot be represented in the same way in tactical, operational, and strategic games.

At the operational level, actual supply points might move through road, rail, and maritime networks. At the grand-strategic level, supply might instead be represented primarily as an economic cost of military operations.

5. Command and Control

Command could also be represented through a simple, optional module without introducing systems that fundamentally alter the original games.

Units could be assigned to headquarters and receive limited penalties—for example, reduced movement—when operating beyond their command range.

It should also be possible to change the assignment of units from one headquarters to another during play, according to the rules established by the individual Game Box.

The purpose would not be to simulate every detail of the chain of command, but to introduce, at relatively low cost, an element that is often absent from traditional games.

6. Multi-State Graphic Objects

The traditional front/back counter paradigm could be expanded through multi-state objects.

A counter could have not merely two sides, but an arbitrary number of representations:

Full Strength → Reduced → Disrupted → Exhausted

or:

Operational → Damaged → Heavily Damaged → Destroyed.

The same principle could apply to fortifications, airfields, installations, markers, cards, and other graphic elements.

It should also be possible to distinguish an object's primary state from independent attributes. A unit might simultaneously be reduced, out of supply, and already moved without requiring a separate graphic image for every possible combination.

7. A New Game Box Editor

The evolution of the system would require a more powerful visual editor for creating Game Boxes.

Maps, counter sheets, cards, and other components could be imported and configured graphically, reducing the need to edit XML files manually.

As far as possible, the editor should also support importing and updating existing Game Boxes.

Preserving the enormous amount of work already contributed by the community should be a priority.

8. From the Rulebook to a Rules Model

This could become the most important innovation in the entire project.

Modern AI models are capable of analyzing complex texts and transforming information expressed in natural language into organized structures.

We can therefore imagine a Hybrid Game Rules Editor.

The Game Box creator provides the original rulebook. The AI analyzes it and proposes a structured representation covering, for example:

sequence of play;
unit types and attributes;
movement;
terrain effects;
stacking;
zones of control;
combat;
tables and modifiers;
supply;
victory conditions;
special rules and exceptions.

The AI should not be treated as infallible.

Every proposed rule should be available for review, modification, or rejection by the Game Box creator and should, whenever possible, retain a reference to the section of the original rulebook from which it was derived.

The principle should be:

AI proposes — human validates.

The result would be a Rules Model: a representation formal enough to be interpreted by the computer, yet readable enough to be reviewed and corrected by a human being.

9. AI Teacher, Assistant, and Referee

Once a Rules Model exists, one of its first applications could be implemented even before attempting to create an artificial opponent.

ZunTzu could become a teacher of the game.

A new player could ask:

“What can I do during this phase?”

or:

“Why can't this unit cross this hexside?”

and receive an answer based on the actual situation on the map and the relevant rule.

Different levels of assistance could be offered:

Observer — intervenes only when asked.

Assistant — points out possible mistakes and omissions.

Tutor — actively explains the rules during play.

Referee — checks actions and, if requested, prevents illegal ones.

This could dramatically reduce one of the greatest barriers to entry in wargaming: the need to absorb lengthy and often complex rulebooks before being able to actually play.

10. A Digital Opponent

The next step would be to use the Rules Model to create an AI Opponent.

The AI would not need to handle every mechanical detail directly.

A deterministic engine could verify legal moves, calculate paths, apply modifiers, resolve combat tables, manage supply, and perform other procedures.

Artificial intelligence could instead focus on decisions:

assessing the situation;
defining objectives;
developing a plan;
concentrating forces;
managing reserves;
evaluating risks and opportunities.

The architecture could therefore separate:

Rules Engine — what is possible

from

AI Player — what is desirable.

This distinction would reduce errors, computational costs, and dependence on external AI models.

11. An Opponent Capable of Learning

The AI could also retain a memory of previous games.

It would not necessarily be necessary to continuously retrain a neural network. It might be sufficient to record positions, decisions, strategies, and results.

The AI could then learn which strategies produced good results and which consistently failed.

If the player wished, it could also adapt to that player's individual style.

A digital opponent could therefore do more than repeat a predefined set of procedures: it could gradually improve through experience.

12. AI vs. AI

Once an AI Player exists, both sides could be placed under computer control.

This would open two very different possibilities.

The first would simply be to watch a game being played.

The AIs could play at normal or accelerated speed and, when asked, explain their decisions.

An observer could pause the game and ask:

“Why did you abandon this position?”

or:

“What alternatives did you consider?”

The second possibility would be to use the game as an experimental tool.

Hundreds or thousands of games could be run automatically to study the distribution of outcomes.

Specific conditions could also be changed and the results compared:

Strategy A → 1,000 simulations

Strategy B → 1,000 simulations

Naturally, these results would not directly represent what would have happened in historical reality.

They would represent what happens within the historical model created by the wargame designer.

That distinction is essential, but it does not make the experiment any less interesting.

13. The Wargame as a Laboratory

This capability could provide a new way to explore the enormous intellectual legacy embodied in historical wargames.

Two games covering the same campaign may produce different results because they embody different judgments about mobility, logistics, force quality, command, or victory conditions.

Running large numbers of simulations could help make these differences visible.

The wargame could therefore become not only a game, but also a tool for exploring the consequences of the assumptions built into its model.

14. A Progressive Project

A vision of this scale should not be approached by attempting to build everything at once.

The project could proceed through successive stages.

Phase 1 — ZunTzu Enhanced

Modernize the digital tabletop, introduce a new graphic editor, Fog of War, multi-state objects, and initial optional features.

Phase 2 — ZunTzu Rules

Define the Rules Model, build the Hybrid Rules Editor, and introduce AI-assisted rulebook import.

Phase 3 — ZunTzu Assistant

Develop the Teacher, Assistant, and Referee functions, together with automation of the most cumbersome procedures.

Phase 4 — ZunTzu AI

Develop the digital opponent and game-memory capabilities.

Phase 5 — ZunTzu Simulation

Introduce AI-vs.-AI play, multiple simulations, replays, statistical analysis, and counterfactual experimentation.

Each phase should produce something useful in its own right. The success of the project should therefore not depend on immediately reaching the final stage.

15. Before Building: Prove the Concept

Before undertaking a major software project, it would be wise to build a limited proof of concept.

A wargame of moderate complexity could be selected, its rulebook provided to the AI, and an experiment conducted to determine whether a Rules Model can be created—with a reasonable amount of human intervention—that correctly represents at least:

movement;
terrain;
stacking;
zones of control;
combat;
sequence of play;
victory conditions.

The first objective should not be to create an AI capable of winning.

It should be much more modest and, at the same time, decisive:

Can a machine understand a rulebook written for human beings well enough to complete a legal game through a human-validated model of those rules?

If this experiment succeeds, one of the greatest uncertainties surrounding the entire project will have been resolved.

16. Why Start From ZunTzu?

A completely new system could, of course, be built.

But ZunTzu possesses something that would be difficult to recreate: a philosophy exceptionally well suited to this project, an existing and functional platform, a community of users, and, above all, a library of Game Boxes built over many years.

The goal should therefore not be to replace ZunTzu.

If technically possible, and if the community considers it worthwhile, the goal should be to continue and extend its original idea.

Compatibility with the existing legacy should be one of the project's primary objectives.

17. An Invitation to the Community

What has been described here is not yet a defined software project.

It is a proposal for discussion.

Some of these features are relatively straightforward. Others will require research, experimentation, and probably solutions that we cannot yet foresee.

Before writing large amounts of code, we need to determine whether the community considers this direction desirable, which features should have priority, and what skills and experience can be brought together.

Programmers would obviously be needed, but not programmers alone.

We would need wargame designers, Game Box creators, experienced players, interface designers, people familiar with artificial intelligence, and, above all, people willing to experiment and identify the cases in which the model fails.

It would be particularly valuable to discuss these ideas with Jérôme, because any evolution of ZunTzu should begin with an understanding of the design choices and philosophy that shaped the original program.

Conclusion

For decades, board wargaming has produced thousands of models of historical conflict, many of them of extraordinary depth.

Many are difficult to play today not because they have lost their value, but for very practical reasons: they require space, time, an available opponent, and the effort required to learn complex rules.

A new generation of ZunTzu could address all of these limitations at once:

the digital tabletop removes the problem of space;

the AI Opponent addresses the problem of finding an opponent;

the AI Teacher lowers the barrier to learning;

automation reduces the burden of procedures and bookkeeping;

Fog of War introduces something a shared physical tabletop cannot fully represent;

AI-vs.-AI simulation makes it possible to explore the model in entirely new ways.

Technology should not replace the wargame.

Instead, it could allow the wargame to finally do some of the things its designers have always wanted it to do, but which the physical tabletop, cardboard counters, and the players' available time made impractical.

If this idea proves technically feasible—and that is precisely what needs to be tested—it could offer ZunTzu not merely a new version, but a new reason to exist.

And it could offer the wargaming community something even more important: a way to carry the enormous legacy it has built in the past into the future.

Re: ZunTzu: A Possible Evolution of the Project

Posted: 22 Aug 2026, 09:43
by maxfin
## Proposed Technical Architecture and Development Path

### Preliminary Technical Paper for Community Discussion

## 1. Purpose of This Document

The previous paper, *ZunTzu: A Possible Evolution of the Project*, described a vision: extend ZunTzu while preserving its original philosophy, progressively adding true Fog of War, assisted logistics, multi-state objects, formalized rules understanding, player assistance, artificial opponents, and AI-vs.-AI simulation.

This second document addresses a different question:

**How could a system like this actually be implemented?**

It is not intended to propose a final architecture.

Many decisions will depend on the internal structure of the current ZunTzu codebase, the technologies ultimately selected, the skills available within the community, and the results of the first experiments.

The purpose here is instead to identify:

* the main subsystems;
* the information they need to exchange;
* what can be implemented using conventional deterministic software;
* what requires, or could benefit from, artificial intelligence;
* which components can run locally;
* which components may require external services;
* how compatibility with existing Game Boxes can be preserved;
* the main technical risks;
* and a prototyping path that can test feasibility before undertaking a large-scale development effort.

The general principle should be:

**Use AI where understanding and decision-making are required; use deterministic software wherever possible.**

---

# PART I — GENERAL ARCHITECTURE

## 2. Separating the Tabletop, the Rules, and the Intelligence

One possible architecture could be divided into five major components.

### A. Digital Tabletop Engine

This component manages what ZunTzu already represents:

* maps;
* counters;
* stacks;
* cards;
* dice;
* markers;
* zoom and navigation;
* interaction with game objects;
* multiplayer synchronization;
* saving and loading games.

The following capabilities could be added:

* multi-state objects;
* object attributes;
* Fog of War;
* multiple levels of visibility;
* private information for individual players;
* new visualization tools.

### B. Game Box Editor

This component defines the physical and graphical elements of the game:

* maps;
* counter sheets;
* cards;
* tables;
* objects;
* properties;
* states;
* zones;
* relationships between objects.

### C. Rules Engine

This component represents and executes the parts of the rulebook that can be formalized:

* sequence of play;
* movement;
* terrain;
* stacking;
* zones of control;
* combat;
* modifiers;
* supply;
* command;
* events;
* victory conditions.

### D. AI Services

These could include:

* AI-assisted rulebook interpretation;
* Rules Teacher;
* Rules Assistant;
* AI Player;
* planning;
* position analysis;
* explanation of decisions;
* game memory.

### E. Simulation Engine

This component would support:

* AI vs. AI;
* accelerated execution;
* multiple simulations;
* replay;
* branching;
* statistical data collection;
* comparison between scenarios.

These five components should communicate through clearly defined interfaces.

In particular, the AI should not manipulate graphics directly or arbitrarily alter the state of the game.

It should request an action from the Rules Engine, and the Rules Engine should determine whether that action is valid.

In simplified form:

**AI Player → proposed action → Rules Engine → validation → Game State → Tabletop**

---

# PART II — THE GAME STATE

## 3. A Single Structured Representation of the Game

To support automation, Fog of War, and AI, ZunTzu needs a structured representation of the current game state.

Each object should have at least one persistent identifier.

For example:

```text
Object ID: GER_4PZ_001
Type: Unit
Class: PanzerDivision
Owner: Germany
Position: Hex 2317
PrimaryState: Reduced
Moved: true
SupplyState: Low
ParentHQ: GER_PZGRP2
```

This representation does not replace the graphical counter.

The counter is the visual representation of the object.

The advantage is that the system can know what an object represents without having to interpret its image repeatedly.

## 4. Separating Game State from Graphic State

It is important to distinguish:

**Game State**

from

**Graphic State.**

For example:

```text
strength = reduced
supply = low
movement = used
visibility = detected
```

could be displayed graphically as:

* the Reduced side or state of the counter;
* a small Low Supply symbol;
* a Moved indicator;
* a different representation for the opposing player.

This avoids the need to create a separate image for every possible combination of conditions.

---

# PART III — MULTI-STATE OBJECTS

## 5. From Front/Back to N States

Each object could contain a set of states defined by the Game Box:

```text
states:
Full
Reduced
Disrupted
Eliminated
```

Each state could be associated with:

* an image;
* values;
* properties;
* available actions.

Transitions could be defined separately:

```text
Full -> Reduced
Reduced -> Eliminated
Full -> Disrupted
Disrupted -> Full
```

The system could support:

* advancing to the next state;
* returning to the previous state;
* direct state selection;
* automatic state changes triggered by a rule.

## 6. Independent Attributes

Some conditions should not be treated as primary states.

For example:

```text
Moved = yes/no
Supplied = yes/no
Disrupted = yes/no
Entrenched = yes/no
```

These attributes could be represented through:

* badges;
* symbols;
* overlays;
* borders;
* small integrated markers.

The Game Box Editor should allow the designer to choose how these are displayed.

---

# PART IV — FOG OF WAR

## 7. True State and Perceived State

The server or host should maintain the full true game state.

Each player would receive a filtered view.

Formally:

**True Game State → Visibility Filter → Player View**

Each object could have several visibility levels:

```text
0 = Unknown
1 = Contact
2 = Detected
3 = Partially Identified
4 = Fully Identified
```

The Game Box would define what information is available at each level.

For example:

**Contact**

shows only that something occupies the hex.

**Detected**

shows the general type.

**Partially Identified**

might reveal nationality and category.

**Fully Identified**

shows the actual counter.

## 8. Last Known Position

When contact with a unit is lost, the system could retain:

```text
LastKnownPosition
LastKnownState
LastSeenTurn
```

The map could then show the most recent known information without revealing the unit's current position.

## 9. Information Security

For true Fog of War, information a player is not supposed to know should preferably **not be transmitted to that player's client at all**, rather than merely being hidden graphically.

This would reduce both accidental disclosure and the possibility of extracting hidden information from memory, saved files, or network traffic.

---

# PART V — THE RULES MODEL

## 10. The Central Problem

The most experimental component of the entire project is the Rules Model.

A human rulebook contains:

* general rules;
* exceptions;
* definitions;
* procedures;
* tables;
* examples;
* notes;
* cross-references;
* special cases.

The system must transform at least part of this information into a formal representation.

It is not necessary, at least initially, to formalize every sentence.

What matters is formalizing what the computer needs in order to understand and verify play.

## 11. Rules Model Primitives

An initial vocabulary might include entities such as:

```text
GAME
PLAYER
SIDE

TURN
PHASE
STEP

MAP
SPACE
HEX
AREA
EDGE
TERRAIN

UNIT
MARKER
CARD
RESOURCE
HQ

ATTRIBUTE
STATE

ACTION
MOVE
ATTACK
FIRE
RETREAT
ADVANCE
TRACE
TRANSPORT

CONDITION
EFFECT
MODIFIER
EXCEPTION

TABLE
DIE
RESULT

OBJECTIVE
VICTORY_CONDITION
```

This list does not need to be final.

In fact, attempting to create a universal ontology for every wargame ever published from the outset would probably be a mistake.

The primitives should emerge progressively from the analysis of real games.

## 12. Rules as Conditions and Effects

A large number of rules can be represented in the form:

**IF conditions THEN effect**

For example:

```text
IF
unit.class = Armor
AND destination.terrain = Marsh
THEN
movement.allowed = false
```

with an exception:

```text
IF
unit.class = Armor
AND destination.terrain = Marsh
AND path.usesRoad = true
THEN
movement.allowed = true
```

The precedence between a general rule and its exception must be explicit.

## 13. Prefer Tables to Code Whenever Possible

Many wargame rules are naturally tabular.

For example:

| Unit Type | Clear | Woods | Mountain | Marsh |
| --------- | ----: | ----: | -------: | ----: |
| Infantry | 1 | 2 | 3 | 2 |
| Armor | 1 | 2 | 3 | X |

The editor should prefer this representation to a collection of separate conditional rules.

The same applies to:

* combat results tables;
* terrain effects charts;
* bombardment tables;
* weather;
* reinforcement schedules;
* replacement tables;
* victory point schedules.

---

# PART VI — THE HYBRID RULES EDITOR

## 14. Why "Hybrid"

It does not seem realistic to expect a purely graphical editor to represent every possible rule in every possible wargame.

On the other hand, requiring the Game Box creator to program the entire rulebook would eliminate much of the project's advantage.

The proposed solution is therefore a multi-level editor.

### Level 1 — Graphical Structures

For common rules:

* matrices;
* tables;
* properties;
* menus;
* checkboxes;
* sequence diagrams.

### Level 2 — Conditional Rules

A visual rule builder could allow something like:

```text
IF [unit type] IS [armor]
AND [terrain] IS [marsh]
THEN [movement] IS [prohibited]
```

### Level 3 — Scripting

For exceptional cases, a limited scripting language could be provided.

Scripting should be the last resort, not the normal way of creating a Game Box.

## 15. AI-Assisted Rulebook Import

The AI could analyze the rulebook PDF and propose the initial structure.

The process might be:

**Rulebook**

↓

**Text Extraction**

↓

**Section Classification**

↓

**Rule Extraction**

↓

**Entity Recognition**

↓

**Rules Model Proposal**

↓

**Human Validation**

The AI should classify text into at least:

```text
RULE
DEFINITION
EXCEPTION
PROCEDURE
EXAMPLE
DESIGN NOTE
HISTORICAL NOTE
STRATEGY ADVICE
```

## 16. Rule Provenance

Every extracted rule should retain its provenance:

```text
Source:
Rulebook
Section 7.3
Page 14
Paragraph 2
```

The user should be able to click a rule and immediately see the original passage.

This feature is essential for human verification.

## 17. Confidence

The AI could assign a confidence level:

```text
HIGH
MEDIUM
LOW
```

Low-confidence rules would be highlighted for review.

The AI should also identify:

* ambiguities;
* possible contradictions;
* unresolved references;
* unresolved exceptions.

## 18. No Silent Changes

One fundamental architectural rule should be:

**The AI never changes a validated Rules Model on its own.**

It may propose:

**Accept / Modify / Reject**

but the final decision belongs to the Game Box author.

---

# PART VII — RULE VALIDATION

## 19. Test Cases

The Rules Editor should allow the creation of test cases.

For example:

```text
TEST:
Armor enters Clear
EXPECTED:
Cost = 1 MP
```

or:

```text
TEST:
Armor enters Marsh without Road
EXPECTED:
Movement prohibited
```

After every change to the Rules Model, all tests could be rerun automatically.

This would make it possible to detect regressions.

## 20. AI-Generated Tests

The AI itself could propose tests based on the rules.

For example, if it finds:

```text
Armor cannot enter Marsh except along Roads
```

it could automatically generate:

1. Armor → Marsh → prohibited.
2. Armor → Marsh + Road → allowed.
3. Infantry → Marsh → verify general terrain rule.

The author could approve or correct these tests.

---

# PART VIII — RULES ASSISTANT AND TEACHER

## 21. The AI Should Not Answer Only from the PDF

Once the Rules Model has been validated, questions during play should be answered primarily using:

**Rules Model + Game State**

with the original rulebook used as a source for explanation and verification.

For example:

**Question**

“Why can't this unit move?”

The system might answer:

```text
Unit: 4th Panzer Division
Remaining MP: 2

Destination:
Woods

Cost:
2 MP

Additional river crossing:
+1 MP

Required:
3 MP

Result:
Movement not allowed.
```

and display the relevant rule reference.

## 22. Levels of Assistance

Possible modes could include:

```text
OFF
OBSERVER
ASSISTANT
TUTOR
REFEREE
```

The player therefore remains in control of the level of intervention.

---

# PART IX — LOGISTICS

## 23. A Configurable Logistics Engine

Logistics should be implemented as a service of the Rules Engine, not as a function of the AI.

The system might manage:

```text
SOURCE
DEPOT
TRANSPORT_NETWORK
CAPACITY
SUPPLY_POINT
CONSUMPTION
TRACE
INTERDICTION
```

The Game Box would define which elements are used.

## 24. Logistics Pathfinding

The problem can be treated as a network.

Hexes or nodes are vertices; roads, railroads, and sea connections are edges with:

* cost;
* capacity;
* status;
* possible interdiction.

The engine could then calculate routes and capacities using conventional algorithms.

No LLM is needed to determine whether a railroad can carry 20 supply points.

## 25. Human Decision, Automatic Calculation

The system should avoid choosing priorities automatically unless the side is under AI control.

A human player might declare:

```text
Army Group North: priority 3
Army Group Center: priority 5
Army Group South: priority 2
```

The engine would distribute resources according to those decisions and the game's rules.

---

# PART X — THE AI PLAYER

## 26. Separate Strategy from Execution

One mistake would be to ask a language model:

**“Play the turn.”**

The number of possible moves can be enormous.

A hierarchical structure would be preferable.

### Strategic Level

The AI determines:

```text
Main objective
Secondary objectives
Risk tolerance
Reserve policy
Supply priorities
```

### Operational Level

It divides the plan by:

* sectors;
* armies;
* groups of units;
* local objectives.

### Tactical Level

The engine generates legal actions and selects those consistent with the plan.

This avoids requiring the AI to consider every possible move of every counter simultaneously.

## 27. Action Generation

The Rules Engine should be able to answer requests such as:

```text
GetLegalMoves(unit)
GetLegalAttacks(unit)
GetReachableHexes(unit)
GetPossibleTargets(unit)
```

The AI then chooses among actions that are already known to be legal.

This greatly reduces the risk of rule-related hallucinations.

## 28. Evaluation Function

Choosing among alternative positions requires some form of evaluation.

It could combine general elements such as:

```text
Victory Points
Force Preservation
Terrain Value
Supply
Cohesion
Objective Control
Enemy Threat
Reserve Strength
```

with game-specific parameters.

The AI could contribute to strategic evaluation, while numerical values are calculated deterministically.

---

# PART XI — MEMORY AND LEARNING

## 29. Game Log

Every game should generate a structured log:

```text
Turn
Phase
Game State
Action
Decision
Evaluation
Result
```

This would support:

* replay;
* debugging;
* analysis;
* learning;
* statistical simulation.

## 30. Learning Without Retraining

There is no need to begin by continuously retraining neural networks.

The system could retain:

* openings;
* strategies;
* results;
* mistakes;
* critical positions.

When it encounters similar situations, it could retrieve previous experience.

More advanced techniques could be explored later.

---

# PART XII — AI VS. AI AND SIMULATION

## 31. The Same Engine for Both Players

If the AI Player can control one side, the same interface can control the other.

The Simulation Engine could therefore execute:

```text
while game_not_finished:
player_A.take_turn()
player_B.take_turn()
```

The Rules Engine remains the authority on legal actions.

## 32. Execution Modes

Possible modes could include:

```text
NORMAL
FAST
VERY FAST
HEADLESS
```

HEADLESS mode would not need to render graphics continuously and could therefore run simulations much faster.

## 33. Monte Carlo and Scenario Testing

A given starting position could be run many times with changes to:

* random results;
* strategies;
* priorities;
* parameters;
* decisions.

Results could be recorded as:

```text
Win rate
Victory Points
Casualties
Territory
Objective capture dates
Game duration
```

---

# PART XIII — BRANCHING AND COUNTERFACTUALS

## 34. Snapshots

The Game State should be savable at any time as a snapshot.

Multiple branches could then be created from a single snapshot:

```text
Turn 8
|
+-- Strategy A
|
+-- Strategy B
```

Both could be simulated independently.

This would make it possible to compare different decisions starting from exactly the same situation.

---

# PART XIV — LOCAL, CLOUD, AND AI COSTS

## 35. Not Everything Should Use AI

The following should normally run locally:

* rendering;
* movement;
* stacking;
* pathfinding;
* combat tables;
* tables in general;
* supply;
* validation;
* Game State;
* replay;
* deterministic simulations.

AI should be used mainly for:

* initial rulebook interpretation;
* natural-language questions;
* planning;
* explanation;
* complex strategic evaluation.

## 36. Reduce Model Calls

An AI Player should not query a large model after every single movement.

Instead, it could:

1. analyze the position;
2. formulate a plan;
3. allow the engine to execute many operations;
4. reassess after a significant event.

This would reduce:

* cost;
* latency;
* dependence on an Internet connection;
* variability.

## 37. Local Models

In the future, some tasks could be assigned to smaller local models.

The architecture should therefore avoid rigid dependence on any single AI provider.

An **AI Provider Interface** would be preferable, allowing different services or local models to be substituted.

---

# PART XV — GAME BOX FORMAT

## 38. Compatibility

A new format could be designed as an extension of the existing Game Box.

Ideally:

```text
Traditional Game Box
+
Optional Metadata
+
Optional Rules Model
+
Optional AI Profile
```

An old Game Box should continue to work.

A new one might declare:

```text
Features:
FogOfWar = true
MultiState = true
RulesModel = true
Logistics = false
AIPlayer = true
```

## 39. Versioning

The Rules Model should be versioned.

For example:

```text
GameBoxVersion: 2.1
RulesModelVersion: 1.4
```

Saved games should record the version used so that results remain reproducible.

---

# PART XVI — NETWORKING

## 40. Authoritative Server

For multiplayer and Fog of War, it would be desirable for an authoritative component to maintain the True Game State.

Clients would receive only the information they are entitled to know.

This component could run on:

* one player's computer;
* a dedicated server;
* possibly a remote service.

The architecture should support multiple configurations without requiring a permanent central server.

---

# PART XVII — REPRODUCIBILITY

## 41. Random Seed

For simulations and debugging, the random-number seed should be recordable.

The same game could then be reproduced exactly.

This is particularly important when comparing different strategies.

## 42. Decision Log

AI decisions should also be recorded.

Not necessarily the model's full internal reasoning, but at least:

```text
Objective selected
Alternatives considered
Action chosen
Evaluation score
```

This would make it possible to understand and compare AI behavior.

---

# PART XVIII — MAIN TECHNICAL RISKS

## 43. Risk 1 — The Rules Model Becomes Too Complex

The greatest risk would be trying to create, from the beginning, a language capable of representing every wargame ever published.

The strategy should be the opposite:

**Build the model from real games.**

## 44. Risk 2 — Incorrect AI Interpretation

The AI may misunderstand:

* exceptions;
* references;
* precedence;
* implicit rules.

Countermeasures include:

* provenance;
* confidence levels;
* human validation;
* test cases;
* regression testing.

## 45. Risk 3 — The AI Plays Legally but Poorly

Knowing the rules does not mean knowing how to play well.

AI Player quality should be treated as a separate problem.

The first milestone should be:

**legal play**

then:

**reasonable play**

and only later:

**strong play.**

## 46. Risk 4 — Excessive Scope

The complete project contains many complex subsystems.

It should therefore be developed modularly, and each phase should produce useful results independently of later phases.

---

# PART XIX — PROOF OF CONCEPT

## 47. The First Experiment

Before making major changes to ZunTzu, it would be wise to build an extremely limited, independent prototype.

The prototype might include:

* a small hex map;
* 20–50 units;
* a few terrain types;
* movement;
* zones of control;
* stacking;
* one combat results table;
* victory conditions;
* a real rulebook.

## 48. Experiment A — Rulebook → Rules Model

The AI receives the rulebook.

It produces an initial structure.

A human reviews it.

The key metric is:

**How much human work is required to obtain a correct model?**

If formalizing a game requires nearly as much work as programming it manually, the concept loses much of its value.

If, on the other hand, the AI can produce a largely correct foundation that the human mainly reviews and corrects, the project becomes far more promising.

## 49. Experiment B — Rules Model → Legal Play

The system must be able to complete a game without violating the formalized rules.

At this stage, it does not matter if the strategic decisions are mediocre.

## 50. Experiment C — AI Player

Only after the first two experiments should strategic planning be introduced.

The question then becomes:

**Can the AI use the legal actions generated by the Rules Engine to play a reasonable game?**

---

# PART XX — SELECTING TEST GAMES

## 51. More Than One Game

After the first prototype, a small set of different games should be selected.

For example:

* one tactical game;
* one operational game;
* one strategic game;
* one naval game;
* one card- or event-driven game.

The purpose would not be to implement all of them completely.

They would serve to test whether the Rules Model primitives are sufficiently general.

Whenever a rule cannot be represented, the model is extended.

---

# PART XXI — A POSSIBLE DEVELOPMENT PATH

## 52. Stage 0 — Technical Investigation

Before making any major decision:

* examine the current ZunTzu codebase;
* document its architecture;
* identify reusable components;
* review dependencies and technologies;
* study the Game Box format;
* evaluate future compatibility.

## 53. Stage 1 — Experimental Rules Engine

Build an independent prototype.

No polished interface is required.

Objective:

**Prove that the Rules Model works.**

## 54. Stage 2 — Hybrid Rules Editor

Build a minimal editor capable of:

* displaying rules;
* modifying them;
* linking them to their source;
* running tests.

## 55. Stage 3 — Tabletop Integration

Integrate the Rules Engine with an actual position on the map.

## 56. Stage 4 — Assistant

Implement:

* move validation;
* Rules Assistant;
* Tutor;
* Referee.

This alone would already be a useful result even without an AI opponent.

## 57. Stage 5 — AI Player Prototype

Build the first artificial opponent.

## 58. Stage 6 — Advanced Systems

Only afterward:

* advanced Fog of War;
* general logistics;
* memory;
* AI vs. AI;
* multiple simulations;
* branching;
* statistical analysis.

---

# PART XXII — PROJECT ORGANIZATION

## 59. Skills Required

A project of this kind would gradually require several different areas of expertise.

**Core Development**

* software architecture;
* graphics;
* networking;
* persistence.

**Rules Engine**

* data modeling;
* algorithms;
* declarative languages.

**AI**

* LLM integration;
* retrieval;
* structured output;
* planning.

**Wargame Domain**

* designers;
* experienced players;
* Game Box creators.

**Testing**

* rule verification;
* scenarios;
* regression testing.

The ZunTzu community already possesses part of the most valuable expertise required: knowledge of the games themselves and experience creating Game Boxes.

## 60. Open Architecture

It would be desirable for:

* the Rules Model to be documented;
* the Game Box format to remain open;
* the main internal APIs to be clearly defined;
* external tools to be able to interact with the system;
* AI providers to be replaceable.

This would reduce dependence on individual technologies and make community contributions easier.

---

# PART XXIII — THE MOST IMPORTANT QUESTION

## 61. How Much Does ZunTzu Need to "Know"?

Not every Game Box needs to become fully automated.

Different levels could exist.

### Level 0 — Digital Tabletop

Traditional ZunTzu.

### Level 1 — Enhanced Objects

Multi-state objects, attributes, Fog of War.

### Level 2 — Rules Aware

The system understands part of the rules and can provide assistance.

### Level 3 — Rules Enforced

The Rules Engine can validate most actions.

### Level 4 — AI Playable

The game contains enough information to be played by the AI.

### Level 5 — Simulation Ready

The game is sufficiently formalized and validated for repeatable AI-vs.-AI simulation.

Not every Game Box needs to reach Level 5.

This is important both technically and philosophically, because it preserves ZunTzu's original character.

---

# PART XXIV — CONCLUSION

The hardest part of this proposal is not Fog of War, networking, pathfinding, or logistics.

These are significant software problems, but they are known problems.

The true experimental challenge is the transition:

**Human Rulebook → Verifiable Rules Model → Machine Behavior.**

That is where the first research effort should be concentrated.

If this transition requires manually programming every individual game, the project remains possible, but much of its ability to unlock the huge existing library of wargames would be lost.

If, on the other hand, artificial intelligence can perform a substantial part of the interpretation and formalization work, leaving humans primarily responsible for reviewing, correcting, and approving the result, the economics of the problem change dramatically.

At that point, it becomes possible to imagine a library of **intelligent Game Boxes** that preserve the original games while progressively adding:

* true Fog of War;
* automated procedure management;
* logistics;
* rules checking;
* interactive teaching;
* artificial opponents;
* AI vs. AI;
* multiple simulation runs;
* counterfactual analysis.

The project should therefore begin not by asking:

**“How do we build all of this?”**

but by asking a much more precise question:

**“What is the smallest experiment that can prove or disprove the core hypothesis?”**

The proposal is to build that proof of concept before making any major commitment of time or money.

If it works, we will have more than a stronger technical specification.

We will have evidence that the vision described in the general proposal can actually become a working system.

Re: ZunTzu: A Possible Evolution of the Project

Posted: 22 Aug 2026, 10:05
by maxfin
# ZunTzu Development — Step 1

## The Graphical Game Box Editor

### 1. Objective

The first proposed step in ZunTzu's development is the creation of a **graphical Game Box Editor**.

This is an intentionally cautious choice. Before making deep changes to the ZunTzu engine or tackling more experimental features, it makes sense to build a tool that is useful on its own, technically limited in scope, and easy to validate.

At present, creating a Game Box requires preparing the graphic assets and manually defining the structure through XML files. This system is powerful, but it makes both creation and especially modification of Game Boxes more difficult than necessary.

The purpose of the editor is to replace much of this work with a visual interface.

The fundamental principle is:

**Anything that is currently described in XML should, whenever possible, be definable graphically.**

---

## 2. What We Already Know from the Source Code

A first analysis of the original ZunTzu source code has already been carried out.

The program is written primarily in **C#**, with some native C/C++ components, and relies on several technologies and libraries that are now considered legacy.

The reverse engineering work has already identified a number of key classes in the model, including:

```text
Game
Board
Map
Piece
Stack
Counter
Card
CounterSheet
CounterSection
TerrainPrototype
```

A simplified conceptual chain has also been reconstructed:

```text
Game Box
↓
Game
↓
CounterSheet
↓
CounterSection
↓
Piece
↓
Stack
```

In particular, `CounterSection` participates in the concrete creation of the counters defined in the Game Box, while `Game` plays a central role in building and reconstructing the state of a game.

This initial analysis suggests that ZunTzu's format and internal model are structured enough to make an external editor technically plausible.

---

## 3. First Goal: Full Compatibility

The first version of the editor **should not require a new version of ZunTzu**.

Its target should be:

```text
Graphical Editor
↓
Standard Game Box
↓
Current ZunTzu
```

A Game Box created with the editor should open in the current ZunTzu exactly like a Game Box created manually.

This also gives us a very simple validation criterion:

> Create a Game Box without manually editing XML, export it, and use it in the current version of ZunTzu.

---

## 4. Features of the First Version

The editor should at least be able to:

* create a new project;
* open an existing Game Box;
* import graphic assets;
* define maps;
* define counter sheets;
* identify individual counters graphically;
* associate front and back sides;
* define cards and markers;
* set the properties supported by the current format;
* validate the configuration;
* build the final Game Box.

Counter definition is particularly well suited to a graphical interface.

Instead of entering coordinates and dimensions manually, the user should be able to open the counter sheet and draw the areas corresponding to individual counters directly on the image.

When a counter sheet follows a regular layout, the editor could also generate a grid automatically, leaving the user only to correct exceptions.

---

## 5. Import, Not Just Creation

The ability to open existing Game Boxes is essential.

Over the years, the ZunTzu community has created a substantial body of work that should not be abandoned.

The ideal workflow should therefore be:

```text
Existing Game Box
↓
Import
↓
Graphical Editing
↓
Export
↓
ZunTzu
```

This would also make it possible to use the editor to progressively upgrade older Game Boxes as new capabilities are introduced.

---

## 6. Separate the Model from the Interface

The editor should not modify XML directly while the user is working.

A preferable architecture would be:

```text
Game Box file
↓
Parser
↓
Internal Game Box Model
↓
Graphical Editor
↓
Validator
↓
Serializer
↓
Game Box file
```

This separation is important because the internal model can later be extended without requiring a complete redesign of the application.

---

## 7. Prepare for the Future Without Complicating the First Version

The first version must generate Game Boxes fully compatible with the current ZunTzu.

However, the editor architecture should already anticipate the future introduction of:

* multi-state objects;
* attributes;
* Fog of War;
* command and control;
* logistics;
* a Rules Model.

These features **do not need to be implemented immediately**.

The only requirement at this stage is to avoid architectural decisions that would make them difficult to add later.

---

## 8. First Milestone

The first true milestone of the new ZunTzu development effort can therefore be defined very concretely:

> **Open an existing Game Box, display its maps and counter sheets graphically, modify at least part of its configuration, export it, and reopen it correctly in the current ZunTzu.**

This is a relatively modest objective compared with the overall vision.

But it is also the right place to begin.

It immediately produces a useful tool, validates our understanding of the Game Box format, and creates the foundation on which all later extensions can be built.

Re: ZunTzu: A Possible Evolution of the Project

Posted: 05 Sep 2026, 01:11
by Chobham_1980A
Hi ZT Folk!

Max has done his thing - he has developed his ideas into an actual computerized program :D :) :idea:

Max has asked the "ZT Master fellows" in testing the program in a Beta 2 enviroment.

These fellows are expert ZT designers, many of which have submitted ZTBs to our site.

Please see the "technical support'' section for more information: under the name "ZT Editor."