Delve

# Delve

This is a little **roguelike** I built in Rust. It runs entirely in the terminal:
no graphics, just coloured letters. You're the `@`, you climb down into a
randomly generated dungeon, fight the things that live there, grab whatever loot
you can, and try to get to the bottom before something eats you. It's twelve
floors deep. Getting there is the whole game.

The only dependency is [`crossterm`](https://crates.io/crates/crossterm) (for raw
terminal mode, colours and key input). **Everything else — the RNG, the map
generator, the field of view, the monster pathfinding, the save format — I wrote
myself.** That was the point: I wanted to actually understand every piece instead
of pulling in a crate for it.

## How a turn works

Delve is turn-based, and the loop is dead simple: **nothing moves until you do.**

1. You press a key → that becomes an `Action` (move, wait, pick up, descend, open
the inventory, …).
2. The game resolves your action. If you walked into a monster, that's an attack.
3. Then *every* monster takes its turn.
4. The field of view is recomputed from your new position, the screen is redrawn,
and it waits for your next key.

Because the world only advances on your input, you can sit and think for as long
as you like — which is very roguelike, and also means the whole thing costs zero
CPU while it waits.

## The pieces

**The dungeon (`mapgen.rs`).** Classic "rooms and corridors": I scatter up to 16
non-overlapping rectangular rooms, then connect each room to the previous one with
an L-shaped tunnel. Up-stairs go in the first room, down-stairs in the last. Every
floor is freshly generated, so no two runs are the same.

**Field of view (`fov.rs`).** You can only see what's near you; everything else is
dark (tiles you've seen before stay dimly remembered). I do it by shooting straight
**Bresenham lines** from the player out to every square on the edge of a box around
them, lighting up tiles until a ray hits a wall. It's not the fancy "shadowcasting"
algorithm everyone uses — I picked the version I could fully understand and it
looks great.

**Monsters that hunt you (`ai.rs` + `pathfind.rs`).** When a monster can see you it
doesn't just stumble around — it runs a real **A\*** search to route around walls
and close the distance. Lose line of sight and it goes back to idling. (The A\* has
a fun gotcha: Rust's `BinaryHeap` is a *max*-heap, but A\* wants the *cheapest* node
first, so I had to reverse the ordering. That bug — it kept expanding the worst
nodes — took me embarrassingly long to spot.)

**Fighting (`combat.rs`).** Simple and readable: roll the attacker's power with a
tiny bit of variance, subtract the defender's defense, and the rest is damage.
Weapons add power, armour adds defense. Kill things for XP, level up for more HP
and power.

**Loot (`items.rs` + `spawn.rs` + `inventory.rs`).** Potions (healing, permanent
strength, permanent max-HP), scrolls (teleport, magic mapping, lightning bolt,
enchant weapon), plus weapons and armour drawn from tables that scale with depth —
so the deeper you go, the better the gear you *might* find, and the nastier the
things guarding it.

**Difficulty curve.** Deeper floors spawn more monsters and meaner ones. The design
is deliberately lopsided: the dungeon always wins eventually. That's the joke the
whole game is built around.

**Saving (`save.rs`).** A save is really a **suspend** — the moment you load it, the
file is deleted, so you can't save-scum your way out of a bad decision. I also
hand-wrote the entire save/load format by hand (parsing and all) instead of reaching
for `serde`, just to prove to myself I could.

**Flavour (`flavor.rs`).** Every death, descent and kill pulls a random one-liner
from a little pool, so the log never reads the same way twice ("You delete the goblin
from the timeline. No undo."). Honestly the most fun part to write.