lot

File*
animate
Docs
Download
What do I make?
log in to save
Machine control
/*
@title: eca
@author: henry
@snapshot: eca1.png
*/

setDocDimensions(125, 125);

const t = new bt.Turtle();

const w = 50

let genStart = Array(w).fill(0)
genStart = genStart.map(() => Math.round(Math.random()))
genStart[w / 2] = 1

t.goTo([0, 0])

let rule = toBits(Math.floor(Math.random() * 255), 8)
let allGens = [genStart]

function toBits(num, overhead) {
let bits = num.toString(2)
return ('0'.repeat(overhead - bits.length) + bits).split('').map(s => {
return parseInt(s)
})
}

function nextGen(prev, gen) {
let nextGen = []
for (let i = 0; i < prev.length; i++) {
for (let state = 0; state < 8; state++) {
let bits = toBits(state, 3)
let l = i <= 1 ? 0 : prev[i - 1]
let c = prev[i]
let r = i >= prev.length - 1 ? 0 : prev[i + 1]
if (c == bits[1] && l == bits[0] && r == bits[2]) {
nextGen.push(rule[8 - state - 1])
break
}
}
}
return nextGen
}

function goTo(pos) {
t.goTo([pos[0] * 0.2, pos[1] * 0.2])
}

function drawGen(arr, y) {
let prevGen = allGens[-y]
for (let x = 0; x < arr.length; x++) {
arr[x] ? t.down() : t.up()
if (arr[x]) {
t.up()
goTo([x, y])
t.down()
if (prevGen[x] == 1) goTo([x, y + 1.0])
goTo([x, y])
if (prevGen[x - 1] == 1) goTo([x - 1.0, y + 1.0])
goTo([x, y])
if (prevGen[x + 1] == 1) goTo([x + 1.0, y + 1.0])
goTo([x, y])
if (arr[x - 1] == 1) goTo([x - 1, y])
goTo([x, y])
}
t.up()
}
t.up()
goTo([w, y - 1])
t.down()
}

for (let gen = 0; gen < w * 2; gen++) {
allGens.push(nextGen(allGens[gen], gen))
drawGen(allGens[gen + 1], -gen)
}

const bb = () => bt.bounds(t.path);
bt.scale(t.path, 110/bb().height);
bt.translate(t.path, [125/2, 125/2], bb().cc);

drawLines(t.lines());

ToolkitClose Help

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 // boolean
bt.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);
}