- name
>
SKILL.md
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill procedural-gen -a cursor -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill procedural-gen -a claude-code -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill procedural-gen -a codex -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill procedural-gen -a grok -ySend the copied message in a Grok Bot chat. The Bot fetches this SKILL.md from GitHub and adds it to the skills all your Bots share.
Install this skill: https://github.com/gamedev-skills/awesome-gamedev-agent-skills/tree/HEAD/skills/disciplines/procedural-genFrom the publisher
Generate levels, terrain and drops from rules and a seed. The property that matters most is
determinism: one seed reproduces one world, so bugs replay and players can share seeds.
This skill owns the algorithms and their validation; genre skills such as roguelike and
survival-crafting decide what to generate and when.
Not this skill: run structure, permadeath and meta-progression (roguelike), deck and card
pools (card-game), drawing tiles (godot-tilemap, unity-tilemap-2d), pathfinding over the
result (game-ai), hand-paced levels (level-design).
import random
rng = random.Random(seed) # a dedicated instance, never the module-level random.*
room_count = rng.randint(5, 12)
sub = random.Random(rng.getrandbits(64)) # derive a child stream per system or per chunk
Engine equivalents: Godot 4.7 var rng := RandomNumberGenerator.new(); rng.seed = s (save
rng.state to resume mid-sequence); Unity new Unity.Mathematics.Random(seed) (a non-zero
uint) or new System.Random(seed). Avoid UnityEngine.Random.InitState for generation: it
seeds the one global generator every other script also draws from. Derive child seeds per
system (layout, loot, decoration) so adding a decoration roll does not reshuffle the layout.
class SplitMix64:
"""Tiny PRNG whose sequence you own: same seed, same numbers, on every version."""
MASK = (1 << 64) - 1
def __init__(self, seed: int):
self.state = seed & self.MASK
def next_u64(self) -> int:
self.state = (self.state + 0x9E3779B97F4A7C15) & self.MASK
z = self.state
z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & self.MASK
z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & self.MASK
return z ^ (z >> 31)
def below(self, n: int) -> int: # 0 <= result < n, without modulo bias
limit = self.MASK - (self.MASK + 1) % n
while (x := self.next_u64()) > limit:
pass
return x % n
# Pin the first outputs in a test so a refactor cannot change every shared seed.
rng = SplitMix64(0)
assert [rng.next_u64() for _ in range(3)] == [
0xE220A8397B1DCDAF, 0x6E789E6AA1B965F4, 0x06C45D188009454F]
Use it when seeds must survive engine, runtime or library updates (daily challenges, seed-only
saves, cross-platform shared seeds). Port the same arithmetic to C# with ulong or to GDScript
with care: GDScript int is a signed 64-bit value, so mask shifts and compare as unsigned.
def weighted_pick(rng, table): # table: list of (item, weight); weights are relative
total = sum(w for _, w in table)
roll = rng.uniform(0, total)
upto = 0.0
for item, w in table:
upto += w
if roll < upto:
return item
return next(i for i, w in reversed(table) if w > 0) # roll == total (float edge)
Built-ins do the same: Python rng.choices(items, weights), Godot
rng.rand_weighted(PackedFloat32Array(weights)) (returns an index). Pure rolls produce streaks;
for a guaranteed rate use a bag or pity timer (references/dungeon-generation.md).
import hashlib, json, random, statistics
def sweep(generate, seeds=range(200), spawn=None):
"""generate(rng) -> grid (0 wall, 1 floor, solid border). Prints and returns a report."""
bad, ratios, digests = [], [], set()
for seed in seeds:
grid = generate(random.Random(seed))
if grid != generate(random.Random(seed)):
bad.append((seed, "not deterministic"))
continue
floor = [(x, y) for y, row in enumerate(grid) for x, v in enumerate(row) if v]
if not floor:
bad.append((seed, "no floor"))
continue
start = spawn(grid) if spawn else floor[0]
if len(reachable_floor(grid, start)) != len(floor): # from dungeon-generation.md
bad.append((seed, "unreachable floor"))
ratios.append(len(floor) / (len(grid) * len(grid[0])))
digests.add(hashlib.sha1(json.dumps(grid).encode()).hexdigest())
report = {"seeds": len(seeds), "failure_count": len(bad), "failures": bad[:10],
"distinct_maps": len(digests),
"floor_ratio": (min(ratios), statistics.median(ratios), max(ratios)) if ratios else None}
print(report)
return report
# report = sweep(lambda rng: drunkard(40, 30, rng)); raise SystemExit(report["failure_count"] > 0)
Run it twice in separate processes and compare the digests too: that catches hash-randomized
set order and other per-process state that a same-process rerun cannot see. Add the checks your
game needs (spawn not in a hazard, exit reachable, key before its door) as more bad.append
lines.
distinct_maps close to the
seed count (a low number means the seed is not reaching the generator).PYTHONHASHSEED differs per run by default) and confirm the
same digests for the same seeds.godot-gdscript-headless-testing) and print the same report.rng.choice(list(some_set))) changes order per
process because of hash randomization. Sort first.random() across
versions (not randint or choice), .NET says System.Random may change between major
versions, and Godot calls its PCG32 an implementation detail. Ship your own PRNG (Pattern 2)
or save the generated result instead of the seed.noise.snoise are about -1..1, Mathf.PerlinNoise about 0..1).noise(x, y) at whole tile coordinates is constant. Scale by a non-integer frequency;
FastNoiseLite applies its frequency (default 0.01) for you.references/dungeon-generation.md: read when implementing rooms and corridors, BSP,
drunkard's walk or cellular caves, wave function collapse, the reachable_floor flood fill,
or bag and pity distributions. Its Python is tested by the repo.references/noise.md: read when building terrain or biomes: frequency, octaves,
redistribution, ridges and terraces, two-field biome lookup, island shaping, scatter
placement, and seamless wraparound.roguelike, survival-crafting: genres that decide what to generate and when.level-design: authored pacing that generation complements, and the key-order check.godot-tilemap, unity-tilemap-2d: painting the grid; game-ai: pathfinding over it.save-systems: storing the seed and generator version, or the generated result.Last verified: 2026-11-11.
random: only random() is guaranteed to repeat across versions for a given seed
(https://docs.python.org/3/library/random.html#notes-on-reproducibility).System.Random: the algorithm may change between major versions
(https://learn.microsoft.com/en-us/dotnet/api/system.random).RandomNumberGenerator: PCG32 today, documented as an implementation detail;
rand_weighted exists; FastNoiseLite.frequency defaults to 0.01
(https://github.com/godotengine/godot/blob/4.7-stable/doc/classes/RandomNumberGenerator.xml).© 2026 Skills Rack.
---name: procedural-gendescription: >---# skills/disciplines/procedural-gen/SKILL.mdFAQ
Download skills/disciplines/procedural-gen/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
The publisher keeps it at https://github.com/gamedev-skills/awesome-gamedev-agent-skills.
Claude, Cursor, Codex, and Grok Build can read a SKILL.md you add from the publisher's repository. Grok Bot installs it when you send the skill's GitHub folder link in a chat.