const WIDTH = 101; // Canvas width in units

const HEIGHT = 103; // Canvas height in units

const SCALE = 5; // Scale each unit for better visibility

​

// Adjustable Variables

let lerpStartTime = 1.0; // Time (in seconds) when lerp starts

let lerpEndTime = 2.0; // Time (in seconds) when lerp ends

let pauseDuration = 3.0; // Duration (in seconds) to pause after lerp

​

let solutionPosition = 6284; // yeeeee

let solutionPositionDisp = solutionPosition - 2; // ehhhhh

​

​

// Flickering Variables

let flickerFrequency = 5; // Flickers per second

let flickerInterval = 1 / flickerFrequency; // Time between flickers in seconds

let lastFlickerTime = 0; // Tracks the last time a flicker occurred

let flickerState = true; // Current visibility state of flickering robots

​

let timeStep = 0.05; // Time step in seconds (can be negative for backward time)

let elapsedTime = 0; // Tracks the total time passed in the simulation

​

let animationPaused = false; // Flag to indicate if the animation is paused

let pauseStartTime = 0; // Time when the pause started

let hasPaused = false; // Flag to ensure pausing happens only once

​

let recording = false; // Flag to start/stop recording

let recordFrames = 300; // Total frames to record (5 seconds at 60 FPS)

​

function preload() {

  // Load the input data

  loadStrings("input.txt", parseInput);

}

​

function setup() {

  canvas = createCanvas(WIDTH * SCALE, HEIGHT * SCALE);

​

  // Initialize robot positions by simulating initial steps

  timeStep = 1;

  for (var i = 0; i < 6283; i++) {

    robots.forEach((robot) => {

      robot.x = (robot.x + robot.vx) % WIDTH;

      robot.y = (robot.y + robot.vy) % HEIGHT;

    });

  }

​

  // Reset timeStep to normal speed

  timeStep = 0.005;

  canvas.parent("canvas-container");

  frameRate(60);

  noStroke();

  textFont("Consolas"); // Use Consolas or a similar code-like font

  // saveGif('AoC2024-14.gif', 12)

}

​

function draw() {

  clear();

  background(0, 0, 0, 100);

​

  elapsedTime += timeStep;

​

  if (!hasPaused && elapsedTime >= lerpEndTime) {

    // Start pause

    animationPaused = true;

    pauseStartTime = elapsedTime;

    hasPaused = true;

    lastFlickerTime = elapsedTime;

  }

​

  if (animationPaused) {

    if (elapsedTime - pauseStartTime >= pauseDuration) {

      animationPaused = false; // Resume animation

    } else {

      handleFlickering();

    }

  } else {

    robots.forEach((robot) => {

      robot.x = (robot.x + robot.vx * timeStep + WIDTH) % WIDTH;

      robot.y = (robot.y + robot.vy * timeStep + HEIGHT) % HEIGHT;

    });

  }

​

  robots.forEach((robot) => {

    let isInCentralRange =

      robot.x > 33 && robot.x < 65 && robot.y > 31 && robot.y < 66;

​

    let targetColor;

    if (isInCentralRange) {

      targetColor = color(0, 255, 0); // Green

    } else {

      targetColor = color(255, 255, 0); // Yellow

    }

​

    let lerpFactor;

​

    if (elapsedTime < lerpStartTime) {

      lerpFactor = 0;

      robot.currentColor = color(255, 255, 255); // White

    } else if (elapsedTime >= lerpStartTime && elapsedTime < lerpEndTime) {

      let normalizedTime =

        (elapsedTime - lerpStartTime) / (lerpEndTime - lerpStartTime);

      lerpFactor = normalizedTime ** 2; // Exponential ease-in (can be adjusted)

      robot.currentColor = lerpColor(

        color(255, 255, 255),

        targetColor,

        lerpFactor

      );

    } else if (

      hasPaused &&

      elapsedTime >= lerpEndTime &&

      elapsedTime < lerpEndTime + pauseDuration

    ) {

      lerpFactor = 1;

      robot.currentColor = targetColor;

    } else {

      lerpFactor = 1;

      robot.currentColor = targetColor;

    }

​

    let isVisible = true;

    if (animationPaused && !isInCentralRange) {

      isVisible = flickerState;

      push();

​

      noStroke();

​

      if (flickerState) {

        fill(255, 0, 0);

      } else {

        fill(0, 255, 0);

      }

​

      textAlign(CENTER, CENTER);

​

      textFont("Arial Rounded MT Bold"); // Use the font family

​

      textSize(36);

​

      // Draw text at a slightly lower position to avoid clipping

      text("MERRY CHRISTMAS", width / 2, 50);

​

      pop();

    }

​

    if (isVisible) {

      fill(robot.currentColor);

      rect(robot.x * SCALE, robot.y * SCALE, SCALE, SCALE);

    }

  });

​

  // Display elapsed time

  let displayTime;

  if (

    hasPaused &&

    elapsedTime >= lerpEndTime &&

    elapsedTime < lerpEndTime + pauseDuration

  ) {

    displayTime = (solutionPositionDisp + lerpEndTime).toFixed(1);

  } else {

    displayTime = (solutionPositionDisp + elapsedTime).toFixed(1);

  }

​

  push();

  fill(255);

  textSize(16);

  textAlign(LEFT, TOP);

  textSize(14);

  text(`t=${displayTime}`, width - 68, height - 20);

}

​

function handleFlickering() {

  // Check if it's time to toggle the flicker state

  if (elapsedTime - lastFlickerTime >= flickerInterval) {

    flickerState = !flickerState; // Toggle visibility

    lastFlickerTime = elapsedTime; // Reset the last flicker time

  }

}

​

function parseInput(data) {

  // Parse input data and initialize robots

  data.forEach((line) => {

    const match = line.match(/p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)/);

    if (match) {

      const [_, px, py, vx, vy] = match.map(Number);

      robots.push({

        x: px,

        y: py,

        vx: vx,

        vy: vy,

        currentColor: color(255, 255, 255), // Initialize with white color

      });

    }

  });

}

​

function keyPressed() {

  // Adjust simulation speed and direction

  if (key === "w") {

    timeStep *= 1.5; // Speed up by 50%

  } else if (key === "s") {

    timeStep /= 1.5; // Slow down by ~50?%

  } else if (key === "a") {

    timeStep = -Math.abs(timeStep); // Make time move backward

  } else if (key === "d") {

    timeStep = Math.abs(timeStep); // Make time move forward

  }

}

​