/*
@title: Rocket Launch
@author: Jeremy
@snapshot: 0.png
*/
// bt.setRandSeed(1)
////////// Imports
const random = bt.rand
// () => (x: number, y: number) => number
const { createNoise2D } = simplexNoise()
////////// Initialization
const width = 125
const height = 125
setDocDimensions(width, height)
const finalLines = []
////////// Main
const floorHeight = rr(0, 15)
const floorPolyline = [[0, floorHeight], [width, floorHeight]]
// finalLines.push(floorPolyline)
const groundGenerator = createNoise2D()
const groundLine = bt.iteratePoints(
bt.resample(structuredClone([floorPolyline]), 1),
current => {
const shift = noise(groundGenerator, current, 40) * 3 + 5
return [current[0], current[1] + shift]
}
)[0]
const groundBox = [
...groundLine,
[width, 0],
[0, 0],
[0, groundLine[0][1]],
]
finalLines.push(groundBox)
const floorPoint = [rr(80, 100), floorHeight]
// finalLines.push(circle(floorPoint, 1))
const outsideScreen = (
[x, y],
bufferLeft = 0,
bufferTop = bufferLeft,
bufferRight = bufferLeft,
bufferBottom = bufferTop
) => (
x <= bufferLeft ||
x >= width - bufferRight ||
y <= bufferBottom ||
y >= height - bufferTop
)
const pathResolution = 3
const targetPathLength = rr(70, 120) * pathResolution
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);
}