trajectory.js

/**
 * Deep clone a collection of body objects for simulation.
 * Only clones necessary fields for gravity prediction.
 */
function cloneBodies(bodies) {
  return bodies.map(b => ({
    x: b.x,
    y: b.y,
    vx: b.vx,
    vy: b.vy,
    mass: b.mass,
    width: b.width,
    height: b.height,
    color: b.color,
    isRocket: b.isRocket
  }));
}

/**
 * Simulates all bodies together using a simple Euler integrator.
 * Returns an array of arrays: positions[i][j] is body i's position at step j.
 */
function computeFutureTrajectoriesAll(bodies, G, steps, stepSize) {
  let futureBodies = cloneBodies(bodies);
  let tracks = futureBodies.map(b => [{x: b.x, y: b.y}]);
  for (let s = 0; s < steps; s++) {
    // Compute accelerations for all
    let accels = futureBodies.map(() => ({ax: 0, ay: 0}));
    for (let i = 0; i < futureBodies.length; i++) {
      let b = futureBodies[i];
      for (let j = 0; j < futureBodies.length; j++) {
        if (i === j) continue;
        let other = futureBodies[j];
        let dx = other.x - b.x;
        let dy = other.y - b.y;
        let distSq = dx*dx + dy*dy;
        let dist = Math.sqrt(distSq);
        if (dist < 1) continue;
        let a = (G * other.mass) / distSq;
        accels[i].ax += a * dx / dist;
        accels[i].ay += a * dy / dist;
      }
    }
    // Update all positions and velocities
    for (let i = 0; i < futureBodies.length; i++) {
      let b = futureBodies[i], a = accels[i];
      b.vx += a.ax * stepSize;
      b.vy += a.ay * stepSize;
      b.x += b.vx * stepSize;
      b.y += b.vy * stepSize;
      tracks[i].push({x: b.x, y: b.y});
    }
  }
  return tracks;
}

/**
 * Trajectory tracker for any body.
 * Stores past trail and predicts future path.
 */
class Trajectory {
  /**
   * @param {Body} body        - The target body to track.
   * @param {number} maxPast   - How many trail points to store.
   * @param {number} futSteps  - Predict how many steps ahead.
   * @param {number} futStepSz - Prediction step size (dt).
   */
  constructor(body, maxPast = 10000, futSteps = 15000, futStepSz = 0.2) {
    this.bodyRef = body;             // Target body reference (can be used for index, etc)
    this.maxPastLength = maxPast;
    this.points = [];                // Past trail

    this.futureSteps = futSteps;
    this.futureStepSize = futStepSz;
    this.futurePoints = [];          // Predicted future positions (array of {x, y})
  }

  // Record current body position to trail
  addPoint(x, y) {
    this.points.push({ x, y });
    if (this.points.length > this.maxPastLength) {
      this.points.shift();
    }
  }

  // Predict future using only static other bodies (single-body prediction)
  computeFutureFixed(bodies, G) {
    // Predicts this.bodyRef in the field of static others.
    const body = this.bodyRef;
    let fx = body.vx, fy = body.vy;
    let px = body.x, py = body.y;
    const m = body.mass;
    this.futurePoints = [];
    for (let i = 0; i < this.futureSteps; i++) {
      let ax = 0, ay = 0;
      for (const other of bodies) {
        if (other === body) continue;
        const dx = other.x - px;
        const dy = other.y - py;
        const distSq = dx * dx + dy * dy;
        const dist = Math.sqrt(distSq);
        if (dist < 1) continue; // avoid singularity
        const a = (G * other.mass) / distSq;
        ax += a * dx / dist;
        ay += a * dy / dist;
      }
      fx += ax * this.futureStepSize;
      fy += ay * this.futureStepSize;
      px += fx * this.futureStepSize;
      py += fy * this.futureStepSize;
      this.futurePoints.push({ x: px, y: py });
    }
  }

  /**
   * Predicts future using n-body mutual simulation.
   *
   * @param {Array} bodies - All bodies in the universe (real ones; will be cloned).
   * @param {number} G     - Gravitational constant.
   */
  computeFutureInteracting(bodies, G) {
    // Find index of this body in the universe, to extract predicted track
    let idx = bodies.findIndex(b => b === this.bodyRef);
    if (idx < 0) return; // Not in bodies array
    let tracks = computeFutureTrajectoriesAll(bodies, G, this.futureSteps, this.futureStepSize);
    this.futurePoints = (tracks[idx] || []);
  }

  // Draw past path (white semi-transparent)
  drawPast(ctx, offsetX = 0, offsetY = 0) {
    if (this.points.length < 2) return;
    ctx.save();
    ctx.strokeStyle = 'rgba(255,255,255,0.35)';
    ctx.lineWidth = 1;
    ctx.beginPath();
    ctx.moveTo(this.points[0].x - offsetX, this.points[0].y - offsetY);
    for (let i = 1; i < this.points.length; i++) {
      ctx.lineTo(this.points[i].x - offsetX, this.points[i].y - offsetY);
    }
    ctx.stroke();
    ctx.restore();
  }

  // Draw future path (dotted cyan)
  drawFuture(ctx, offsetX = 0, offsetY = 0) {
    if (this.futurePoints.length < 2) return;
    ctx.save();
    ctx.strokeStyle = 'rgba(0,255,255,0.7)';
    ctx.lineWidth = 1;
    ctx.setLineDash([5, 5]); // dotted line
    ctx.beginPath();
    ctx.moveTo(this.futurePoints[0].x - offsetX, this.futurePoints[0].y - offsetY);
    for (let i = 1; i < this.futurePoints.length; i++) {
      ctx.lineTo(this.futurePoints[i].x - offsetX, this.futurePoints[i].y - offsetY);
    }
    ctx.stroke();
    ctx.setLineDash([]);
    ctx.restore();
  }
}