let temp = 0;

let shooters = [];

let O = [5677, 69897]; // Coordinates of the top-left corner

let w = 7545 - O[0]; // Absolute width of the map segment

let s = 844 / w; // Scale factor from map coordinates to the canvas

let vej = [];

let inputs = [];

let Time = 0;

let bullets = [];

let ebullets = [];

let ani = 0;

let svings = [];

let enemies;

let prox = [[], [], [],[]];

let rev = 0;

function setup() {

  createCanvas(844, 690);

  // Make the shooters

  shooters.push(

    new shooter("Camikaze", [6706, 68572], 515, 850, 500 / 60, [

      0,

      (6.55 * PI) / 180,

    ])

  );

  shooters.push(

    new shooter("Shakira", [6238, 69187], 517, 744, 25 / 60, [

      0,

      (13.9 * PI) / 180,

    ])

  );

  shooters.push(

    new shooter("Vương Thừa Vũ", [5785, 67202], 515, 853, 10, [0, (0.4 * PI) / 180])

  );

  shooters.push(

    new shooter("Stegepanden", [6711, 69287], 537, 600, 15 / 60, [

      0,

      (3.1 * PI) / 180,

    ])

  );

  shooters.push(

    new shooter("Stella", [6192, 69336], 512, 600, 5, [0, (1 * PI) / 180])

  );

  shooters.push(new shooter('Napoleon Torn-Aparte',[11511,68593],510,1000,100,[171.07089,1.1437]))

  shooters.push(new shooter('người thợ đốn gỗ',[6485,68983],515,280,10,[0,0]))

  img = loadImage("baghold.png"); // Loading background

  // Adding roads

  vej.push(new dLine([7500, 69700], [7412, 69690], "red", 10));

  vej.push(new dLine([7412, 69539], [7217, 68811], "red", 10)); // I define the target road

  vej.push(new dLine([7093, 68758], [6555, 68937], "red", 10));

  vej.push(new sving([6542, 68833],100))

  vej.push(new dLine([6451, 68887], [6385, 68609], "red", 10));

  vej.push(new dLine([6374, 68609], [5800, 68250], "red", 10));

​

  svings.push(new sving([7200, 68900], 100));

  for (let i = 0; i < shooters.length; i++) {

  let v =(i==5) ? ["171.07089","1.1437"]:(i==1)?["0","0,20845"]: (i==3)?["5","-2.29"]:(i==6)?['35.2','-0.47']:['80','-1.7']

  inputs.push([createInput(v[0]), createInput(v[1]),createInput(shooters[i].cs),createInput('1')]);

    inputs[i][0].position(width, i * 100+40);

    inputs[i][1].position(width, i * 100 + 60);

    inputs[i][2].position(width,i*100)

    inputs[i][3].position(width,i*100+20)

    bullets.push(new bullet());

  }

  enemies = new enemy();

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

    enemies.add(i);

    ebullets.push(new bullet());

  }

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

    prox[0].push([0]);

    prox[1].push([dst(shooters[0].x, roads(i, 1))]);

    prox[2].push([roads(i, 1).ang(shooters[0].x)]);

    prox[3].push([60])

    for (let j = 1; j < shooters.length; j++) {

      let k=0

      //print(prox[0][i][k])

      //print(prox[1][i][k])

      //print(dst(shooters[j].x,roads(i,1)))

      while(dst(shooters[j].x,roads(i,1))>prox[1][i][k]){k++}

      prox[0][i].splice(k,0,j)

      prox[1][i].splice(k,0,dst(shooters[j].x,roads(i,1)))

      prox[2][i].splice(k,0,roads(i, 1).ang(shooters[j].x))

      prox[3][i].splice(k,0,55)

      }

    }

  prox[3][6]=150

  //print(prox[0])

  }

function draw() {

  background(220);

  image(img, 0, 0);

  strokeWeight(10);

  enemies.drive();

  // If the animation is on, create and fire bullets

  if (ani > 0) {

    for (let i = 0; i < shooters.length; i++) {

      if (inputs[i][3].value()=='1'&&Time-shooters[i].tf> round(60/shooters[i].r)) {

        bullets[i].add(

          structuredClone(shooters[i].x),

          structuredClone(shooters[i].z),

          structuredClone(shooters[i].a),

          structuredClone(shooters[i].v)

        );

        shooters[i].tf=Time

      }

      bullets[i].update();

    }

      Time += 1;

    ani = (Time+600) % 60;

  }

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

    ebullets[i].stat()

    enemies.returnFire()

  }

  for (i = 0; i < shooters.length; i++) {

    shooters[i].stat();

    bullets[i].stat();

  }

​

  text("Tid: " + str(Time/ 60-10), 10, 20);

  strokeWeight(10);

  let temp = roads(55,1)

}

function keyPressed() {

  ani = int(keyCode == 32); // Space-bar

  rev -= 1 - ani; // Reversing status

  //Time -= 60 * (1 - ani); // Reversing time

    for (let i = 0; i < shooters.length; i++) {

       if (inputs[i][3].value()==1) {

      shooters[i].a = [

        (inputs[i][0].value() * PI) / 180,

        (inputs[i][1].value() * PI) / 180,

      ];

    }

  }

}

class enemy {

  constructor() {

    this.t = [];

    this.hp = [];

  }

  add(t) {

    this.t.push(t);

    this.hp.push(100);

  }

  drive() {

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

      roads(Time/60-this.t[i]);

      stroke(1)

      stroke('black')

      text(this.t[i],coord(roads(Time/60-this.t[i],1)).x[0]-30,coord(roads(Time/60-this.t[i],1)).x[1]-40)

    }

  }

  returnFire() {

    for(let i=0;i<this.t.length;i++){

      let temp=random()

      let j=0

      while(inputs[prox[0][i][j]][3].value()=='0'){j++}

      j=j%7

      text(str(prox[0][min(max(round(Time/60-this.t[i]),0),130)][j]),coord(roads(Time/60-this.t[i],1)).x[0]+10,coord(roads(Time/60-this.t[i],1)).x[1]+40)

      if(Time/60-this.t[i]>0&&temp<pow(0.1,prox[1][min(round(Time/60-this.t[i]),130)][j]/prox[3][i][j])){

        let ttemp=shooters[prox[0][round(Time/60-this.t[i])][j]]

        print("Shooter "+shooters[prox[0][round(Time/60-this.t[i])][j]].cs+" has been hit.")

      }      

    }

  }

}

// Shooter class to make it easy to add new shooters without having to enter everything manually

class shooter {

  constructor(cs, x, z, v, r, a) {

    this.cs = cs; // Call-sign

    this.x = new vec(x); // Coordinates

    this.z = z;

    this.v = v; // Speed

    this.r = r; // Rate of fire

    this.a = a; // Angle

    this.tf = 0; // Time of last firing

    this.bullets = [];

  }

  stat() {

    strokeWeight(5);

    fill("white");

    stroke("black");

    text(

      this.cs,

      coord(this.x).x[0] - textWidth(this.cs),

      coord(this.x).x[1] + 15

    );

    stroke("white");

    point(coord(this.x).x[0], coord(this.x).x[1]);

    strokeWeight(1);

    strokeWeight(2);

    point(550, 884 - (this.h - 110) * 3);

    stroke("black");

  }

}

class bullet {

  constructor() {

    this.x = [];

    this.a = [];

    this.v = [];

    this.t = [];

    this.i = [];

  }

  add(s, z, a, v) {

    this.x.push(new vec([s.x[0], s.x[1], z]));

    this.a.push(new vec(a));

    this.v.push(

      new vec([

        (v * cos(a[1]) * cos(a[0]))/60,

        (v * cos(a[1]) * sin(a[0]))/60,

        (v * sin(a[1]))/60,

      ])

    );

    this.t.push(Time);

    this.i.push(0);

  }

  update() {

    for (let i = 0; i < this.x.length; i++) {

      if (this.i[i] != 1) {

        this.v[i].x[2] = this.v[i].x[2] - 1/360 ;

        if (this.x[i].add(this.v[i]).x[2] > 505) {

          this.x[i]=this.x[i].add(this.v[i]);

        }else{

          this.i[i] = 1;

        }

      }

    }

  }

  stat() {

    for (let i = 0; i < this.x.length; i++) {

      stroke(255 * (1 - this.i[i]));

      strokeWeight(pow(5, 1 - this.i[i]));

      point(coord(this.x[i]).x[0], coord(this.x[i]).x[1]);

      strokeWeight(1);

    }

  }

}

class sving {

  constructor(c, r) {

    this.c = new vec(c);

    this.r = r;

    this.ω = 25 / r;

    this.φ = -PI/3

  }

  draw() {

    noFill();

    stroke("red");

    strokeWeight(10);

    circle(coord(this.c).x[0], coord(this.c).x[1], this.r);

  }

  func(t) {

    return this.c.add(new vec([cos(this.ω * t/60+this.φ), sin(this.ω * t/60+this.φ)]).mult(this.r));

  }

}

function roads(t, v) {

  let n = 0;

  if (t < 2) {

    n = 0;

  } else if (t < 42) {

    n = 1;

  } else if (t < 66) {

    n = 2;

  } else if (t  < 75) {

    n = 3;

  } else if(t  <83) {

    n = 4;

  }else{

    n=5

  }

  // Determines which road we're on and adjusts the time for the correct position

  if (v === undefined) {

    stroke("pink");

    strokeWeight(9.4);

    let temp=coord(vej[n].func(t*60 -

            490 * (n > 0) -

            2255 * (n > 1) -

            740 * (n > 2) -

            880 * (n > 3) -

            690 * (n>4)

        ))

    point(temp.x[0],temp.x[1])

    stroke(Time-t*60 == 600 ? "red" : "green");

    strokeWeight(4.7);

    point(temp.x[0],temp.x[1]);

  } else {

    return vej[n].func(t*60 -

            490 * (n > 0) -

            2255 * (n > 1) -

            740 * (n > 2) -

            880 * (n > 3) -

            690 * (n>4));

  }

}

// Mathematics section:

// Calculates map coordinates to canvas coordinates

function coord(x) {

  return new vec([(x.x[0] - O[0]) * s, (O[1] - x.x[1]) * s]);

}

// Calculates distance between to vectors

function dst(v, w) {

  return v.add(w.mult(-1)).len;

}

class vec {

  constructor(x, l) {

    let tlen = 0;

    for (let i = 0; i < x.length; i++) {

      tlen += sq(x[i]);

    }

    tlen = sqrt(tlen);

    if (l === undefined) {

      // If the length is not designated:

      this.x = x;

      this.len = tlen;

    } else {

      // If it is:

      this.len = l;

      this.x = [];

      for (let i = 0; i < x.length; i++) {

        this.x.push(x[i] / tlen);

      }

    }

  }

  // Adds the vector x

  add(x) {

    let w = [];

    for (let i = 0; i < this.x.length; i++) {

      w.push(this.x[i] + x.x[i]);

    }

    return new vec(w);

  }

  // Multiplies by a scalar

  mult(k) {

    let w = [];

    for (let i = 0; i < this.x.length; i++) {

      w.push(this.x[i] * k);

    }

    return new vec(w);

  }

  // Calculates the CO-vector

  co() {

    return new vec([-this.x[1], this.x[0]]);

  }

  // Calculates the scalar product

  dot(x) {

    let s = 0;

    for (let i = 0; i < this.x.length; i++) {

      s += x.x[i] * this.x[i];

    }

    return s;

  }

  // Calculates the magnitude of the vector

  len() {

    let s = 0;

    for (let i = 0; i < this.x.length; i++) {

      s += sq(this.x[i]);

    }

    return sqrt(s);

  }

  // Extends vector by k

  ext(k) {

    this.x.push(k);

    this.len = sqrt(sq(this.len) + sq(k));

  }

  // Calculates angle to v

  ang(v) {

    return (acos(this.dot(v) / this.len / v.len) * 180) / PI;

  }

}

// I make a line class that has a method that allows me to calculate the distance from a point to it.

class dLine {

  constructor(x1, x2, c, w) {

    if (w === undefined) {

      this.w = 1;

    } else {

      this.w = w;

    }

    if (c === undefined) {

      this.colour = "black";

    } else {

      this.colour = c;

    }

    this.z = 505;

    this.x1 = new vec(x1);

    this.x2 = new vec(x2);

    let temp = this.x2.add(this.x1.mult(-1)); // Making unit vector

    this.r = temp.mult(25 /60/ temp.len); // Directional vector

    this.n = this.r.co(); // Normal vector

    this.c = -this.n.dot(this.x1); // Line equation constant

    this.length = this.n.len; // Length of the line/normal vector.

  }

  draw() {

    stroke(this.colour);

    strokeWeight(this.w);

    line(

      coord(this.x1).x[0],

      coord(this.x1).x[1],

      coord(this.x2).x[0],

      coord(this.x2).x[1]

    );

    stroke("black");

    strokeWeight(1);

  }

  // This method measures the distance from a point with coordinates (x,y) to the line

  dist(x) {

    // If the shortest path to the line is to one of the end points, I take the shortest of these distances

    if (

      max(

        dist(x.x[0], x.x[1], this.x1.x[0], this.x1.x[1]),

        dist(x.x[0], x.x[1], this.x2.x[0], this.x2.x[1])

      ) > this.length

    ) {

      return min(

        dist(x.x[0], x.x[1], this.x1.x[0], this.x1.x[1]),

        dist(x.x[0], x.x[1], this.x2.x[0], this.x2.x[1])

      );

    } else {

      // else I use the distance formula

      return abs(this.n.dot(x) + this.c) / this.n.len;

    }

  }

  func(t) {

    return this.r.mult(t).add(this.x1);

  }

}

​