📄 Cheat sheet — The Roguelike (your recipe)

In 1980, Rogue ran in a green terminal: a new dungeon every game, a death that erases everything. The whole genre fits in six bricks — and you have them all.

The history, in three lines

Year	What happened	What it brought
1980	Rogue on a green terminal	procedural dungeon + permadeath
80s	NetHack, ADOM…	same recipe, more depth
today	thousands of roguelikes	your recipe — lessons 1 to 9

The founding "detail": the party is not a level, it's a generator. You don't draw the dungeon — you write the rule that builds it.

The recipe: 6 bricks = 6 lessons

Brick	Lesson	The piece of code
the hero (state)	1 — objects	initialize + reader
the save (file)	2 — formats	to_yaml
the dungeon (grid)	3 + 8 — containers & map	Array.new + cells x,y
the loot (no duplicates)	3 — Set	Set.new(objets)
the monster (AI)	5 — the 4 ghosts	one step, one axis
the turn (rules)	7 + 8 — movement & collisions	case/when

Brick 1 — the hero (the object)

class Heros
  def initialize(pv)
    @pv = pv
  end
  def pv
    @pv
  end
end
Heros.new(20).pv   # => 20

The hero's life is stored state, never a global variable.

Brick 2 — the dungeon (an array of arrays)

def donjon(lignes, colonnes)
  Array.new(lignes) { Array.new(colonnes, ".") }
end
donjon(2, 3)   # => [[".", ".", "."], [".", ".", "."]]

The empty cell is "." — mine becomes #, yours whatever you want.

Brick 3 — the loot (Set) + the save (YAML)

Set.new(["epee", "epee", "potion"])   # => #<Set: {"epee", "potion"}>
{ "pv" => 20, "x" => 3 }.to_yaml      # => "---\npv: 20\nx: 3\n"

An inventory that refuses duplicates, a party that fits in a file — format and container, nothing more.

Brick 4 — the monster: the AI before AI

def chasse(pos, cible)
  dx = cible[0] <=> pos[0]
  dy = cible[1] <=> pos[1]
  dx != 0 ? [pos[0] + dx, pos[1]] : [pos[0], pos[1] + dy]
end
chasse([5, 5], [5, 2])   # => [5, 4]

No trajectory math, no machine learning: one step per turn, one axis at a time. (Pac-Man, also 1980 — lesson 5.)

Brick 5 — the turn: all the gameplay in one case

def tour(carte, x, y, dx, dy)
  cible = "#{x + dx},#{y + dy}"
  case carte[cible]
  when "mur"     then [x, y]        # facing a wall: I stay
  when "monstre" then :combat       # facing an enemy: I strike
  else [x + dx, y + dy]             # free cell: I advance
  end
end

A Hash read once per turn — walls, monsters, treasures: same question, same address.

Permadeath (the genre's paradox)

File.write("partie.yaml", sauvegarde(etat))   # saves
File.delete("partie.yaml")                     # dies → everything restarts

The difficulty comes from what gets erased, not what gets added.

Never say again

• "I need an engine / a dungeon generator" → a rule that fills an array of arrays
• "a monster AI" → an if on the distance, like in 1980
• "roguelikes are complicated" → six bricks, already written, in this course.

---

SlopCourse — from slop to clean code.