Cody's mind

function preload() {
  // Load font with error handling
  font = loadFont('https://unpkg.com/@fontsource/roboto@latest/files/roboto-latin-400-normal.woff',
    () => console.log('Font loaded successfully'),
    (error) => {
      console.error('Failed to load font:', error);
      loadingError = true;
      loadingErrorMessage = "Failed to load font. Check console for details.";
    }
  );

  // Removed all loadImage calls to eliminate image loading issues
}

function setup() {
  createCanvas(windowWidth, windowHeight);
  if (loadingError) {
    // If there was a loading error, display the message and stop the sketch
    background(20);
    fill(255, 0, 0); // Red text for error
    textSize(24);
    textAlign(CENTER, CENTER);
    text(loadingErrorMessage, width / 2, height / 2);
    noLoop(); // Stop draw() from looping
    return; // Exit setup
  }

  textFont(font);
  textAlign(CENTER, CENTER);
  noStroke();

  // Draw a static radial gradient background once in setup
  let c1 = color(10, 10, 20);  // Dark blue-grey
  let c2 = color(0, 0, 0);   // Black
  for (let r = max(width, height); r > 0; r -= 10) {
    fill(lerpColor(c1, c2, r / max(width, height)));
    ellipse(width / 2, height / 2, r, r);
  }

  // Create particles
  for (let i = 0; i < particleCount; i++) {
    particles.push(new Particle());
  }

  // Initial generative content (now only text)
  createGenerativeContent();
}

function draw() {
  // If there was a loading error, setup() would have called noLoop(), so this won't run.
  // Draw background with transparency to create trails
  background(10, 50);

  // --- Title and Author Line ---
  fill(255);
  textSize(min(width * 0.06, 60)); // Responsive title size
  text("Cody's Thought Network", width / 2, height * 0.12);
  fill(200);
  textSize(min(width * 0.02, 20)); // Responsive subtitle size
  text("A Generative AI Art Piece", width / 2, height * 0.18);

  // --- Central Core ---
  let coreX = width / 2;
  let coreY = height / 2;
  let currentCoreSize = coreSize + sin(frameCount * 0.05) * 15; // Pulsating effect
  fill(0, 150, 255, 100); // Blue, semi-transparent
  ellipse(coreX, coreY, currentCoreSize, currentCoreSize);
  fill(0, 150, 255, 200); // Brighter blue
  ellipse(coreX, coreY, currentCoreSize * 0.6, currentCoreSize * 0.6);

  // --- Particle Network ---
  let connectDistance = width * connectDistanceRatio; // Calculate responsive connection distance
  for (let p of particles) {
    p.update();
    p.display();
    p.connect(particles, connectDistance); // Pass responsive distance
    p.attract(coreX, coreY); // Attract to the central core
  }

  // --- Generative Content ---
  // Add new thought every contentFrequency frames
  if (frameCount % contentFrequency === 0) {
    createGenerativeContent();
  }

  // Update and display contents
  for (let i = generativeContents.length - 1; i >= 0; i--) {
    generativeContents[i].update();
    generativeContents[i].display();
    if (generativeContents[i].isFaded()) {
      generativeContents.splice(i, 1); // Remove faded contents
    }
  }

  // --- Instructions ---
  fill(200);
  textSize(min(width * 0.015, 14)); // Responsive instruction size
  text("Press any key to generate a new thought! (And trigger a burst of processing)", width / 2, height - 20);
}

function createGenerativeContent() {
  // Now only creates text content
  let newContent;
  let maxAttempts = 10; // Try a few times to find a non-overlapping position

  for (let i = 0; i < maxAttempts; i++) {
    newContent = new GenerativeContent(random(thoughts));
    // If text is wider than screen, it will always overlap with itself when centered.
    // Skip creating it if it's too wide.
    if (newContent.getBoundingBox().w > width * 0.9) {
      console.log("Thought too wide, skipping.");
      continue;
    }

    let overlaps = false;
    // Check for overlap with existing content
    for (let existingContent of generativeContents) {
      if (rectsOverlap(newContent.getBoundingBox(), existingContent.getBoundingBox())) {
        overlaps = true;
        break;
      }
    }
    if (!overlaps) {
      generativeContents.push(newContent);
      return; // Added successfully
    }
  }
  // If we reach here, couldn't find a clear spot after maxAttempts
  console.log("Could not find a non-overlapping position for new thought.");
}

// Helper function to check if two rectangles overlap
function rectsOverlap(rect1, rect2) {
  return rect1.x < rect2.x + rect2.w &&
         rect1.x + rect1.w > rect2.x &&
         rect1.y < rect2.y + rect2.h &&
         rect1.y + rect1.h > rect2.y;
}

function keyPressed() {
  // Generate a new thought and slightly intensify particles
  createGenerativeContent();
  for (let p of particles) {
    p.intensify(0.1); // Briefly speed up particles
  }
  // Make contents appear more frequently for a few frames after interaction
  contentFrequency = 30; // Faster for 2 seconds
  setTimeout(() => contentFrequency = 180, 2000); // Reset after 2 seconds
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  background(10); // Redraw dark background on resize
  // Re-draw the static gradient in setup() to fill the new size
  setup();
}

// --- Particle Class ---
class Particle {
  constructor() {
    this.pos = createVector(random(width), random(height));
    this.vel = p5.Vector.random2D();
    this.vel.setMag(random(1, 2));
    this.acc = createVector();
    this.maxSpeed = 3;
    this.maxForce = 0.1;
    this.r = 4;
    this.alpha = random(50, 150);
  }

  update() {
    this.vel.add(this.acc);
    this.vel.limit(this.maxSpeed);
    this.pos.add(this.vel);
    this.acc.mult(0); // Reset acceleration

    // Wrap around edges
    if (this.pos.x < 0) this.pos.x = width;
    if (this.pos.x > width) this.pos.x = 0;
    if (this.pos.y < 0) this.pos.y = height;
    if (this.pos.y > height) this.pos.y = 0;
  }

  display() {
    fill(0, 150, 255, this.alpha);
    noStroke();
    ellipse(this.pos.x, this.pos.y, this.r * 0.5);
  }

  connect(particles, connectDistance) { // Added connectDistance parameter
    for (let other of particles) {
      let d = p5.Vector.dist(this.pos, other.pos);
      if (d < connectDistance) { // Connect if within the responsive distance
        stroke(0, 150, 255, map(d, 0, connectDistance, 100, 0)); // Fade connections
        strokeWeight(0.5);
        line(this.pos.x, this.pos.y, other.pos.x, other.pos.y);
      }
    }
  }

  attract(targetX, targetY) {
    let target = createVector(targetX, targetY);
    let force = p5.Vector.sub(target, this.pos);
    force.setMag(this.maxForce); // Gentle attraction
    this.acc.add(force);
  }

  intensify(factor) {
    this.vel.mult(1 + factor);
    this.vel.limit(this.maxSpeed * 2); // Temporarily increase max speed
    setTimeout(() => this.vel.limit(this.maxSpeed), 500); // Reset after 0.5 seconds
  }
}

// --- GenerativeContent Class (now only handles text) ---
class GenerativeContent {
  constructor(text) {
    this.type = 'text'; // Always text now
    this.text = text;
    this.alpha = 255;
    this.pos = createVector(width / 2, height / 2 + random(-100, 100));
    this.vel = createVector(random(-1, 1), random(-0.5, -1.5));
    this.size = random(20, 30);
    this.fadeRate = random(1, 3);

    // Calculate initial bounding box
    this.calculateBoundingBox();
  }

  update() {
    this.pos.add(this.vel);
    this.alpha -= this.fadeRate;
    // Recalculate bounding box as position changes
    this.calculateBoundingBox();
  }

  display() {
    if (this.alpha > 0) {
      // Draw semi-transparent black backdrop rectangle
      fill(0, 0, 0, this.alpha * 0.7); // 70% of current text alpha
      rectMode(CENTER);
      rect(this.pos.x, this.pos.y, this.textW + this.padding * 2, this.textH + this.padding, 5); // Rounded corners

      // Draw white text on top
      fill(255, this.alpha); // White text fading out
      textSize(this.size);
      text(this.text, this.pos.x, this.pos.y);
    }
  }

  isFaded() {
    return this.alpha <= 0;
  }

  calculateBoundingBox() {
    textSize(this.size); // Set size to get accurate dimensions
    this.textW = textWidth(this.text);
    this.textH = textAscent() + textDescent();
    this.padding = 10; // Padding around the text
    this.bbox = {
      x: this.pos.x - (this.textW + this.padding * 2) / 2,
      y: this.pos.y - (this.textH + this.padding) / 2,
      w: this.textW + this.padding * 2,
      h: this.textH + this.padding
    };
  }

  getBoundingBox() {
    return this.bbox;
  }
}