Tunnel

// Inspired by https://editor.p5js.org/colin.thil@gmail.com/sketches/BkvF-TUgm

// Simplified, refactored, and generally improved. Still plenty to work on.

​

let press,

    player,

    npcs = [],

    time,

    speed,

    highestSpeed = 0;

​

const HUE = 191,

      N_sides = 9,

      pathLength = 1000,

      NPC_chance = 0.005,

      defaultMaxDepth = 0.008,

      introSpeed = 0.01;

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  colorMode(HSB, 360, 100, 100);

  textFont("Georgia");

  textSize(16);

  player = new p5.Vector();

  init();

}

​

function windowResized() {

  resizeCanvas(windowWidth, windowHeight);

}

​

function draw() {

  background(color(HUE, 40, 50 + sin(time * speed) * 10));

  time ++;

  push();

  translate(width / 2, height / 2);

  scale(1 + speed * 9);

  translate(-width / 2, -height / 2);

  drawTunnel();

​

  if (!crash) {

    depth = Math.min(depth + maxDepth * introSpeed, maxDepth);

    if (depth >= maxDepth) {

      move(5);

      maxDepth = speed + defaultMaxDepth;

      if (!crash) {

        let amt = 0.01 * speed + 0.012;

        if (keyIsDown(LEFT_ARROW))  player.x -= amt;

        if (keyIsDown(RIGHT_ARROW)) player.x += amt;

​

        speed += 0.00005;

​

        drawSpaceship(player.x, player.y + 10, 10, new p5.Vector(width / 2, height / 2), true);

​

        maxspeed = Math.min(maxspeed, speed);

      }

    }

  } else {

    depth -= maxDepth * introSpeed * 2;

    if (depth <= 0) init();

  }

  pop();

  fill(360);

  textAlign(LEFT, TOP);

  text("Speed: " + round(1000 * speed), 10, 10);

  text("Highest: " + round(1000 * highestSpeed), 10, 30);

  highestSpeed = Math.max(highestSpeed, speed);

}

​

function init() {

  time = 0;

  speed = 0;

  crash = false;

  step = 20;

  inc = 0;

  depth = 0;

  maxDepth = defaultMaxDepth;

  maxspeed = 0;

  npcs = [];

  crash = false;

  playerLastPos = [];

  path = [];

  pathR = [];

  for (let i = 0; i < pathLength; i++) {

    pathR.push(0);

    path.push(newPath(i));

    playerLastPos.push(0);

  }

}

​

​

let cercleX = 0.00;

let cercleY = 0.00;

let angl = 0.00;

let angl1 = 0.00;

let angl2 = 0.00;

let anglCourt = 0.00;

let direct = 0.00;

let direct1 = 0.00;

let vt = 4;

let vtRotat = vt / 200000;

let rotat = 0;

let targetX = 0.00;

let targetY = 0.00;

​

function newPath(i) {

  let target = new p5.Vector(targetX, targetY);

  let rad = 180 / PI;

  if (abs(target.x - cercleX) < 10 && abs(target.y - cercleY) < 10) {

    target = newTarget(target);

  }

  angl = angl1 - angl2;

  if (abs(angl) > PI) {

    anglCourt = TWO_PI - abs(angl);

    if (angl > 0) anglCourt = -anglCourt;

  } else anglCourt = angl;

  rotat += vtRotat;

  if (direct < anglCourt + (rotat * vt)) direct += rotat * vt;

  if (direct >= anglCourt) direct -= rotat * vt;

  if (direct === 0) rotat = 0;

  if (direct == direct1) {

    direct = 0;

    angl2 = angl1;

    angl1 = atan2(target.y - cercleY, target.x - cercleX);

  }

  direct1 = direct;

  cercleX += (cos(direct + angl2) * vt);

  cercleY += (sin(direct + angl2) * vt);

  if (angl > 0) pathR[i] += rotat;

  else if (angl < 0) pathR[i] -= rotat;

  return new p5.Vector(cercleX, cercleY);

}

​

function newTarget(t) {

  let minRayon = height;

  let maxRayon = height;

  let newT = t;

  let o = random(0, 1);

  let r = random(0, 1);

  newT.x += sin(o * TWO_PI) * (r * maxRayon + minRayon);

  newT.y += cos(o * TWO_PI) * (r * maxRayon + minRayon);

  return newT;

}

​

function drawTunnel() {

  noSmooth();

  noStroke();

  let l = (pathLength / step - 2),

      cam = new p5.Vector(-path[0].x, -path[0].y);

  for (let i = l; i >= 0; i--) {

    let h = int(i * step + inc),

        h1 = int((i + 1) * step + inc),

        s = height / 2 / (1 + depth * h),

        x = (path[h].x + cam.x) / s + width / 2,

        y = (path[h].y + cam.y) / s + height / 2,

        s1 = height / 2 / (1 + depth * (h1)),

        x1 = (path[h1].x + cam.x) / s1 + width / 2,

        y1 = (path[h1].y + cam.y) / s1 + height / 2;

    if (i === 0) tube(x, y, height / 2, pathR[h - inc], x1, y1, s1, pathR[h1], 100 / h1);

    else tube(x, y, s, pathR[h], x1, y1, s1, pathR[h1], 100 / h1);

    for (npc of npcs) npc.draw(h, new p5.Vector(x, y));

  }

}

​

function tube(x, y, s, r, x1, y1, s1, r1, c) {

  let p = TWO_PI / float(N_sides);

  for (let i = 0; i < N_sides; i++) {

    let ip = p * i;

    let ip1 = p * (i + 1);

    let cs = cos(ip + r);

    let clr = color(HUE, 14 + c - cs * 14, 50 + c + cs * 30);

​

    fill(clr);

    quad(x + sin(ip + r) * s, y + cs * s, x1 + sin(ip + r1) * s1, y1 + cos(ip + r1) * s1, x1 + sin(ip1 + r1) * s1, y1 + cos(ip1 + r1) * s1, x + sin(ip1 + r) * s, y + cos(ip1 + r) * s);

  }

}

​

playerLastPos = [];

​

function move(m) {

  for (let h = 0; h < playerLastPos.length - 1; h++) {

    playerLastPos[h] = playerLastPos[h + 1];

  }

  playerLastPos[playerLastPos.length - 1] = player.x;

  for (let j = 0; j < m; j++) {

    for (let i = 0; i < pathLength - 1; i++) {

      path[i] = path[i + 1];

      pathR[i] = pathR[i + 1];

    }

    if (inc < 1) inc = step;

    inc--;

    path[pathLength - 1] = newPath(pathLength - 1);

    if (!crash) {

      for (let npc of npcs) npc.update();

      spawn();

    }

  }

}

​

function drawSpaceship(x, y, L, n, p) {

    let pX = x * N_sides;

    while (pX < 0) pX += N_sides;

    let s = height / 2 / (1 + depth * y);

    let o = (int(pX) + 0.5) * (TWO_PI / N_sides) + pathR[L];

    let l = (s * 0.64);

    let tx = (pX % 1 - 0.5) * l;

    push();

    translate(n.x, n.y);

    rotate(-o);

    translate(tx, s);

    scale(0.1 * s);

    noStroke();

    fill(HUE, 40, 20, 1);

    triangle(0, 0, 0, -1, 0.2, -0.2);

    triangle(0, -1, -1, 0, -0.2, -0.2);

    triangle(0, 0, 0, -1, -0.2, -0.2);

    triangle(0, -1, 1, 0, 0.2, -0.2);

    fill(360);

    s = 0.2 + sin(time * speed) * 0.05;

    ellipse(-0.5, -0.1, s, s);

    ellipse(0.5, -0.1, s, s);

    pop();

}

​

function spawn() {

  if (random() < NPC_chance) npcs.push(new NPC());

}

​

class NPC {

  constructor() {

    this.p = new p5.Vector(random(0, 1), pathLength);

    this.spd = new p5.Vector(0.002 * random(-1, 1), random(-1, -0.5));

  }

​

  draw(h, n) {

    if (h <= this.p.y && this.p.y <= h + step)

      drawSpaceship(this.p.x, this.p.y, int(this.p.y), n, false);

    if (0 < this.p.y && this.p.y < 16) {

      if (abs(this.p.x - player.x) < 0.03) {

        crash = true;

        npcs = [];

      }

    }

  }

​

  update() {

    this.p.add(this.spd);

    if (this.p.y < -1000) npcs.shift();

  }

}