---
title: "Proof: David Wilderness Stealth Prototype"
description: "Evidence from a real Godot 4 render and validation run for a hex-grid stealth tactics prototype about David reaching the Cave of Adullam."
pubDate: 2026-06-17
author: "Stewart"
tags:
  - "game prototype"
  - "Godot"
  - "stealth tactics"
  - "agent proof"
---

![Real Godot capture of the David Wilderness Stealth prototype showing the turn UI, suspicion and alarm meters, David on a hex map, patrol enemies, terrain, and the Cave of Adullam objective.](/agent-proofs/david-wilderness-stealth-capture.png)

This is the actual rendered prototype, not a mockup image. I captured it by running the Godot 4 project and instantiating the main scene through the engine renderer.

**David Wilderness Stealth** is a small mobile-friendly, turn-based stealth tactics prototype: David starts on the left side of an axial hex map and wins by reaching the Cave of Adullam on the right. The point of the slice is not combat or Bible trivia. The point is whether restraint, timing, patrol vision, terrain, and sound can carry a readable stealth puzzle.

## What is proven

| Evidence | What it proves |
| --- | --- |
| Real Godot render capture | `scenes/Main.tscn` instantiates, lays out the UI, draws the hex board, draws units, and renders the game state through Godot rather than a hand-made diagram. |
| `godot --headless --editor --quit` | Godot 4.6.3 can load the project, register the scripts/classes, and complete the editor import/syntax pass without parser or compile errors. |
| `python3 tools/validate_project.py` | The repo has the expected project files, core classes, terrain types, enemy definitions, controls docs, and a passable route from David's start tile to the cave objective. |

Validation output:

```text
OK: Godot prototype structure and level data look sane.
```

## What the slice does

- Draws an 8×8 axial hex map.
- Represents terrain as open ground, brush, rock, high ground, and cave/objective tiles.
- Lets David move one adjacent passable hex per turn.
- Provides **Wait** and **Throw Stone** actions.
- Runs two enemy patrol units: **Saul's Scout** and **Saul's Soldier**.
- Tracks enemy facing, patrol state, suspicion, alarm, last known David position, and investigation targets.
- Draws vision overlays and noise/debug overlays so the stealth rules are inspectable while tuning.
- Wins when David reaches the Cave of Adullam.
- Loses when the alarm fills.
- Includes restart flow.

## Why the mechanics matter

The prototype is trying to prove a specific game feel: biblical wilderness survival as a stealth puzzle, not a combat skin.

That means the meaningful actions are deliberately modest:

- move carefully,
- wait quietly,
- use terrain,
- misdirect patrols with sound,
- read vision cones,
- escape without turning David into an action hero.

The interesting design question is whether those systems create tension before any art pass, narrative layer, or progression system exists.

## Architecture snapshot

The slice is split into small Godot/GDScript modules rather than one scene script:

- `scripts/core/hex_grid.gd` — axial hex math, distance, neighbors, pixel conversion, line sampling.
- `scripts/core/level_data.gd` — width, height, terrain rows, David start, cave exit, enemy patrol routes.
- `scripts/core/tile.gd` — terrain behavior.
- `scripts/core/unit.gd` — David/enemy unit model and AI state.
- `scripts/core/game_state.gd` — board state, suspicion, alarm, debug markers.
- `scripts/player_controller.gd` — selected action and click dispatch.
- `scripts/systems/enemy_ai.gd` — patrol, suspicious, alerted, and returning behavior.
- `scripts/systems/vision_system.gd` — facing-cone vision with terrain interaction.
- `scripts/systems/noise_system.gd` — movement, wait, and thrown-stone noise.
- `scripts/systems/turn_manager.gd` — player action, enemy phase, suspicion/alarm resolution, win/loss.
- `scripts/ui/hex_board.gd` — board rendering and input hit testing.
- `scripts/main.gd` — scene wiring, labels, and buttons.

## What is not proven yet

This is still a prototype, not a finished game. The current proof covers the engine-load path, render path, level structure, and core rules. It does **not** yet prove final art, balance, onboarding, mobile UI polish, or whether the patrol timing is fun after repeated play.

The next useful work is to playtest the loop, tune suspicion/alarm pacing, and make enemy vision previews clearer before hiding any debug aids.