const hexRadius = 20;
const hexLineWeight = 2;
const hexMargin = 0;
const drawHex = true;
const drawPoints = false;
const drawStraightLines = false;
const drawCurves = false;
const drawBoids = true;

const boidInitialVelocity = 4;
const boidMaxVelocity = 5;
const boidAvoidanceDist = hexRadius * 1.5;
const boidAvoidanceScalar = 0.02;
const boidCohesionDist = hexRadius * 2;
const boidCohesionScalar = 0.005;
const boidAlignDist = hexRadius * 3;
const boidAlignScalar = 0.2;

let hexHeight, hexWidth, columns, rows;
let hexagons = [];
let boids = [];
let boidCount = 200;

function setup() {
	hexWidth = hexRadius * 2;
	hexHeight = Math.sqrt(3)*hexRadius;
	columns = Math.ceil(window.innerWidth / (hexRadius * 3));
	rows = Math.ceil(window.innerHeight / (hexHeight / 2)) + 1;
	
  createCanvas((columns + 1/4) * (hexRadius * 3), (rows + 1) * (hexHeight / 2));
  frameRate(60);
	fill(255, 100);
  stroke(255);
  strokeWeight(5);
	noStroke();
	
	// initialise 2D array of hexagons
	for (let x = 0; x < columns; x++) {
		hexagons.push([]);
		for (let y = 0; y < rows; y++) {
			const active = Math.round(random()*0.6);
		  hexagons[x].push(new Hex(x, y, active));
		}
	}
	// neighbouring needs to be done after they're all initialised
	for (let x = 0; x < columns; x++) {
		for (let y = 0; y < rows; y++) {
		  hexagons[x][y].initialiseNeighbours(x, y);
		}
	}
	
	// initialise boids
	for	(let i = 0; i < boidCount; i++) {
		boids.push(new Boid(i));
	}
}

function draw() {
  background(0);
	for (let y = 0; y < rows; y++) {
		for (let x = 0; x < columns; x++) {
			let hex = hexagons[x][y];
			hex.draw();
			hex.checkActive();
		}
	}
	if (drawBoids) {
		for	(let i = 0; i < boidCount; i++) {
			boids[i].draw();
		}
	}
	update();
}

function update() {
	for (let y = 0; y < rows; y++) {
		for (let x = 0; x < columns; x++) {
			let hex = hexagons[x][y];
			hex.updateActive();
		}
	}
	for	(let i = 0; i < boidCount; i++) {
		boids[i].update();
	}
}


class Boid {
	constructor(i) {
		this.i = i;
		
		// establish pixel position
		this.pos = createVector(random(0, width), random(0, height));
		
		// establish random unit velictiy
		this.vel = p5.Vector.random2D().mult(boidInitialVelocity);
	}
	
	draw() {
		fill(255);
		ellipse(this.pos.x, this.pos.y, 5, 5);
	}
	
	update() {
		
    this.separate();
    this.cohesion();
    this.align();
    
    this.vel.limit(boidMaxVelocity);
		this.pos.add(this.vel);
		
		this.borders();
	
	}
	
	
  separate() {
    let result = createVector(0, 0);
    
    // loop through other boids
    for (let i = 0; i < boidCount; i++) {
      const other = boids[i];
      const dist = this.pos.dist(other.pos);
      // allow for other == this
      if (dist < boidAvoidanceDist && dist > 0) {
        result.sub(p5.Vector.sub(other.pos, this.pos));
      }
    }
    
    result.mult(boidAvoidanceScalar);
    this.vel.add(result);
  }
  
  
  cohesion() {
    let result = createVector(0, 0);
    let numNeighbours = 0;
    
    // loop through other boids
    for (let i = 0; i < boidCount; i++) {
      const other = boids[i];
      const dist = this.pos.dist(other.pos);
      // allow for other == this
      if (dist < boidCohesionDist && dist > 0) {
        result.add(other.pos);
        numNeighbours++;
      }
    }
    
    if (numNeighbours == 0) return;

    result.div(numNeighbours);
    result.sub(this.pos);
    result.mult(boidCohesionScalar);
    this.vel.add(result);
  }
  
  
  align() {
    let result = createVector(0, 0);
    let numNeighbours = 0;
    
    // loop through other boids
    for (let i = 0; i < boidCount; i++) {
      const other = boids[i];
      const dist = this.pos.dist(other.pos);
      // allow for other == this
      if (dist < boidAlignDist && dist > 0) {
        result.add(other.vel);
        numNeighbours++;
      }
    }
    
    if (numNeighbours == 0) return;
    
    result.div(numNeighbours);
    result.mult(boidAlignScalar);
    this.vel.add(result);
  }
	
	borders() {
    var wall = 0;
    if (this.pos.x > (width-wall) || this.pos.x < wall) {
      this.vel.x *= -1;
    }
    if (this.pos.y > (height-wall) || this.pos.y < wall) {
      this.vel.y *= -1;
    }
	}
}


class Hex {
	constructor(x, y, active) {
		
		// establish grid position
		this.pos = createVector(x, y);
		
		// establish pixel position
		this.pixelPos = createVector(0, 0);
		this.pixelPos.x = hexWidth * (1.5 * x + 0.5 + y % 2 * 0.75);
		this.pixelPos.y = hexHeight * (y * 0.5 + 0.5);
		
		// establish state
		this.active = active;
		this.nextActive = false;
		
		// establish neighbours
		this.neighbours = [];
	}
	
	initialiseNeighbours(x, y) {
		let n = [false, false, false, false, false, false];
		const odd = y%2;
		
		// above
		if (y >= 2) {
			n[0] = hexagons[x][y-2];
		}
		
		// top right
		if (y >= 1) {
			if (!odd || x < columns-1) {
				n[1] = hexagons[x+odd][y-1];
			}
		}
		
		// bottom right
		if (y < rows-1) {
			if (!odd || x < columns-1) {
				n[2] = hexagons[x+odd][y+1];
			}
		}
		
		// bottom
		if (y < rows-2) {
			n[3] = hexagons[x][y+2];
		}
		
		// bottom left
		if (y < rows-1) {
			if (odd || x >= 1) {
				n[4] = hexagons[x-1+odd][y+1];
			}
		}
		
		// top left
		if (y >= 1) {
			if (odd || x >= 1) {
				n[5] = hexagons[x-1+odd][y-1];
			}
		}

		this.neighbours = n;
	}
	
	updateActive() {
		this.active = this.nextActive;
	}
	
	countActiveNeighbours() {
		let activeNeighbours = 0;
		for (let i = 0; i < 6; i++) {
			if (this.neighbours[i] && this.neighbours[i].active) {
				activeNeighbours++;
			}
		}
		return activeNeighbours;
	}
	
	getActiveNeighbours() {
		let activeNeighbours = [];
		for (let i = 0; i < 6; i++) {
			if (this.neighbours[i] && this.neighbours[i].active) {
				activeNeighbours.push(true);
			} else {
				activeNeighbours.push(false);
			}
		}
		return activeNeighbours;
	}
	
	checkActive() {
		let activeNeighbours = this.countActiveNeighbours();
		this.nextActive = false;
		
		// loop through every boid and check target pos
		// appoximate by checking whether it's within the outer radius of the hexes
		for	(let i = 0; i < boidCount; i++) {
			var boidPos = boids[i].pos;
			if (boidPos.dist(this.pixelPos) < hexRadius) {
				this.nextActive = true;
			}
		}
	}
	
	checkNeighbours() {
		return true;
	}
	
	draw() {
		
		push();
		translate(this.pixelPos.x, this.pixelPos.y);
		
		// draw hexagon
		noStroke();
		if (this.active) {
			let activeNeighbours = this.countActiveNeighbours();
			fill(80-10*activeNeighbours, 20+40*activeNeighbours, 130+180*activeNeighbours, 100);
		} else {
			fill(0, 40);
		}
		if (drawHex) {
			beginShape();
			for (let i = 0; i < 6; i++) {
				vertex((hexRadius-hexMargin/2)*cos(i*Math.PI/3), (hexRadius-hexMargin/2)*sin(i*Math.PI/3));
			}
			endShape(CLOSE);
		}
		
		// draw shapes
		if (this.active) {
			let activeNeighboursCount = this.countActiveNeighbours();
			let activeNeighbours = this.getActiveNeighbours();
			stroke(255);
			strokeWeight(hexLineWeight);
			noFill();
			if (activeNeighboursCount == 0) {
				// for one
				if (drawPoints) {
					point(0, 0);
					// ellipse(0, 0, hexRadius/2);
				}
			} else if (activeNeighboursCount == 1) {
				// for two
				if (drawStraightLines) {
					var pos = getEdgePos(activeNeighbours.indexOf(true));
					line(0, 0, pos.x, pos.y);
				}
			} else {
				// for three
				if (drawCurves) {
					for (var i = 0; i < 6; i++) {
						if (activeNeighbours[i]) {
							for (var j = i+1; j < 6; j++) {
								if (activeNeighbours[j]) {
									var pos1 = getEdgePos(i);
									var pos2 = getEdgePos(j);
									beginShape();
									vertex(pos1.x, pos1.y);
									quadraticVertex(0, 0, pos2.x, pos2.y);
									endShape();
								}
							}
						}
					}
				}
			}
		}
		pop();
	}
}

function getEdgePos(i) {
	var pos = createVector(0, -hexHeight/2);
	pos.rotate(i*Math.PI/3);
	return pos;
}