Snippet Zone

Responsive Radial Gradient Animation

function rect(x1, y1, x2, y2, col, blur=.1) {

```
  const dx = x1 - x2;
```
```
  const dy = y1 - y2;
```

  const dist = Math.sqrt(dx * dx + dy * dy);

  return `radial-gradient(circle at ${x1}% ${y1}%, ${col} 0, ${col} ${dist}%, transparent ${dist +

```
    blur}%)`;
```
```
}
```
```
 
```
```
const NUM = 8; 
```
```
 
```
```
let rects = [];
```

const colors = ['rgba(0, 0, 0, 0.2)', 'white', 'black'];

```
 
```
```
let x = 0;
```
```
let y = 0;
```
```
let t = 8;
```
```
function loop() { 
```
```
  rects = [];
```
```
 
```
```
  for (let i = 0; i < NUM; i++) { 
```
```
    x = 50 + 30 * Math.sin(t + i / 2);
```

    y = 50 + 30 * Math.cos(t * 1.5 * i / 10);

    rects.push(rect(x, y, x + 5, y + 5, 'rgba(255, 255, 255, 1)', 1));

    rects.push(rect(x, y, x + 5, y + 5, 'rgba(0, 0, 0, 0.4)',

```
      8 + 6 * Math.cos(y / 10)));
```
```
  }
```
```
  t += .04;
```

  document.body.style.backgroundImage = rects.join(', ');

```
  window.requestAnimationFrame(loop);
```
```
}
```
```
loop()
```
```
 
```
```
document.body.innerHTML += `
```
```
  <style>
```
```
    body, html {
```
```
      height: 100%;
```
```
      background: #ccc;
```
```
      margin: 0;
```
```
      background-repeat: no-repeat;
```
```
      width: 100%;
```
```
    }
```
```
  </style>
```
```
`;
```

Animated variation on yesterdays post – many animating circles with no divs or canvas, just radial-gradients…

December 7, 2021

// animation // css // dom // graphics // hacks // javascript // math

Responsive Radial Gradient Background

```
function rect(x1, y1, x2, y2, col) {
```
```
  const dx = x1 - x2;
```
```
  const dy = y1 - y2;
```

  const dist = Math.sqrt(dx * dx + dy * dy);

  return `radial-gradient(circle at ${x1}% ${y1}%, ${col} 0, ${col} ${dist}%, transparent ${dist +

```
    0.1}%)`;
```
```
}
```
```
 
```
```
const NUM = 90;
```
```
const MAX_SIZE = 20;
```
```
 
```
```
const rects = [];
```

const colors = ['rgba(0, 0, 0, 0.2)', 'white', 'black'];

```
 
```
```
for (let i = 0; i < NUM; i++) {
```
```
  const x1 = Math.random() * 100; // %
```
```
  const y1 = Math.random() * 100;
```

  const size = Math.random() * Math.random() * MAX_SIZE;

  const idx = Math.random() < 0.3 ? 1 + Math.round(Math.random()) : 0;

```
  col = colors[idx];
```

  rects.push(rect(x1, y1, x1 + size,  y1 + size, col));

```
}
```
```
 
```

document.body.style.backgroundImage = rects.join(', ');

```
 
```
```
document.body.innerHTML += `
```
```
  <style>
```
```
    body, html {
```
```
      height: 100%;
```
```
      background-repeat: no-repeat;
```
```
    }
```
```
  </style>
```
```
`;
```

Many circles with no divs or canvas, just radial-gradients…

December 6, 2021

// css // dom // gradients // graphics // hacks // javascript

Remove from String

```
x='hello'
```
```
x.replace(/h/g,'') // 17 bytes
```
```
x.split`h`.join`` // 16 bytes
```
```
x.replaceAll('h','') // 19 bytes
```

Another fun one from the great javascript golfing tips stackexchange thread.

This one comes from user emanresu-a and this answer.

November 8, 2021

// golfed // hacks // javascript // strings

Array Range from 1

```
Object.assign(Number.prototype, {
```
```
  *[Symbol.iterator]() {
```
```
    for (let i = this; i--;) 
```
```
      yield this - i;
```
```
  }
```
```
});
```
```
 
```
```
console.log([...3]);
```

I saw this on twitter a little while back. Tweet was from James Padolsey. A fun trick, the thread is pretty entertaining.

November 6, 2021

// arrays // hacks // humor // javascript // tricks

ASCII Circles (Bresenham Fun)

```
// some circles made of text
```
```
 
```
```
const cols = 50;
```
```
const rows = 50;
```
```
const sym = '.';
```
```
const body = document.body;
```
```
 
```
```
Object.assign(body.style, {
```
```
  userSelect: 'none',
```
```
  fontFamily: 'Courier, monospace',
```
```
  position: 'fixed', 
```
```
  width: '100%',
```
```
  height: '100%',
```
```
  margin: 0
```
```
});
```
```
 
```
```
const el = body.appendChild(
```
```
  document.createElement('span')
```
```
);
```
```
el.innerHTML = sym;
```
```
 
```
```
Object.assign(el.style, {
```
```
  position: 'absolute',
```
```
  left: '50%',
```
```
  top: '50%',
```
```
  wordWrap: 'break-word',
```
```
  cursor: 'pointer'
```
```
});
```
```
 
```

const charSize = el.getBoundingClientRect().width;

```
const elWidth = charSize * cols;
```
```
el.style.display = 'block'
```
```
el.style.width = `${elWidth}px`;
```
```
 
```
```
const info = body.appendChild(
```
```
  document.createElement('div')
```
```
);
```
```
 
```
```
Object.assign(info.style, {
```
```
  background: '#fff',
```
```
  padding: '4px',
```
```
  position: 'absolute'
```
```
})
```

info.innerHTML = 'click/tap and hold for different fx';

```
 
```
```
function resize() {
```
```
  const scl = Math.min(
```
```
    1.23, 
```

    Math.min(innerWidth, innerHeight) / elWidth * .93

```
  );
```

  el.style.transform = `translate(-50%, -50%) scale(${scl}, ${scl * .55})`

```
}
```
```
addEventListener('resize', resize);
```
```
resize();
```
```
 
```
```
const size = cols * rows;
```
```
const pix = sym.repeat(size);
```
```
el.innerHTML = pix;
```
```
 
```
```
let cells = pix.split('')
```
```
const blank = cells.concat();
```
```
 
```
```
function setSym(x, y, col) {
```
```
  const idx = x + y * cols;
```
```
  if (cells[idx] != null) {
```
```
    cells[idx] = col;
```
```
  }
```
```
  return setSym
```
```
}
```
```
 
```
```
const grad = '::;|0UU888NN';
```
```
function circ(shooter) {
```

  let x = Math.round(Math.random() * cols);

  let y = Math.round(Math.random() * rows);

```
  const rad = Math.round(
```
```
    shooter ? Math.random() * 2 :
```

      Math.random() * Math.random() * 13 + 1

```
  );
```
```
 
```

  const sym = shooter ? '#' : grad.charAt(rad % grad.length);

```
  let speed = rad / 10 + .1;
```
```
  let dir = Math.random() * 2 - 1;
```
```
  return () => {
```

    drawCircle(x, y, rad, sym, shooter);

```
    y += speed;
```
```
    if (shooter) x += speed * 3 * dir;
```
```
    if (y > rows + 10) y = -14;
```
```
  }
```
```
}
```
```
 
```
```
const circs = [];
```
```
const NUM = 40;
```
```
for (let i = 0; i < NUM; i++) {
```
```
  circs.push(circ(Math.random() > 0.5))
```
```
}
```
```
 
```
```
let down;
```

document.addEventListener('mousedown', () => {

```
  down = true;
```
```
});
```

document.addEventListener('mouseup', () => {

```
  down = false;
```
```
});
```

document.addEventListener('touchstart', () => {

```
  down = true;
```
```
});
```

document.addEventListener('touchend', () => {

```
  down = false;
```
```
});
```
```
 
```
```
let tweak;
```
```
let tweakChoice;
```
```
let tweakChance = 0.4;
```

const clear = () => cells = blank.concat();

```
 
```
```
function draw() {
```
```
  if (!down) {
```
```
    tweak = false;
```
```
    tweakChoice = Math.random();
```
```
    clear();
```
```
  } else {
```
```
    if (tweakChoice < tweakChance) {
```
```
      tweak = true;
```
```
      clear();
```
```
    }
```
```
  }
```
```
 
```
```
  circs.forEach(circ => circ());
```
```
  el.innerHTML = cells.join('');
```
```
}
```
```
 
```

// 60fps is too fast, so use 30ms interval

```
setInterval(draw, 30);
```
```
 
```
```
function hLine(xp, yp, w, col) {
```
```
  for (let i = 0; i < w; i++) {
```
```
    setSym(xp + i, yp, col);
```
```
  }
```
```
  return hLine;
```
```
}
```
```
 
```
```
// bresenham circle
```

function drawCircle(xp, yp, radius, sym = '@', isFilled) {

```
  if (isFilled && tweak) sym = '';
```
```
 
```
```
  xp = parseInt(xp, 10);
```
```
  yp = parseInt(yp, 10);
```
```
  radius = parseInt(radius, 10);
```
```
  let balance = -radius,
```
```
    xoff = 0,
```
```
    yoff = radius;
```
```
 
```
```
  while (xoff <= yoff) {
```
```
    const p0 = xp - xoff;
```
```
    const p1 = xp + xoff;
```
```
 
```
```
    const p2 = yp + yoff;
```
```
    const p3 = yp - yoff;
```
```
    const p4 = yp + xoff;
```
```
    const p5 = xp + yoff;
```
```
    const p6 = xp - yoff;
```
```
    const p7 = yp - xoff;
```
```
 
```
```
    if (isFilled) {
```
```
      const w0 = xoff + xoff;
```
```
      const w1 = yoff + yoff;
```
```
 
```
```
      hLine
```
```
        (p0, yp + yoff, w0, sym)
```
```
        (p0, yp - yoff, w0, sym)
```
```
        (p6, yp + xoff, w1, sym)
```
```
        (p6, yp - xoff, w1, sym);
```
```
 
```
```
    } else {
```
```
      setSym
```
```
        (p1, p2, sym)
```
```
        (p0, p2, sym)
```
```
        (p0, p3, sym)
```
```
        (p1, p3, sym)
```
```
        (p5, p4, sym)
```
```
        (p6, p4, sym)
```
```
        (p6, p7, sym)
```
```
        (p5, p7, sym);
```
```
    }
```
```
 
```

    // never been able to find the original

```
    // source for the below condition 
```

    // more info here: https://actionsnippet.com/?p=492

    if ((balance += xoff++ + xoff) >= 0) {

```
      balance -= --yoff + yoff;
```
```
    }
```
```
  }
```
```
}
```

This is a bit of a longer snippet that uses the Bresenham circle drawing algorithm to draw some circles with text. I recommend looking at it with the fullscreen button.

I like to do this:

```
hLine
```
```
  (p0, yp + yoff, w0, sym)
```
```
  (p0, yp - yoff, w0, sym)
```
```
  (p6, yp + xoff, w1, sym)
```
```
  (p6, yp - xoff, w1, sym);
```

Make a function return itself, so that if you need to call it many times without having to repeat the function name. Because this isn’t a common style it is generally frowned upon, I’m always tempted to use it at work for some reason… maybe next April fools.

September 26, 2021

// animation // arrays // graphics // hacks // humor // javascript // math // random // strings // tricks

Older Posts

Newer Posts

Responsive Radial Gradient Animation

Responsive Radial Gradient Background

Remove from String

Array Range from 1

ASCII Circles (Bresenham Fun)

Recent

Archive