procedural-gen Checked

# Sum several octaves: each higher octave has higher frequency, lower amplitude.
def fbm(noise, x, y, octaves=5, lacunarity=2.0, gain=0.5):
    total, amp, freq, norm = 0.0, 1.0, 1.0, 0.0
    for _ in range(octaves):
        total += amp * noise(x * freq, y * freq)   # noise() returns ~0..1
        norm  += amp                                # track total amplitude
        amp   *= gain                               # each octave contributes less
        freq  *= lacunarity                         # ...at a higher frequency
    return total / norm                             # normalize back into 0..1

# Redistribute to carve flat valleys / sharpen peaks: higher exp -> more lowland.
elevation = pow(fbm(noise, nx, ny), 2.2)

Use a real noise library (FastNoiseLite, opensimplex,

Unity.Mathematics.noise, or Mathf.PerlinNoise) — do not implement gradient

noise yourself. Seed **elevation and moisture with different seeds** so a

biome lookup over both fields isn't perfectly correlated. Full biome lookup and

island shaping are in references/noise.md.

### 3. Weighted loot table (rarity-correct selection)

# Roll proportional to weight: common drops far more often than legendary.
def weighted_pick(rng, table):           # table: list of (item, weight)
    total = sum(w for _, w in table)
    roll = rng.uniform(0, total)          # a point on the cumulative line
    upto = 0.0
    for item, w in table:
        upto += w
        if roll < upto:                   # first bucket the roll falls into
            return item
    return table[-1][0]                   # float-safety fallback

loot = weighted_pick(rng, [("common", 70), ("rare", 25), ("legendary", 5)])

Weights need not sum to 100 — they are relative. To prevent bad streaks, use a

"pity"/bag system (see references/dungeon-generation.md notes on distributions).

### 4. Rooms-and-corridors dungeon (sketch)

# 1. Place non-overlapping rooms; 2. connect them; 3. carve into the grid.
rooms = []
for _ in range(attempts):
    r = Rect(rng.randint(1, W-w-1), rng.randint(1, H-h-1), w, h)
    if not any(r.intersects(o.expand(1)) for o in rooms):  # keep a 1-tile gap
        rooms.append(r)
for a, b in zip(rooms, rooms[1:]):       # connect each room to the next
    carve_l_corridor(grid, a.center, b.center, rng)   # horizontal then vertical

The complete generator (BSP partitioning, L-corridors, reachability check, and

random-walk caves) is in references/dungeon-generation.md.

Pitfalls

• **Using the global RNG** inside generation makes worlds unreproducible and

breaks the moment call order changes. Always pass a seeded instance.

• **Correlated noise fields**: sampling elevation and moisture from the *same*

seed/offset produces biomes that line up in bands. Offset or reseed each field.

• **Octave artifacts**: adding octaves without renormalizing pushes values out of

0..1; divide by the summed amplitude (and beware library output ranges — some

return -1..1, some 0..1).

• **No connectivity check**: rooms or caves can end up isolated. Flood-fill from

the spawn and discard/reconnect unreachable regions before play.

• **Unbounded placement loops**: "keep trying until N rooms fit" can spin forever

on a small grid. Cap attempts and accept fewer rooms.

• **Seeding once globally, then relying on frame timing**: any non-deterministic

input (time, physics, hash randomization) leaking into generation destroys

reproducibility.

References

• references/noise.md — octaves/lacunarity/gain, redistribution, island

shaping, two-axis biome lookup, blue-noise object scatter.

• references/dungeon-generation.md — BSP, rooms+corridors, random-walk caves,

cellular-automata smoothing, connectivity validation, distribution/pity tables.

Related skills

• godot-tilemap, unity-tilemap-2d — paint the generated grid into the engine.
• game-ai — pathfinding over the generated graph.
• level-design — pacing and hand-authored structure that procgen complements.
• roguelike, survival-crafting — genres that compose this skill.