AI Gravity Wells - Orbital Physics Particle Simulation - xelsed.ai

function setup() {
  createCanvas(windowWidth, windowHeight);
  pixelDensity(1); // Improve performance, especially on high-DPI screens

  // Generate background stars once
  generateStars();

  // Create 3-4 initial gravity wells at random positions
  let numWells = floor(random(3, 5));
  for (let i = 0; i < numWells; i++) {
    gravityWells.push(new GravityWell(random(width), random(height), random(500, 2000)));
  }
}

function draw() {
  // Draw fading trails by drawing a semi-transparent black rectangle
  // This causes previous frames to fade out, creating the trail effect.
  background(0, 10);

  // Draw background stars
  drawStars();

  // Spawn new particles from the edges of the screen periodically
  if (frameCount % particleSpawnRate === 0) {
    particles.push(spawnParticle());
  }

  // Update and display gravity wells
  for (let well of gravityWells) {
    well.update();
    well.display();
  }

  // Update and display particles, applying gravity from all wells
  for (let i = particles.length - 1; i >= 0; i--) {
    let particle = particles[i];
    
    // Apply gravity from each well to the current particle
    for (let well of gravityWells) {
      particle.applyForce(well.getGravityForce(particle));
    }
    
    particle.update();
    particle.display();

    // Remove particles that go too far off-screen to maintain performance
    if (particle.isOffScreen()) {
      particles.splice(i, 1);
    }
  }

  // Clean up any wells that might have been marked for removal (e.g., mass <= 0)
  for (let i = gravityWells.length - 1; i >= 0; i--) {
    if (gravityWells[i].mass <= 0) { // Check if mass has been set to 0 or less
      gravityWells.splice(i, 1);
    }
  }
}

function generateStars() {
  for (let i = 0; i < numStars; i++) {
    stars.push({
      x: random(width),
      y: random(height),
      size: random(1, 3),
      brightness: random(100, 255)
    });
  }
}

function drawStars() {
  noStroke();
  blendMode(SCREEN); // Additive blending for stars to appear brighter
  for (let star of stars) {
    fill(star.brightness, star.brightness, star.brightness, 150);
    circle(star.x, star.y, star.size);
  }
  blendMode(NORMAL); // Reset blend mode for other drawing
}

function spawnParticle() {
  let x, y, vx, vy;
  let edge = floor(random(4)); // 0: top, 1: right, 2: bottom, 3: left

  // Vary initial speed slightly for more dynamic behavior
  let initialSpeed = random(1, 2);

  switch (edge) {
    case 0: // Top edge
      x = random(width);
      y = 0;
      vx = random(-initialSpeed, initialSpeed);
      vy = random(0.5, initialSpeed);
      break;
    case 1: // Right edge
      x = width;
      y = random(height);
      vx = random(-initialSpeed, -0.5);
      vy = random(-initialSpeed, initialSpeed);
      break;
    case 2: // Bottom edge
      x = random(width);
      y = height;
      vx = random(-initialSpeed, initialSpeed);
      vy = random(-initialSpeed, -0.5);
      break;
    case 3: // Left edge
      x = 0;
      y = random(height);
      vx = random(0.5, initialSpeed);
      vy = random(-initialSpeed, initialSpeed);
      break;
  }

  // Slight color variation for particles
  let pColor = color(random(150, 255), random(150, 255), random(150, 255));

  return new Particle(x, y, vx, vy, pColor);
}

function mousePressed() {
  if (mouseButton === LEFT) {
    // Add a new gravity well with a random mass
    gravityWells.push(new GravityWell(mouseX, mouseY, random(1000, 4000)));
  }
  // Prevent default right-click context menu
  return false; 
}

function mouseReleased() {
  if (mouseButton === RIGHT) {
    // If there are wells, find and remove the nearest one
    if (gravityWells.length > 0) {
      let minDist = Infinity;
      let nearestIndex = -1;

      for (let i = 0; i < gravityWells.length; i++) {
        let well = gravityWells[i];
        let d = dist(mouseX, mouseY, well.x, well.y);
        if (d < minDist) {
          minDist = d;
          nearestIndex = i;
        }
      }

      if (nearestIndex !== -1) {
        gravityWells.splice(nearestIndex, 1);
      }
    }
  }
  // Prevent default right-click context menu
  return false; 
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  // Re-generate stars for the new canvas size
  stars = [];
  generateStars();
}

constructor(x, y, mass) {
    this.x = x;
    this.y = y;
    this.mass = mass;
    // Visual size of the well core, mapped from its mass
    this.radius = map(mass, 500, 4000, 5, 20); 
    // Radius for checking nearby particles to influence glow
    this.glowRadius = this.radius * 2;
    this.glowBrightness = 0; // Current brightness of the well's glow
    // Random speed for the subtle brightness pulse
    this.pulseSpeed = random(0.02, 0.05); 
  }

update() {
    let nearbyParticles = 0;
    // Count particles within a certain range to determine glow intensity
    for (let particle of particles) {
      let d = dist(this.x, this.y, particle.position.x, particle.position.y);
      if (d < this.glowRadius * 2) {
        nearbyParticles++;
      }
    }
    // Map nearby particle count to glow brightness, capping at 100 particles
    this.glowBrightness = map(nearbyParticles, 0, 100, 0, 255, true); 
    
    // Add a subtle brightness pulse using sine wave
    this.glowBrightness += sin(frameCount * this.pulseSpeed) * 50;
    this.glowBrightness = constrain(this.glowBrightness, 0, 255); // Keep brightness within valid range
  }

display() {
    noStroke();
    
    // Draw the glow effect using additive blending
    blendMode(SCREEN); 
    for(let r = this.glowRadius; r > 0; r -= 2) {
      // Alpha fades out towards the edge of the glow
      let alpha = map(r, this.glowRadius, 0, 0, this.glowBrightness * 0.1);
      fill(200, 200, 255, alpha); // Soft blue-white glow
      circle(this.x, this.y, r * 2);
    }
    blendMode(NORMAL); // Reset blend mode for other elements
    
    // Draw the solid core of the gravity well
    fill(255); // White core
    circle(this.x, this.y, this.radius * 2);
  }

getGravityForce(particle) {
    // Vector pointing from particle to well
    let force = createVector(this.x - particle.position.x, this.y - particle.position.y);
    // Calculate distance squared, constrained to prevent division by zero and limit max distance
    // Particles inside the well's core experience force as if at the edge.
    let distanceSq = constrain(force.magSq(), this.radius * this.radius, 1000 * 1000); 
    // Calculate gravitational strength
    let strength = (G * this.mass) / distanceSq;
    
    // Limit max force to prevent particles from accelerating too wildly when very close
    strength = constrain(strength, 0, 10); 

    // Set the magnitude of the force vector
    force.setMag(strength);
    return force;
  }

constructor(x, y, vx, vy, pColor) {
    this.position = createVector(x, y);
    this.velocity = createVector(vx, vy);
    this.acceleration = createVector(0, 0);
    this.size = random(2, 5); // Random size for particles
    this.color = pColor; // Assigned color
    this.mass = 1; // For simplicity, particles have a mass of 1
  }

applyForce(force) {
    let f = force.copy();
    f.div(this.mass); 
    this.acceleration.add(f);
  }

update() {
    this.velocity.add(this.acceleration);
    this.velocity.limit(10); // Limit maximum speed of particles
    this.position.add(this.velocity);
    this.acceleration.mult(0); // Reset acceleration for the next frame
  }

display() {
    noStroke();
    fill(this.color);
    circle(this.position.x, this.position.y, this.size);
  }

isOffScreen() {
    let padding = 100; // Extra space before considering off-screen
    return (
      this.position.x < -padding ||
      this.position.x > width + padding ||
      this.position.y < -padding ||
      this.position.y > height + padding
    );
  }