larry babby and threejs for glsl

Larry the snail/js/helper.js

@@ -0,0 +1,407 @@
+async function fetchConfig(className) {
+  // Configurations for different shapes
+  const config = {
+    Larry: [
+      {
+        type: "range",
+        min: 1,
+        max: 5,
+        defaultValue: 1,
+        property: "magnitude"
+      },
+      // Dropdown control to select food
+      {
+        type: "dropdown",
+        property: "selectedFood",
+        defaultValue: "lettuce",
+        options: [
+          { value: "lettuce", label: "Lettuce" },
+          { value: "apple", label: "Apple" },
+          { value: "carrot", label: "Carrot" }
+        ]
+      },
+      {
+        type: "range",
+        min: 0,
+        max: 20,
+        defaultValue: 2,
+        property: "eatSpeed"
+      },
+      {
+        type: "range",
+        min: 0,
+        max: 10000,
+        defaultValue: 3000,
+        property: "eatDuration"
+      },
+      // Button control to start eating
+      {
+        type: "button",
+        label: "Start Eating",
+        method: "startEating",
+      },
+      // Dropdown control to select hat
+      {
+        type: "dropdown",
+        property: "selectedHat",
+        defaultValue: "",
+        options: [
+          { value: "", label: "None" },
+          { value: "cap", label: "Cap" },
+          { value: "top_hat", label: "Top Hat" },
+          { value: "center_box_full", label: "Center Full" },
+          { value: "center_box_hollow", label: "Center Hollow" },
+        ]
+      },
+      // Button control to apply a hat
+      {
+        type: "button",
+        label: "Apply Hat",
+        method: "applyHat"
+      },
+      // Movement controls
+      {
+        type: "range",
+        min: 0,
+        max: 360,
+        defaultValue: 0,
+        property: "moveDirection"
+      },
+      {
+        type: "range",
+        min: 1,
+        max: 100,
+        defaultValue: 10,
+        property: "moveDistance"
+      },
+      {
+        type: "range",
+        min: 1,
+        max: 10,
+        defaultValue: 5,
+        property: "moveSpeed"
+      },
+
+      {
+        type: "button",
+        label: "Wander",
+        method: "wander"
+      },
+      // Appearance controls
+      {
+        type: "dropdown",
+        property: "selectedShell",
+        defaultValue: "default",
+        options: [
+          { value: "default", label: "Default" },
+          { value: "spiky", label: "Spiky" },
+          { value: "striped", label: "Striped" }
+        ]
+      },
+      {
+        type: "button",
+        label: "Apply Shell",
+        method: "applyShell"
+      },
+      // Background controls
+      {
+        type: "dropdown",
+        property: "selectedBackground",
+        defaultValue: "",
+        options: [
+          { value: "", label: "None" },
+          { value: "field_white", label: "Field Whtie" },
+          { value: "field_blue", label: "Field Blue" },
+          { value: "field_trans", label: "Field Trans" }
+        ]
+      },
+      {
+        type: "button",
+        label: "Apply Background",
+        method: "applyBackground"
+      }
+    ],
+    // Add other shape configurations here
+  };
+  return config[className];
+}
+
+
+function addControl(item, instance) {
+  let parentDiv = document.getElementById("custom");
+
+  let title = document.createElement("p");
+  title.innerText = item.property + ": " + item.defaultValue;
+  title.id = "elText" + item.property;
+
+  let control;
+
+  if (item.type === "range") {
+    control = document.createElement("input");
+    control.type = "range";
+    control.min = item.min;
+    control.max = item.max;
+    control.value = item.defaultValue;
+    control.addEventListener("input", (event) => {
+      const newValue = event.target.value;
+      instance[item.property] = parseInt(newValue, 10);
+      title.innerText = item.property + ": " + newValue;
+    });
+  } else if (item.type === "button") {
+    control = document.createElement("button");
+    control.innerText = item.label;
+    control.addEventListener("click", () => {
+      instance[item.method]();
+    });
+  } else if (item.type === "dropdown") {
+    control = document.createElement("select");
+    item.options.forEach(option => {
+      let optionElement = document.createElement("option");
+      optionElement.value = option.value;
+      optionElement.innerText = option.label;
+      control.appendChild(optionElement);
+    });
+    control.value = item.defaultValue;
+    control.addEventListener("change", (event) => {
+      const newValue = event.target.value;
+      instance[item.property] = newValue;
+      title.innerText = item.property + ": " + newValue;
+    });
+  }
+
+  control.className = "control";
+  control.id = "el" + item.property;
+
+  parentDiv.appendChild(title);
+  parentDiv.appendChild(control);
+
+  return { element: control };
+}
+
+
+function drawEyelid(width, x1, y1, colour) {
+  x1 -= centerX;
+  y1 -= centerY;
+
+  const angle = Math.atan2(y1, x1);
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+
+  const x2 = cosAngle * width;
+  const y2 = sinAngle * width;
+
+  const x3Old = width / 2;
+  const y3Old = width / 2;
+  const x4Old = width / 2;
+  const y4Old = -width / 2;
+
+  const x3 = x3Old * cosAngle - y3Old * sinAngle;
+  const y3 = x3Old * sinAngle + y3Old * cosAngle;
+  const x4 = x4Old * cosAngle - y4Old * sinAngle;
+  const y4 = x4Old * sinAngle + y4Old * cosAngle;
+
+  x1 += centerX;
+  y1 += centerY;
+  const x2Final = x2 + x1;
+  const y2Final = y2 + y1;
+  const x3Final = x3 + x1;
+  const y3Final = y3 + y1;
+  const x4Final = x4 + x1;
+  const y4Final = y4 + y1;
+
+  ctx.beginPath();
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x3Final, y3Final, x2Final, y2Final);
+
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x4Final, y4Final, x2Final, y2Final);
+  ctx.fillStyle = colour;
+  ctx.fill();
+
+  ctx.lineWidth = 2;
+  ctx.strokeStyle = "black";
+  ctx.stroke();
+}
+
+function drawEyelidAccident(x1, y1) {
+  let leafWidth = 120;
+  let leafHeight = 60;
+  x1 -= centerX;
+  y1 -= centerY;
+  let angle = Math.atan(y1 / x1);
+  // if(angle >=Math.PI){
+  //     angle -=Math.PI
+  //     console.log("greater called")
+  // }
+  angle = Math.abs(angle);
+  let x2Old = 0 + leafWidth;
+  let y2Old = 0;
+
+  let x3Old = 0 + leafWidth / 2;
+  let y3Old = 0 + leafHeight / 2;
+
+  let x4Old = 0 + leafWidth / 2;
+  let y4Old = 0 - leafHeight / 2;
+
+  let x2 = x2Old * Math.cos(angle) - y2Old * Math.sin(angle);
+  let y2 = x2Old * Math.sin(angle) + y2Old * Math.cos(angle);
+
+  let x3 = x3Old * Math.cos(angle) - y3Old * Math.sin(angle);
+  let y3 = x3Old * Math.sin(angle) + y3Old * Math.cos(angle);
+
+  let x4 = x4Old * Math.cos(angle) - y4Old * Math.sin(angle);
+  let y4 = x4Old * Math.sin(angle) + y4Old * Math.cos(angle);
+
+  let oldx1 = x1;
+  let oldy1 = y1;
+
+  x1 += centerX; // +x2/2
+  y1 += centerY; // +x2/2
+  x2 += x1;
+  y2 += y1;
+  x3 += x1;
+  y3 += y1;
+  x4 += x1;
+  y4 += y1;
+  ctx.beginPath();
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x3, y3, x2, y2);
+
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x4, y4, x2, y2);
+  ctx.fillStyle = "black";
+  ctx.fill();
+
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x3, y3, x2, y2);
+
+  ctx.moveTo(x1, y1);
+  ctx.quadraticCurveTo(x4, y4, x2, y2);
+  ctx.strokeStyle = "orange";
+  ctx.stroke();
+}
+
+function DrawPolygon(sides, width, rotation, colour, line_width) {
+  ctx.beginPath();
+  ctx.moveTo(
+    centerX + width * Math.cos((rotation * Math.PI) / 180),
+    centerY + width * Math.sin((rotation * Math.PI) / 180)
+  );
+
+  for (var i = 1; i <= sides; i += 1) {
+    ctx.lineTo(
+      centerX +
+      width *
+      Math.cos((i * 2 * Math.PI) / sides + (rotation * Math.PI) / 180),
+      centerY +
+      width * Math.sin((i * 2 * Math.PI) / sides + (rotation * Math.PI) / 180)
+    );
+  }
+  ctx.strokeStyle = colour;
+  ctx.lineWidth = line_width;
+  ctx.stroke();
+}
+
+function rad(degrees) {
+  return (degrees * Math.PI) / 180;
+}
+
+function colourToText(colour) {
+  return "rgb(" + colour[0] + "," + colour[1] + "," + colour[2] + ")";
+}
+
+
+function waveNormal(x, max) {
+  let val = Math.sin((x / max) * Math.PI * 2 - max * (Math.PI / (max * 2))) / 2 + 0.5
+  return val
+}
+
+function LerpHex(a, b, amount) {
+  var ah = parseInt(a.replace(/#/g, ""), 16),
+    ar = ah >> 16,
+    ag = (ah >> 8) & 0xff,
+    ab = ah & 0xff,
+    bh = parseInt(b.replace(/#/g, ""), 16),
+    br = bh >> 16,
+    bg = (bh >> 8) & 0xff,
+    bb = bh & 0xff,
+    rr = ar + amount * (br - ar),
+    rg = ag + amount * (bg - ag),
+    rb = ab + amount * (bb - ab);
+
+  return (
+    "#" + (((1 << 24) + (rr << 16) + (rg << 8) + rb) | 0).toString(16).slice(1)
+  );
+}
+
+function LerpRGB(a, b, t) {
+  if (t < 0) {
+    t *= -1;
+  }
+  var newColor = [0, 0, 0];
+  newColor[0] = a[0] + (b[0] - a[0]) * t;
+  newColor[1] = a[1] + (b[1] - a[1]) * t;
+  newColor[2] = a[2] + (b[2] - a[2]) * t;
+  return newColor;
+}
+
+function lerpRGB(a, b, t) {
+  const result = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    result[i] = (1 - t) * a[i] + t * b[i];
+  }
+  return result;
+}
+
+
+function drawCenter(width) {
+  // console.log("center?")
+  ctx.strokeStyle = "pink";
+  ctx.lineWidth = 1
+  ctx.beginPath();
+  ctx.moveTo(centerX - width, centerY);
+  ctx.lineTo(centerX + width, centerY);
+  ctx.closePath();
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(centerX, centerY - width);
+  ctx.lineTo(centerX, centerY + width);
+  ctx.closePath();
+  ctx.stroke();
+}
+
+function render_clear() {
+  ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  ctx.fillStyle = "black";
+  ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+}
+
+function rotatePointTmp(x, y, centerXX, centerYY, rotation) {
+  let xFromC = x - centerXX;
+  let yFromC = y - centerYY;
+  let d = (xFromC ** 2 + yFromC ** 2) ** 0.5
+  // let orgAngle = Math.atan2(yFromC/xFromC)
+  let orgAngle = Math.atan2(xFromC, yFromC)
+  let tmp = Math.cos(rad(orgAngle - rotation)) * d
+  // console.log(Math.cos((-90)*(Math.PI/180)))
+  console.log(orgAngle)
+  console.log(rad(rotation))
+  console.log(Math.cos(orgAngle - rad(rotation)) * d)
+  console.log(d)
+  // console.log(d)
+  let newPointX = Math.cos(orgAngle - rad(rotation + 90)) * d + centerXX;
+  let newPointY = Math.sin(orgAngle - rad(rotation + 90)) * d + centerYY;
+  return [newPointX, newPointY]
+}
+
+function rotatePoint(x, y, rotation) {
+  let nCos = Math.cos(rad(rotation))
+  // console.log(nCos*(180/Math.PI))
+  // console.log(rad(rotation))
+  let nSin = Math.sin(rad(rotation))
+  let newX = x * nCos - y * nSin
+  let newY = y * nCos + x * nSin
+  return [newX, newY]
+}

Larry the snail/js/index.js

@@ -0,0 +1,154 @@
+//jshint esversion:8
+let c = document.getElementById("myCanvas");
+let ctx = c.getContext("2d");
+ctx.canvas.width = window.innerWidth;
+ctx.canvas.height = window.innerHeight;
+centerX = ctx.canvas.width / 2;
+centerY = ctx.canvas.height / 2;
+ctx.imageSmoothingEnabled = false;
+
+
+let deg_per_sec = 10;
+let targetFps = 60;
+let frameDuration = 1000 / targetFps;
+
+let rotation = 0; //was = j = angle
+let paused = true;
+render_clear();
+
+let drawObj = null;
+function createInstance(className, args) {
+  const classMap = {
+    Larry: Larry,
+    NewWave: NewWave,
+    PolyTwistColourWidth: PolyTwistColourWidth,
+    FloralPhyllo: FloralPhyllo,
+    Spiral1: Spiral1,
+    FloralAccident: FloralAccident,
+    FloralPhyllo_Accident: FloralPhyllo_Accident,
+    Nodal_expanding: Nodal_expanding,
+    Phyllotaxis:Phyllotaxis,
+    SquareTwist_angle:SquareTwist_angle,
+    EyePrototype:EyePrototype,
+    CircleExpand:CircleExpand,
+    MaryFace:MaryFace,
+    // Add more class constructors here as needed
+  };
+
+  if (classMap.hasOwnProperty(className)) {
+    return new classMap[className](...args);
+  } else {
+    throw new Error(`Unknown class name: ${className}`);
+  }
+}
+
+
+
+async function updateDrawObj() {
+  const shapeSelector = document.getElementById("shape-selector");
+  const selectedShape = shapeSelector.value;
+  const config = await fetchConfig(selectedShape);
+  if (drawObj) {
+    drawObj.remove(); // Remove the previous instance
+  }
+
+  // Initialize the instance without configuration
+  drawObj = createInstance(selectedShape, []);
+
+  // Set up controls and then update instance properties
+  drawObj.initialise(config);
+
+  // Update instance properties based on control values
+  config.forEach(item => {
+    if (item.type === "range" || item.type === "dropdown") {
+      const control = document.getElementById("el" + item.property);
+      drawObj[item.property] = control.value;
+    }
+  });
+
+  console.log(drawObj);
+}
+
+
+updateDrawObj();
+
+function render() {
+  setTimeout(() => {
+    requestAnimationFrame(() => {
+      render_clear();
+      if (drawObj) {
+        drawObj.draw(rotation);
+      }
+
+      if (!paused) {
+        rotation += deg_per_sec / targetFps;
+      }
+      drawCenter(300)
+    });
+    render();
+  }, frameDuration);
+}
+
+document
+  .getElementById("shape-selector")
+  .addEventListener("change", updateDrawObj);
+
+let toolbarShowing = true;
+document.addEventListener("keydown", toggleSettings);
+
+function manualToggleSettings(){
+  console.log("hi")
+  toolbarShowing = !toolbarShowing;
+  let tb = document.getElementById("toolbar");
+  if (toolbarShowing) {
+    tb.style.display = "flex";
+  } else {
+    tb.style.display = "none";
+  }
+}
+
+function toggleSettings(e) {
+  if (e.key == "p") {
+    toolbarShowing = !toolbarShowing;
+  }
+  if (e.code === "Space") {
+    paused = !paused;
+  }
+
+  let tb = document.getElementById("toolbar");
+  if (toolbarShowing) {
+    tb.style.display = "flex";
+  } else {
+    tb.style.display = "none";
+  }
+}
+
+function TogglePause() {
+  let pb = document.getElementById("pauseButton");
+  paused = !paused;
+
+  if (paused) {
+    pb.textContent = "Play";
+  } else {
+    pb.textContent = "Pause";
+  }
+}
+function Reset() {
+  rotation = 0; //was = j = angle
+  currentFrame = 0;
+}
+
+function ForwardFrame() {
+  rotation += deg_per_sec / fps; // was = j = innerRotation, now = rotation
+  currentFrame += 1; // was = i
+}
+function BackwardFrame() {
+  rotation -= deg_per_sec / fps; // was = j = innerRotation, now = rotation
+  currentFrame -= 1; // was = i
+}
+
+function ChangeDegPerSec(newValue) {
+  deg_per_sec = newValue;
+}
+
+window.onload = render;

Larry the snail/js/math.js

@@ -0,0 +1,77 @@
+function rotateMatrix2d(p, angle) {
+  // cos0 sin0
+  // -sin0 cos0
+  const angleD = rad(angle);
+  const r = [
+    [Math.cos(angleD), Math.sin(angleD)],
+    [-Math.sin(angleD), Math.cos(angleD)],
+  ];
+  const newPoint = [
+    p[0] * r[0][0] + p[1] * r[0][1],
+    p[0] * r[1][0] + p[1] * r[1][1],
+  ];
+  return newPoint;
+}
+
+function rotateMatrix3dX(p, angle) {
+  // cos0 sin0
+  // -sin0 cos0
+  const angleD = rad(angle);
+  const r = [
+    [1, 0, 0],
+    [0, Math.cos(angleD), -Math.sin(angleD)],
+    [0, Math.sin(angleD), Math.cos(angleD)],
+  ];
+  const newPoint = [
+    p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+    p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+    p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+  ];
+  return newPoint;
+}
+
+function rotateMatrix3dY(p, angle) {
+  // cos0 sin0
+  // -sin0 cos0
+  const angleD = rad(angle);
+  const r = [
+    [Math.cos(angleD), 0, Math.sin(angleD)],
+    [0, 1, 0],
+    [-Math.sin(angleD), 0, Math.cos(angleD)],
+  ];
+  const newPoint = [
+    p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+    p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+    p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+  ];
+  return newPoint;
+}
+function rotateMatrix3dZ(p, angle) {
+  // cos0 sin0
+  // -sin0 cos0
+  const angleD = rad(angle);
+  const r = [
+    [Math.cos(angleD), -Math.sin(angleD), 0],
+    [Math.sin(angleD), Math.cos(angleD), 0],
+    [0, 0, 1],
+  ];
+  const newPoint = [
+    p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+    p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+    p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+  ];
+  return newPoint;
+}
+
+function projectionOrth(v) {
+  const p = [
+    [1, 0, 0],
+    [0, 1, 0],
+  ];
+
+  const nPoint = [
+    p[0][0] * v[0] + p[0][1] * v[1] + p[0][2] * v[2],
+    p[1][0] * v[0] + p[1][1] * v[1] + p[1][2] * v[2],
+  ];
+  return nPoint;
+}

Larry the snail/js/objects.js

@@ -0,0 +1,808 @@
+
+class BaseShape {
+  constructor() {
+    this.controls = []; // Keep track of created elements and event listeners
+    this.speedMultiplier = 100;
+  }
+
+  initialise(config) {
+    for (let item of config) {
+      const { element, listener } = addControl(item, this);
+      this.controls.push({ element, listener });
+    }
+
+    // Add a default speed multiplier control
+    const { element, listener } = addControl({
+      type: "range",
+      min: 1,
+      max: 500,
+      defaultValue: 100,
+      property: "speedMultiplier",
+    }, this);
+    this.controls.push({ element, listener });
+  }
+
+  remove() {
+    this.controls.forEach(({ element, listener }) => {
+      if (element && listener) {
+        element.removeEventListener("input", listener);
+      }
+      if (element && element.parentElement) {
+        element.parentElement.removeChild(element);
+        const titleElement = document.getElementById("elText" + element.id.slice(2));
+        if (titleElement) {
+          titleElement.parentElement.removeChild(titleElement);
+        }
+      }
+    });
+    this.controls = [];
+  }
+
+  draw() {
+    throw new Error("Draw function not implemented");
+  }
+}
+
+class Larry extends BaseShape {
+  constructor(eatSpeed, eatDuration) {
+    super();
+    this.magnitude = 1;
+    this.bodyWidth = 64;
+    this.bodyHeight = 64;
+    this.headWidth = 21;
+    this.headHeight = 24;
+    this.headOffsetX = 54 - this.headWidth * this.magnitude / 2;
+    this.headOffsetY = this.bodyHeight * this.magnitude - 7; // Bottom of the body minus 7 pixels
+    this.globalX = centerX;
+    this.globalY = centerY;
+    this.localX = 0;
+    this.localY = 0;
+    this.speedMultiplier = 100;
+
+    this.isEating = false;
+    this.eatDuration = eatDuration;
+    this.eatSpeed = eatSpeed;
+
+    this.bodyImage = new Image();
+    this.headImage = new Image();
+    this.hatImage = new Image();
+    this.shellImage = new Image();
+    this.backgroundImage = new Image();
+
+    this.bodyImage.src = 'larry_photos/body.png';
+    this.headImage.src = 'larry_photos/head.png';
+    this.hatImage.src = '';
+    this.shellImage.src = '';
+    this.backgroundImage.src = '';
+  }
+
+  draw(timestamp) {
+    timestamp *= (this.speedMultiplier / 100);
+    // Draw background
+    if (this.backgroundImage.src) {
+      console.log("drawing background: " + this.backgroundImage.src)
+      ctx.drawImage(this.backgroundImage, centerX- (this.backgroundImage.width), centerY -this.backgroundImage.height,this.backgroundImage.width*2,this.backgroundImage.height*2);
+    }
+
+    // Draw body at its anchor point (center-bottom)
+    const bodyX = this.globalX - (this.bodyWidth * this.magnitude / 2);
+    const bodyY = this.globalY - this.bodyHeight * this.magnitude;
+    ctx.drawImage(this.bodyImage, bodyX, bodyY, this.bodyWidth * this.magnitude, this.bodyHeight * this.magnitude);
+
+    // Draw head aligned with body
+    // const headX = bodyX + this.headOffsetX;
+    // let headY = bodyY + this.headOffsetY - this.headHeight;
+    const headX = bodyX + (54 * this.magnitude - this.headWidth * this.magnitude / 2);
+    let headY = bodyY + (this.bodyHeight * this.magnitude - 7* this.magnitude) - this.headHeight * this.magnitude;
+
+    if (this.isEating === true) {
+      const eatMaxHeight = 20;
+      const eatingYOffset = ((Math.sin((timestamp * 2 * Math.PI * this.eatSpeed * 0.1) - Math.PI / 2) + 1) / 2) * eatMaxHeight;
+      headY -= eatingYOffset;
+    }
+    ctx.drawImage(this.headImage, headX, headY, this.headWidth * this.magnitude, this.headHeight * this.magnitude);
+
+    // Draw hat if any
+    if (this.hatImage.src) {
+      let hatXoffset = (this.headWidth*this.magnitude)/2 -(this.hatImage.width*this.magnitude)/2 + (2*this.magnitude);
+      let hatYoffset = (this.headHeight*this.magnitude) - (this.hatImage.height*this.magnitude) + (-11 * this.magnitude);
+      if(document.getElementById('elselectedHat').value === "cap"){
+        hatXoffset += this.magnitude*1.5
+      }
+      this.drawCrosshair(headX,headY,20)
+      ctx.drawImage(this.hatImage, headX + hatXoffset, headY + hatYoffset,this.hatImage.width*this.magnitude,this.hatImage.height*this.magnitude);
+    }  
+
+    // Draw shell if any
+    if (this.shellImage.src) {
+      ctx.drawImage(this.shellImage, bodyX, bodyY, this.bodyWidth, this.bodyHeight);
+    }
+  }
+
+  drawCrosshair(x,y,size){
+    ctx.beginPath();
+    ctx.moveTo(x-size,y);
+    ctx.lineTo(x+size,y);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(x,y-size);
+    ctx.lineTo(x,y+size);
+    ctx.stroke();
+  }
+
+  startEating() {
+    console.log("Larry starts eating");
+    console.log(this.eatDuration)
+    this.isEating = true;
+    setTimeout(() => {
+      this.isEating = false;
+      console.log("Larry stops eating");
+    }, this.eatDuration); // Adjust duration as needed
+  }
+
+  applyHat() {
+    const hatSelection = document.getElementById('elselectedHat').value;
+    if (hatSelection === "") {
+      this.hatImage.src = ``;
+    }
+    else {
+      this.hatImage.src = `larry_photos/hats/${hatSelection}.png`;
+    }
+  }
+
+  wander() {
+    console.log("Larry starts wandering");
+    // Implement wandering logic here
+  }
+
+  applyShell() {
+    const shellSelection = document.getElementById('elselectedShell').value;
+    this.shellImage.src = `larry_photos/shells/${shellSelection}.png`;
+  }
+
+  applyBackground() {
+    const backgroundSelection = document.getElementById('elselectedBackground').value;
+    this.backgroundImage.src = `larry_photos/backgrounds/${backgroundSelection}.png`;
+  }
+}
+
+
+class PolyTwistColourWidth extends BaseShape {
+  constructor(sides, width, line_width, depth, rotation, speedMultiplier, colour1, colour2) {
+    super();
+    this.sides = sides;
+    this.width = width;
+    this.line_width = line_width;
+    this.depth = depth;
+    this.rotation = rotation;
+    this.speedMultiplier = speedMultiplier;
+    this.colour1 = colour1;
+    this.colour2 = colour2;
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 100)
+    let out_angle = 0;
+    const innerAngle = 180 - ((this.sides - 2) * 180) / this.sides;
+    const scopeAngle = rotation - (innerAngle * Math.floor(rotation / innerAngle));
+
+    if (scopeAngle < innerAngle / 2) {
+      out_angle = innerAngle / (2 * Math.cos((2 * Math.PI * scopeAngle) / (3 * innerAngle))) - innerAngle / 2;
+    } else {
+      out_angle = -innerAngle / (2 * Math.cos(((2 * Math.PI) / 3) - ((2 * Math.PI * scopeAngle) / (3 * innerAngle)))) + (innerAngle * 3) / 2;
+    }
+    let minWidth = Math.sin(rad(innerAngle / 2)) * (0.5 / Math.tan(rad(innerAngle / 2))) * 2;
+
+    let widthMultiplier = minWidth / Math.sin(Math.PI / 180 * (90 + innerAngle / 2 - out_angle + innerAngle * Math.floor(out_angle / innerAngle)));
+
+    for (let i = 0; i < this.depth; i++) {
+      const fraction = i / this.depth;
+      const ncolour = LerpHex(this.colour1, this.colour2, fraction);
+      DrawPolygon(this.sides, this.width * widthMultiplier ** i, out_angle * i + this.rotation, ncolour, this.line_width);
+    }
+  }
+}
+class FloralPhyllo extends BaseShape {
+  constructor(width, depth, start, colour1, colour2) {
+    super();
+    this.width = width;
+    this.depth = depth;
+    this.start = start;
+    this.colour1 = colour1;
+    this.colour2 = colour2;
+    this.speedMultiplier = 500;
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 500)
+    rotation += this.start
+    // var c = 24; //something to do with width. but not width
+    var c = 1; //something to do with width. but not width
+    //dont make larger than 270 unless altering the number of colours in lerpedColours
+    for (let n = this.depth; n > 0; n -= 1) {
+      let colVal = waveNormal(n, this.depth)
+      let ncolour = LerpHex(this.colour1, this.colour2, n / this.depth);
+      const a = n * rotation / 1000; //137.5;
+      const r = c * Math.sqrt(n);
+      const x = r * Math.cos(a) + centerX;
+      const y = r * Math.sin(a) + centerY;
+
+      drawEyelid(n * 2.4 + 40, x, y, ncolour);
+    }
+  }
+}
+class Spiral1 extends BaseShape {
+  constructor(sides, width, colour) {
+    super();
+    this.sides = sides;
+    this.width = width;
+    this.colour = colour;
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 100)
+    var rot = Math.round((this.sides - 2) * 180 / this.sides * 2)
+    var piv = 360 / this.sides;
+    var stt = 0.5 * Math.PI - rad(rot) //+ rad(rotation);
+    var end = 0;
+    var n = this.width / ((this.width / 10) * (this.width / 10)) //pixel correction for mid leaf
+
+    for (let i = 1; i < this.sides + 1; i++) {
+      end = stt + rad(rot);
+      ctx.lineWidth = 5
+      ctx.beginPath();
+      ctx.arc(centerX + Math.cos(rad(90 + piv * i + rotation)) * this.width, centerY + Math.sin(rad(90 + piv * i + rotation)) * this.width, this.width, stt + rad(rotation) - (stt - end) / 2, end + rad(rotation) + rad(n), 0);
+      ctx.strokeStyle = this.colour;
+      ctx.stroke();
+
+
+      ctx.beginPath();
+      ctx.arc(centerX + Math.cos(rad(90 + piv * i - rotation)) * this.width, centerY + Math.sin(rad(90 + piv * i - rotation)) * this.width, this.width, stt - rad(rotation), end - (end - stt) / 2 + rad(n) - rad(rotation), 0);
+      ctx.strokeStyle = this.colour;
+      ctx.stroke();
+
+
+      stt = end + -(rad(rot - piv)) //+rad(30);
+    }
+
+  }
+}
+
+class FloralAccident extends BaseShape {
+  constructor(sides, width, colour) {
+    super();
+    this.sides = sides;
+    this.width = width;
+    this.colour = colour;
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 100)
+    var rot = Math.round((this.sides - 2) * 180 / this.sides * 2)
+    var piv = 360 / this.sides;
+    var stt = 0.5 * Math.PI - rad(rot) //+ rad(rotation);
+    var end = 0;
+    var n = this.width / ((this.width / 10) * (this.width / 10)) //pixel correction for mid leaf
+
+    for (let i = 1; i < this.sides + 1; i++) {
+      end = stt + rad(rot);
+
+      ctx.beginPath();
+      ctx.arc(centerX + Math.cos(rad(90 + piv * i + rotation)) * this.width, centerY + Math.sin(rad(90 + piv * i + rotation)) * this.width, this.width, stt - (stt - end + rad(rotation)) / 2, end + rad(n), 0);
+      ctx.strokeStyle = this.colour;
+      ctx.stroke();
+
+
+      ctx.beginPath();
+      ctx.arc(centerX + Math.cos(rad(90 + piv * i - rotation)) * this.width, centerY + Math.sin(rad(90 + piv * i - rotation)) * this.width, this.width, stt, end - (end - stt - rad(rotation)) / 2 + rad(n), 0);
+      ctx.strokeStyle = this.colour;
+      ctx.stroke();
+
+
+      stt = end + -(rad(rot - piv)) //+rad(30);
+    }
+
+  }
+}
+class FloralPhyllo_Accident extends BaseShape {
+  constructor(sides, width, colour1, colour2) {
+    super();
+    this.sides = sides;
+    this.width = width;
+    this.colour1 = colour1;
+    this.colour2 = colour2;
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 100)
+    var c = 24; //something to do with width. but not width
+
+    for (let n = 0; n < 300; n += 1) {
+      let ncolour = LerpHex(this.colour1, this.colour2, Math.cos(rad(n / 2)));
+      let a = n * (rotation / 1000 + 100); //137.5;
+      let r = c * Math.sqrt(n);
+      let x = r * Math.cos(a) + centerX;
+      let y = r * Math.sin(a) + centerY;
+
+      drawEyelidAccident(x, y);
+
+    }
+  }
+}
+class Nodal_expanding extends BaseShape {
+  constructor(expand, points, start, line_width, colour1, colour2, colour_change) {
+    super();
+    this.expand = expand;
+    this.points = points;
+    this.start = start;
+    this.line_width = line_width;
+    this.colour1 = colour1;
+    this.colour2 = colour2;
+    this.colour_change = colour_change
+  }
+
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 1000)
+    var angle = (360 / 3000 * rotation) + this.start //2000 controls speed
+
+    var length = this.expand;
+
+    for (let z = 1; z <= this.points; z++) { //why specifically 2500
+      ctx.beginPath();
+      let ncolour = LerpHex(this.colour1, this.colour2, z / this.points);
+
+      ctx.moveTo(centerX + (Math.cos(rad(angle * (z - 1) + 0)) * (length - this.expand)), centerY + (Math.sin(rad(angle * (z - 1) + 0)) * (length - this.expand)));
+      ctx.lineTo(centerX + (Math.cos(rad(angle * z + 0)) * length), centerY + (Math.sin(rad(angle * z + 0)) * length));
+      length += this.expand;
+      ctx.lineWidth = this.line_width;//try 1
+      ctx.strokeStyle = ncolour;
+      ctx.lineCap = "round"
+      // ctx.strokeStyle = colourToText(ncolour);
+      console.log(ncolour)
+      ctx.stroke();
+    }
+
+
+  }
+}
+class Phyllotaxis extends BaseShape {
+  constructor(width, start, nMax, wave, colour1, colour2) {
+    super();
+    this.width = width;
+    this.start = start;
+    this.nMax = nMax;
+    this.wave = wave;
+    this.colour1 = colour1;
+    this.colour2 = colour2;
+  }
+  drawWave(angle) {
+    angle /= 1000
+    const startColor = [45, 129, 252];
+    const endColor = [252, 3, 98];
+    const distanceMultiplier = 3;
+    const maxIterations = 200;
+    //   angle=0;
+    for (let n = 0; n < maxIterations; n++) {
+      ctx.beginPath();
+      const nColor = lerpRGB(startColor, endColor, Math.cos(rad(n / 2)));
+
+      // const nAngle = n* angle ;
+      // const nAngle = n*angle+ Math.sin(rad(n*1+angle*4000))/1 ;
+      const nAngle = n * angle + Math.sin(rad(n * 1 + angle * 40000)) / 2;
+      const radius = distanceMultiplier * n;
+      const xCoord = radius * Math.cos(nAngle) + centerX;
+      const yCoord = radius * Math.sin(nAngle) + centerY;
+      ctx.arc(xCoord, yCoord, 8, 0, 2 * Math.PI);
+      ctx.fillStyle = colourToText(nColor);
+      ctx.fill();
+    }
+  }
+  drawSpiral(angle) {
+    angle /= 5000
+    const startColor = [45, 129, 252];
+    const endColor = [252, 3, 98];
+    const distanceMultiplier = 2;
+    const maxIterations = 1000;
+
+
+    for (let n = 0; n < maxIterations; n++) {
+      const nColor = lerpRGB(startColor, endColor, Math.cos(rad(n / 2)));
+
+      const nAngle = n * angle + Math.sin(angle * n * 2);
+      const radius = distanceMultiplier * n;
+      const xCoord = radius * Math.cos(nAngle) + centerX;
+      const yCoord = radius * Math.sin(nAngle) + centerY;
+
+      ctx.beginPath();
+      ctx.arc(xCoord, yCoord, 8, 0, 2 * Math.PI);
+      ctx.fillStyle = colourToText(nColor);
+      ctx.fill();
+    }
+  }
+
+  // Draw_nodal(300, 100, 31, rotation, "blue");
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 300)
+    rotation += this.start
+    const sizeMultiplier = this.nMax / (5 - 3)
+    if (this.wave === 1) {
+      this.drawWave(rotation)
+    }
+    else if (this.wave === 2) {
+      this.drawSpiral(rotation)
+    }
+    else {
+      for (let n = 0; n < this.nMax; n += 1) {
+        const ncolour = LerpHex(this.colour1, this.colour2, n / this.nMax);
+        // const ncolour = LerpHex(this.colour1, this.colour2, (n/this.nMax)**2);
+        const a = n * (rotation / 1000)//137.5;
+        const r = this.width * Math.sqrt(n);
+        const x = r * Math.cos(a) + centerX;
+        const y = r * Math.sin(a) + centerY;
+
+        ctx.beginPath();
+        ctx.arc(x, y, (n / sizeMultiplier) + 3, 0, 2 * Math.PI);
+        ctx.fillStyle = ncolour;
+        // ctx.fillStyle = colourToText(ncolour);
+        ctx.fill();
+        // console.log(this.c)
+      }
+    }
+  }
+}
+class SquareTwist_angle extends BaseShape {
+  constructor(width, line_width, colour1) {
+    super();
+    this.width = width;
+    this.line_width = line_width;
+    this.colour1 = colour1;
+  }
+  drawSquare(angle, size, colour) {
+    ctx.save();
+    ctx.translate(centerX, centerY)//-(Math.sin(rad(angle)) *centerX));
+    ctx.rotate(rad(angle + 180));
+    ctx.beginPath();
+    ctx.strokeStyle = colour;
+    ctx.lineWidth = this.line_width;
+    ctx.rect(-size / 2, -size / 2, size, size);
+    ctx.stroke();
+    ctx.restore();
+  }
+  // DrawSquareTwist_angle(400,0,rotation,"red")
+  draw(rotation) {
+    rotation *= (this.speedMultiplier / 100)
+    let out_angle = rotation;
+    let widthMultiplier = 1 / (2 * Math.sin(Math.PI / 180 * (130 - out_angle + 90 * Math.floor(out_angle / 90)))) + 0.5
+
+    for (let i = 0; i < 25; i++) {
+      this.drawSquare(rotation * i, this.width * widthMultiplier ** i, this.colour1)
+    }
+
+  }
+}
+
+class CircleExpand extends BaseShape {
+  constructor(nCircles, gap, linear, heart, colour1, colour2) {
+    super();
+    this.nCircles = nCircles;
+    this.gap = gap;
+    this.linear = linear;
+    this.heart = heart;
+    this.colour1 = colour1;
+    this.colour2 = colour2
+  }
+  lerpColor(a, b, amount) {
+    var ah = +a.replace('#', '0x'),
+      ar = ah >> 16, ag = ah >> 8 & 0xff, ab = ah & 0xff,
+      bh = +b.replace('#', '0x'),
+      br = bh >> 16, bg = bh >> 8 & 0xff, bb = bh & 0xff,
+      rr = ar + amount * (br - ar),
+      rg = ag + amount * (bg - ag),
+      rb = ab + amount * (bb - ab);
+
+    return '#' + ((1 << 24) + (rr << 16) + (rg << 8) + rb | 0).toString(16).slice(1);
+  }
+
+  arraySort(x, y) {
+    if (x.r > y.r) {
+      return 1;
+    }
+    if (x.r < y.r) {
+      return -1;
+    }
+    return 0;
+  }
+  drawHeart(w, colour) {
+    // var w = 200
+    ctx.strokeStyle = "black";
+    ctx.fillStyle = colour;
+    ctx.lineWidth = 1;
+    var x = centerX - w / 2;
+    let y = centerY - w / 2
+    ctx.beginPath();
+    ctx.moveTo(x, y + w / 4);
+    ctx.quadraticCurveTo(x, y, x + w / 4, y);
+    ctx.quadraticCurveTo(x + w / 2, y, x + w / 2, y + w / 5);
+    ctx.quadraticCurveTo(x + w / 2, y, x + w * 3 / 4, y);
+    ctx.quadraticCurveTo(x + w, y, x + w, y + w / 4);
+    ctx.quadraticCurveTo(x + w, y + w / 2, x + w * 3 / 4, y + w * 3 / 4);
+    ctx.lineTo(x + w / 2, y + w);
+    ctx.lineTo(x + w / 4, y + w * 3 / 4);
+    ctx.quadraticCurveTo(x, y + w / 2, x, y + w / 4);
+    ctx.stroke();
+    ctx.fill();
+  }
+
+  draw(rotation) {
+    rotation *= (0.9)
+    ctx.strokeWeight = 1;
+    ctx.lineWidth = 1;
+    let arrOfWidths = []
+    let arrOfco = []
+    let intRot;
+    if (this.linear) {
+      intRot = Math.floor(rotation * 30) / 100
+    }
+    else {
+      intRot = Math.sin(rad(Math.floor(rotation * 30) / 4)) + rotation / 4
+    }
+
+    for (let i = 0; i < this.nCircles; i++) {
+      const width = this.gap * ((intRot + i) % this.nCircles);
+      const colour = (Math.sin(rad(i * (360 / this.nCircles) - 90)) + 1) / 2
+      arrOfWidths.push({ r: width, c: colour });
+    }
+
+    let newArr = arrOfWidths.sort(this.arraySort)
+
+    for (let i = this.nCircles - 1; i >= 0; i--) {
+      let newColour = this.lerpColor(this.colour1, this.colour2, newArr[i].c)
+
+      if (this.heart) {
+        this.drawHeart(newArr[i].r, newColour)
+      }
+      else {
+        ctx.beginPath();
+        ctx.arc(centerX, centerY, newArr[i].r, 0, 2 * Math.PI);
+        ctx.fillStyle = newColour;
+        ctx.fill();
+        ctx.stokeStyle = "black";
+        ctx.stroke();
+
+      }
+    }
+
+  }
+}
+
+
+class EyePrototype extends BaseShape {
+  constructor(x, y, rotate, flip, width, blink_speed, draw_spiral, spiral_full, draw_pupil, draw_expand, draw_hypno, line_width, colourPupil, colourSpiral, colourExpand) {
+    super();
+    this.x = x;
+    this.y = y;
+    this.rotate = rotate;
+    this.flip = flip
+    this.width = width;
+    this.blink_speed = blink_speed;
+    this.line_width = line_width;
+    this.step = 0;
+    this.opening = true;
+    this.counter = 0;
+    this.cooldown = 0;
+    this.draw_spiral = draw_spiral;
+    this.spiral_full = spiral_full;
+    this.draw_pupil = draw_pupil;
+    this.draw_expand = draw_expand;
+    this.draw_hypno = draw_hypno;
+    this.colourPupil = colourPupil;
+    this.colourSpiral = colourSpiral;
+    this.colourExpand = colourExpand;
+    this.centerPulse = new CircleExpand(10, 30, 1, 0, "#2D81FC", "#FC0362")
+  }
+  drawEyelid(rotation) {
+    ctx.strokeStyle = "orange";
+    let relCenterX = centerX + this.x;
+    let relCenterY = centerY + this.y;
+    rotation *= (this.speedMultiplier / 100)
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    let newPoint = 0
+    let newPoint1 = 0
+    let addedRotate = this.flip ? 90 : 0
+    newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+    ctx.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+    newPoint = rotatePoint(0, - rotation / 400 * this.width, this.rotate + addedRotate)
+    newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+    ctx.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+    newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+    ctx.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+    newPoint = rotatePoint(0, + rotation / 400 * this.width, this.rotate + addedRotate)
+    newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+    ctx.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+    ctx.stroke();
+  }
+  eyelidCut(rotation) {
+    let relCenterX = centerX + this.x;
+    let relCenterY = centerY + this.y;
+    let newPoint = 0
+    let newPoint1 = 0
+    let addedRotate = this.flip ? 90 : 0
+    // ctx.lineWidth = 1;
+    let squarePath = new Path2D();
+    newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+    squarePath.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+    newPoint = rotatePoint(0, - rotation / 400 * this.width, this.rotate + addedRotate)
+    newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+    squarePath.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+    newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+    squarePath.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+    newPoint = rotatePoint(0, + rotation / 400 * this.width, this.rotate + addedRotate)
+    newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+    squarePath.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+    ctx.clip(squarePath);
+  }
+  drawGrowEye(step) {
+    // console.log(step)
+    ctx.strokeStyle = this.colourExpand
+    ctx.beginPath();
+    ctx.lineWidth = 5;
+    ctx.arc(centerX + this.x, centerY + this.y, step, 0, 2 * Math.PI);
+    ctx.stroke();
+  }
+  drawCircle(step) {
+    ctx.strokeStyle = this.colourPupil
+    ctx.beginPath();
+    ctx.lineWidth = 5;
+    ctx.arc(centerX + this.x, centerY + this.y, step, 0, 2 * Math.PI);
+    ctx.stroke();
+  }
+
+  drawSpiral(step) {
+    ctx.strokeStyle = this.colourSpiral;
+    let a = 1
+    let b = 5
+    ctx.moveTo(centerX, centerY);
+    ctx.beginPath();
+    let max = this.spiral_full ? this.width : this.width / 2
+    for (let i = 0; i < max; i++) {
+      let angle = 0.1 * i;
+      let x = centerX + (a + b * angle) * Math.cos(angle + step / 2);
+      let y = centerY + (a + b * angle) * Math.sin(angle + step / 2);
+
+      ctx.lineTo(x + this.x, y + this.y);
+    }
+    ctx.lineWidth = 3;
+    ctx.stroke();
+  }
+  stepFunc() {
+    if (this.cooldown != 0) {
+      this.cooldown--;
+    } else {
+      if (this.opening == true) {
+        if (this.step >= 200) {
+          this.cooldown = 200;
+          this.opening = false;
+          this.step -= this.blink_speed;
+        } else {
+          this.step += this.blink_speed;
+        }
+      } else {
+        if (this.step <= 0) {
+          this.opening = true;
+          this.step += this.blink_speed;
+        } else {
+          this.step -= this.blink_speed;
+        }
+      }
+    }
+  }
+
+  draw(rotation) {
+    let speedMult = 50
+    console.log(this.blink_speed)
+    let waitTime = this.blink_speed
+    let cap = 200
+    let d = waitTime * speedMult * 10
+    let a = cap * 2 + d
+    let outputRotation = Math.min(Math.abs((Math.floor(rotation * speedMult) % a) - a / 2 - d / 2), cap)
+
+    ctx.fillStyle = "black";
+    ctx.save();
+    this.drawEyelid(outputRotation);
+    // squareCut();
+    this.eyelidCut(outputRotation);
+    // console.log(Math.floor(this.counter % this.width / 2))
+    if (Math.floor(this.counter % (this.width / 4)) === 0) {
+      this.counter = 0;
+    }
+    ctx.fillStyle = "black";
+    ctx.fillRect(this.x - this.width / 2 + centerX, 0, this.width, ctx.canvas.height);
+    if (this.draw_expand) {
+      this.drawGrowEye(this.width / 4 + this.counter);
+    }
+
+    if (this.draw_hypno) {
+      this.centerPulse.draw(rotation)
+    }
+    if (this.draw_spiral) {
+      this.drawSpiral(rotation)
+    }
+    if (this.draw_pupil) {
+      this.drawCircle(this.width / 4);
+    }
+
+    ctx.restore();
+
+    this.stepFunc();
+    this.counter++;
+  }
+}
+class MaryFace extends BaseShape {
+  constructor(x1, y1, rotate1, width1, x2, y2, rotate2, width2) {
+    super();
+    this.x1 = x1;
+    this.y1 = y1;
+    this.rotate1 = rotate1;
+    this.width1 = width1;
+    this.x2 = x2;
+    this.y2 = y2;
+    this.rotate2 = rotate2;
+    this.width2 = width2;
+    this.eye1 = new EyePrototype(x1, y1, rotate1, 0, width1, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+    this.eye2 = new EyePrototype(x2, y2, rotate2, 0, width2, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+    // this.eye3 = new EyePrototype(112, -280, rotate2+2,1, width2, 10, 1, 1, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+    this.eye3 = new EyePrototype(110, -280, rotate2 + 2, 1, width2, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")//maybe
+  }
+
+  draw(rotation) {
+    let img = new Image();
+    img.src = "maryFace.png";
+
+    ctx.drawImage(img, centerX - img.width / 2, centerY - img.height / 2);
+    this.eye1.draw(rotation);
+    this.eye2.draw(rotation);
+    this.eye3.draw(rotation);
+  }
+}
+class NewWave extends BaseShape {
+  constructor(width, sides, step, lineWidth, limiter) {
+    super();
+    this.width = width
+    this.sides = sides;
+    this.step = step;
+    this.lineWidth = lineWidth;
+    this.limiter = limiter;
+  }
+
+  draw(rotation) {
+    rotation *= this.speedMultiplier / 400
+    ctx.lineWidth = this.lineWidth
+    for (let j = 0; j < this.sides; j++) {
+      const radRotation = rad(360 / this.sides * j)
+      const inverter = 1 - (j % 2) * 2
+      let lastX = centerX
+      let lastY = centerY
+      for (let i = 0; i < this.width; i += this.step) {
+
+        ctx.beginPath();
+        ctx.moveTo(lastX, lastY);
+        ctx.strokeStyle = colourToText(lerpRGB([255, 51, 170], [51, 170, 255], i / this.width))
+        const x = i
+        const y = (Math.sin(-i * inverter / 30 + rotation * inverter) * i / (this.limiter / 100))
+
+        const xRotated = x * Math.cos(radRotation) - y * Math.sin(radRotation)
+        const yRotated = x * Math.sin(radRotation) + y * Math.cos(radRotation)
+        lastX = centerX + xRotated;
+        lastY = centerY + yRotated;
+        ctx.lineTo(centerX + xRotated, centerY + yRotated);
+        ctx.stroke();
+      }
+    }
+
+  }
+}
+