/*
@title: Maze Generator
@author: Xavier Choe
@snapshot: snapshot1.png
*/
//Generates a random maze using a Depth-First Search (DFS)
//Parameters
const rows = 30;
const cols = 30;
const cellSize = 5;
//Initialize the Document
const border = cellSize * 5;
const width = cols * cellSize + 2*border;
const height = rows * cellSize + 2*border;
setDocDimensions(width, height);
//Initialize the maze grid
const grid = [];
for (let i = 0; i < rows; i++) {
grid[i] = [];
for (let j = 0; j < cols; j++) {
grid[i][j] = {
x: j, // X-coordinate of the cell
y: i, // Y-coordinate of the cell
walls: [true, true, true, true], // Top, Right, Bottom, Left
visited: false // Whether the cell has been visited
};
}
}
// Create a stack for the DFS
const stack = [];
// Directions: [dx, dy] for top, right, bottom, left
const directions = [
[0, -1], // top
[1, 0], // right
[0, 1], // bottom
[-1, 0] // left
];
// Start at the first cell
let currentCell = grid[0][0];
currentCell.visited = true;
stack.push(currentCell);
// Function to remove walls between two cells
function removeWall(cell1, cell2) {
const x = cell1.x - cell2.x;
const y = cell1.y - cell2.y;
if (x === 1) {
cell1.walls[3] = false; // Remove left wall of cell1
cell2.walls[1] = false; // Remove right wall of cell2
} else if (x === -1) {
The Toolkit
This is a quick reference sheet. For full documentation refer to this.
For an introduction to Blot check out this guide.
Check out our 38 second trailer for a brief overview of the whole Blot project.
There are three names that provide functionality available in the Blot editor:
setDocDimensions, drawLines, and blotToolkit (which can also be referenced as bt).
The first two affect the drawing environment itself, and the blotToolkit is used for creating line drawings.
Environment Affecting
setDocDimensions(width: number, height: number)
drawLines(polylines: [number, number][][])Modify Polylines
Take and modify polylines in place returns first passed polylines.
These functions are available in the blotToolkit or bt object.
bt.iteratePoints(polylines, (pt, t) => { ... }) // return pt to modify, "BREAK" to split, "REMOVE" to filter out point
bt.scale(polylines, scale : scaleXY | [scaleX, scaleY], ?origin: [ x, y ])
bt.rotate(polylines, degrees, ?origin: [ x, y ])
bt.translate(polylines, [dx, dy], ?origin: [ x, y ])
bt.originate(polylines) // moves center to [0, 0]
bt.resample(polylines, sampleRate)
bt.simplify(polylines, tolerance)
bt.trim(polylines, tStart, tEnd)
bt.merge(polylines)
bt.join(polylines0, ...morePolylines)
bt.copy(polylines)
bt.cut(polylines0, polylines1)
bt.cover(polylines0, polylines1)
bt.union(polylines0, polylines1)
bt.difference(polylines0, polylines1)
bt.intersection(polylines0, polylines1)
bt.xor(polylines0, polylines1)
bt.offset(polylines, delta, ?ops = { endType, joinType, miterLimit, arcTolerance })Get Data From Polylines
These functions are available in the blotToolkit or bt object.
// take polylines return other
bt.getAngle(polylines, t: [0 to 1]) // returns angle in degrees
bt.getPoint(polylines, t: [0 to 1]) // returns point as [x, y]
bt.getNormal(polylines, t: [0 to 1]) // returns normal vector as [x, y]
bt.pointInside(polylines, pt)
bt.bounds(polylines)
/*
returns {
xMin, xMax,
yMin, yMax,
lt, ct, rt,
lc, cc, rc,
lb, cb, rb,
width, height
}
l is left
c is center
r is right
t is top
b is bottom
they are arranged in this configuration around the bounding box of the polylines
lt--ct--rt
| | |
lc--cc--rc
| | |
lb--cb--rb
*/Generate Polylines
These functions are available in the blotToolkit or bt object.
const myTurtle = new bt.Turtle()
.forward(distance: number)
.arc(angle: number, radius: number)
.goTo( [ x: number, y: number ] ) // move with up/down state
.jump( [ x: number, y: number ] ) // move but don't draw
.step( [ dx: number, dy: number ] ) // add delta to turtles current position
.right(angle: number)
.left(angle: number)
.setAngle(angle: number)
.up() // sets drawing to false
.down() // sets drawing to true
.copy()
.applyToPath(fn) // takes (turtlePath) => { }
.lines() // get copy of the Turtle's path
// data
const position = myTurtle.pos // [x: number, y: number]
const angle = myTurtle.angle // number
const path = myTurtle.path // is array of polylines [number, number][][]
const drawing = myTurtle.drawing // booleanbt.catmullRom(points, ?steps = 1000) // returns polyline [number, number][]
bt.nurbs(points, ?ops = { steps: 100, degree: 2}) // returns polyline [number, number][]Randomness
These functions are available in the blotToolkit or bt object.
bt.rand();
bt.randInRange(min: number, max: number);
bt.randIntInRange(min: number, max: number);
bt.setRandSeed(seed: number);
bt.noise(
number | [ x:number , ?y: number , ?z: number ],
{
octaves: number [0 to 8],
falloff: number [0 to 100]
}
);Idioms
These are small useful code snippets.
function centerPolylines(polylines, documentWidth, documentHeight) {
const cc = bt.bounds(polylines).cc;
bt.translate(polylines, [documentWidth / 2, documentHeight / 2], cc);
}