Gist 7787a984f4735d812b642d776e9d5913

100%

Gist 7787a984f4735d812b642d776e9d5913

✓ Published0🌍 Public

Last edited Apr 9, 2017

Created on Apr 9, 2017

This example uses procedural generation to create a cave-like dungeon in Minecraft, starting from a random map of logs and bedrock and then applying cellular automata rules to smooth the layout. The code’s `generateDungeonArr` populates a 50x100 grid, `generateNewMap` iterates neighbor counts to refine the map over 20 generations, and `floodDungeon` recursively carves out connected regions. The final `renderDungeon` function places blocks in 3D space using Bukkit’s `org.bukkit.Material` API, positioning them relative to the player’s coordinates. The visualization highlights how algorithmic map generation and flood-fill logic combine to create playable cave structures.

AI-generated description

Similar vizzes

Loading thumbnail…

A random dungeon generator that fits on a business card

This example renders a procedurally generated dungeon map as ASCII art in a terminal, using a random cave-growing algorithm. It shows a 40-by-80 grid of wall and floor tiles, with occasional doorways, gold, and a starting position marked by `@`. The generator, written in C, uses the standard library’s `rand()` for all stochastic decisions, and draws its output via `printf` and `putchar`. The code fits on a business card, implementing the entire simulation in a single compressed source file.

FFrozenfire92

71% match

Loading thumbnail…

Gist c9bd662941bf0c774e47523b31df1177

This example shows a recursive flood-fill algorithm that triggers a chain of explosions across connected blocks in a Minecraft world. The code defines a `floodBoom` function that identifies the targeted block type and initiates a recursive spread through six cardinal directions. Using the Bukkit API, it calls `createExplosion` on the world object to detonate each matching block, while a depth counter limits recursion to 100 iterations. The `checkPower` helper caps the explosion radius at level 5, and the recursion continues only while encountering blocks identical to the original target.

44xDMG

67% match

Loading thumbnail…

Randomized Depth-First II

A maze is generated using randomized depth-first traversal, then flooded with color to reveal its structure. Hue encodes the Manhattan distance from the starting cell, making the maze’s branching patterns visually comparable. The animation is rendered on a Canvas 2D context, drawing cells and passages incrementally as the flood expands. The code uses D3’s `d3.timer` to drive the animation loop and `d3.hsl` to cycle hue over time, while a custom `generateMaze` function builds the maze and `fillRect` calls paint each cell and connecting corridor.

Mmbostock

66% match

Loading thumbnail…

Random Traversal II

A maze is generated by random traversal and then flooded with colored light. Hue encodes the Manhattan distance from the starting cell, creating a vibrant gradient that reveals the maze’s branching structure. The animation uses a canvas, with `d3.timer` driving the flood fill, while `context.fillRect` paints each cell and corridor. The maze itself is built from an edge-bit array, and the color progression cycles through the HSL spectrum via `d3.hsl`.

Mmbostock

62% match

Loading thumbnail…

Randomized Depth-First

A randomized depth-first traversal generates a maze on a black canvas, with the active frontier of possible extensions highlighted in magenta. The algorithm starts in the bottom-left corner and repeatedly pops a frontier edge, carving passages in random directions while ensuring no cycles form. It renders to a 2D canvas using `d3.v3` and a `d3.timer` loop, drawing cells and corridors as white rectangles and spacing gaps. Each step redraws affected cells and frontier edges, with a shuffle applied to the frontier array to randomize the next choice.

Mmbostock

61% match

Loading thumbnail…

Random Traversal

A black canvas displays a maze being generated cell by cell via a random traversal algorithm. White cells mark the growing maze structure, while magenta highlights the current frontier of possible extensions. The animation progresses in steps, using the Canvas API to draw rectangles for cells and connections. The code implements the algorithm with a frontier array and popRandom selection, using d3.v3's timer for animation control.

Mmbostock

61% match

Loading thumbnail…

Randomized Depth-First IV

A maze is generated on a 40x40 grid using a randomized depth-first traversal, then converted into a tree structure. The tree layout from D3 is applied to position the nodes, and SVG paths draw the links between parent and child nodes. The code uses `d3.layout.tree`, `d3.select`, and SVG path elements to render the final hierarchical visualization. The tree’s branching pattern visually reflects the maze’s corridors and dead ends, with each node representing a cell and each link a passage.

Mmbostock

60% match

Loading thumbnail…

Random Traversal IV

This example shows a tree layout applied to a recursively generated maze, producing a branching structure of connected cells. The maze is created using a randomized depth-first traversal that records edge connections, and the resulting tree is rendered as a set of black link paths. The code uses `d3.layout.tree` to compute node positions from the maze’s traversal tree, then draws each link as an SVG path with `M` and `L` commands. The visualization is built with D3 v3 and SVG, with the maze generation logic implemented in plain JavaScript.

Mmbostock

60% match