const [
	EMPTY, SNAKE,
	FOOD, SUPER_FOOD, DECAY_FOOD,
	WALL,
	FIRE, FLAMMABLE, FLAMMABLE_S,
	HOLE, HOLE_S,
	PORTAL_A, PORTAL_A_S, PORTAL_B, PORTAL_B_S, PORTAL_C, PORTAL_C_S, PORTAL_D, PORTAL_D_S,
	KEY, DOOR,
	SWITCH_ON, SWITCH_ON_S, SWITCH_OFF, SWITCH_OFF_S, SPIKES_OFF, SPIKES_OFF_S, SPIKES_ON
]=Array(255).keys();

class SnekGame {
	constructor(settings, canvas, rules) {
		// setup the delay
		this.delay=settings.delay || Infinity;

		// score starts at 0
		this.score=0;

		// world is given in the level
		if(settings.world) { // explicitly

			// convert the world
			this.world=Array(settings.world[0].length);
			for(let x=0; x<this.world.length; x++) {
				this.world[x]=Array(settings.world.length);
				for(let y=0; y<this.world[x].length; y++) {
					this.world[x][y]=(() => {
						switch(settings.world[y][x]) {
							case ' ': return EMPTY;
							case 'f': return FOOD;
							case 'F': return SUPER_FOOD;
							case 'd': return DECAY_FOOD;
							case 'w': return WALL;
							case 'o': return HOLE;
							case 'i': return FIRE;
							case 'I': return FLAMMABLE;
							case 'A': return PORTAL_A;
							case 'B': return PORTAL_B;
							case 'C': return PORTAL_C;
							case 'D': return PORTAL_D;
							case 'k': return KEY;
							case 'K': return DOOR;
							case 's': return SWITCH_OFF;
							case 'S': return SPIKES_ON;
							case 't': return SPIKES_OFF;
						}
					})();
				}
			}

			// extract the dimensions
			this.dimensions=[this.world.length, this.world[0].length];

			// extract the fruits
			this.fruits=this.getTilesOfType(FOOD);

			// extract the decaying fruits
			this.decayFood=this.getTilesOfType(DECAY_FOOD);

			// extract the portals
			this.portals={};
			this.world.forEach((l, x) =>
				l.forEach((c, y) => {
					if(c==PORTAL_A) this.portals.a=[x, y];
					if(c==PORTAL_B) this.portals.b=[x, y];
					if(c==PORTAL_C) this.portals.c=[x, y];
					if(c==PORTAL_D) this.portals.d=[x, y];
				})
			);
		} else { // dimension and objects

			// get the dimensions
			this.dimensions=[...settings.dimensions];

			// build an empty world
			this.world=Array(settings.dimensions[0]);
			for(let i=0; i<settings.dimensions[0]; i++) {
				this.world[i]=Array(settings.dimensions[1]);
				this.world[i].fill(EMPTY);
			}

			// add the walls
			if(settings.walls) settings.walls.forEach(([x, y]) => this.world[x][y]=WALL);

			// add the holes
			if(settings.holes) settings.holes.forEach(([x, y]) => this.world[x][y]=HOLE);

			// add the fires and flammable tiles
			if(settings.fires) settings.fires.forEach(([x, y]) => this.world[x][y]=FIRE);
			if(settings.flammable) settings.flammable.forEach(([x, y]) => this.world[x][y]=FLAMMABLE);

			// add the food
			settings.food.forEach(([x, y]) => this.world[x][y]=FOOD);
			this.fruits=[...settings.food];

			// add the super food
			if(settings.superFood) settings.superFood.forEach(([x, y]) => this.world[x][y]=SUPER_FOOD);

			// add the decaying food
			if(settings.decayFood) {
				settings.decayFood.forEach(([x, y]) => this.world[x][y]=DECAY_FOOD);
				this.decayFood=settings.decayFood.map(([x, y]) => [x, y, 0]);
			} else {
				this.decayFood=[];
			}

			// add the portals
			if(settings.portals) {
				if(settings.portals.a) this.world[settings.portals.a[0]][settings.portals.a[1]]=PORTAL_A;
				if(settings.portals.b) this.world[settings.portals.b[0]][settings.portals.b[1]]=PORTAL_B;
				if(settings.portals.c) this.world[settings.portals.c[0]][settings.portals.c[1]]=PORTAL_C;
				if(settings.portals.d) this.world[settings.portals.d[0]][settings.portals.d[1]]=PORTAL_D;
				this.portals={...settings.portals};
			} else {
				this.portals={};
			}

			// add the keys
			if(settings.keys) settings.keys.forEach(([x, y]) => this.world[x][y]=KEY);

			// add the doors
			if(settings.doors) settings.doors.forEach(([x, y]) => this.world[x][y]=DOOR);

			// add the switches
			if(settings.switches) settings.switches.forEach(([x, y]) => this.world[x][y]=SWITCH_OFF);

			// add the spikes
			if(settings.spikesOn) settings.spikesOn.forEach(([x, y]) => this.world[x][y]=SPIKES_ON);
			if(settings.spikesOff) settings.spikesOff.forEach(([x, y]) => this.world[x][y]=SPIKES_OFF);
		}

		// add the snake to the world
		settings.snake.forEach(([x, y]) => this.world[x][y]=SNAKE);


		// get the head and initial direction
		this.head=[...settings.snake[0]];
		if(settings.snake.length>=2) this.direction=[
			settings.snake[0][0]-settings.snake[1][0],
			settings.snake[0][1]-settings.snake[1][1]
		];
		else this.direction=[
			1,
			0
		];
		this.lastDirection=this.direction

		// store the snake
		this.snake=[...settings.snake];
		this.length=this.snake.length;

		// get our canvas, like, if we want to actually draw
		this.canvas=canvas;
		this.ctx=canvas.getContext('2d');

		// load the custom rules
		this.rules=Object.assign({
			fruitRegrow: true,
			superFruitGrow: false,
			decayingFruitGrow: false,
			speedIncrease: true,
			worldWrap: true,
			winCondition: 'none',
			scoreSystem: 'fruit',
			fireTickSpeed: 10,
			autoSizeGrow: false,
			autoSpeedIncrease: false,
			timeFlow: true
		}, rules, settings.rules || {});

		// reset direction if time doesn't flow
		if(!this.rules.timeFlow) {
			this.lastDirection=[0, 0];
			this.direction=[0, 0];
		}

		// set score if move-based
		if(this.rules.scoreSystem=='moves') {
			this.score=this.rules.moveCount;
		}
	}

	get playTime() {
		return Date.now()-this.firstStep;
	}

	get speed() {
		return Math.round(1000/this.delay);
	}

	getTilesOfType(type) {
		return this
			.world
			.map(
				(l, x) => l
					.map(
						(r, y) => r==type?[x,y]:null
					).filter(
						a => a
					)
			).flat();
	}

	draw() {
		const assets=require('assets');
		const config=require('config');

		// clear the canvas, because it's easier than having to deal with everything
		this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);

		// get the cell size and offset
		const cellSize=Math.min(
			this.canvas.width/this.dimensions[0],
			this.canvas.height/this.dimensions[1]
		);
		const offsetX=(this.canvas.width-cellSize*this.dimensions[0])/2;
		const offsetY=(this.canvas.height-cellSize*this.dimensions[1])/2;

		// draw a grid/checkerboard if requested
		if(config.getS('appearance.grid')=='grid') {
			this.ctx.strokeStyle='rgba(0, 0, 0, 50%)';
			this.ctx.lineCap='square';
			this.ctx.lineWidth=1;
			this.ctx.beginPath();
			for(let x=1; x<this.dimensions[0]; x++) {
				this.ctx.moveTo(offsetX+x*cellSize, offsetY);
				this.ctx.lineTo(offsetX+x*cellSize, this.canvas.height-offsetY);
			}
			for(let y=1; y<this.dimensions[1]; y++) {
				this.ctx.moveTo(offsetX, offsetY+y*cellSize);
				this.ctx.lineTo(this.canvas.width-offsetX, offsetY+y*cellSize);
			}
			this.ctx.stroke();
		} else if(config.getS('appearance.grid')=='checkerboard') {
			this.ctx.fillStyle='rgba(0, 0, 0, 10%)';
			for(let x=0; x<this.dimensions[0]; x++) {
				for(let y=(x+1)%2; y<this.dimensions[1]; y+=2) {
					this.ctx.fillRect(offsetX+x*cellSize, offsetY+y*cellSize, cellSize, cellSize);
				}
			}
		}

		// draw our tiles
		const wall=assets.get('wall');
		const hole=assets.get('hole');
		const fire=assets.get('fire');
		const flammable=assets.get('flammable');
		const superFruit=assets.get('superFruit');
		const decayFruit=assets.get('decayFruit');
		const portalA=assets.get('portalA');
		const portalB=assets.get('portalB');
		const portalC=assets.get('portalC');
		const portalD=assets.get('portalD');
		const key=assets.get('key');
		const door=assets.get('door');
		const switchTile=assets.get('switch');
		const spikes=assets.get('spikes');
		const putTile=(x, y, tile) => this.ctx.drawImage(
			tile,
			offsetX+cellSize*x,
			offsetY+cellSize*y,
			cellSize,
			cellSize
		);
		const putTileAnim=(x, y, tile) => putTile(x, y, tile[
			Math.floor(Date.now()/1000*60+x+y)%tile.length
		]);
		const putTileAnimPercent=(x, y, tile, percent) => putTile(x, y, tile[
			Math.min(Math.round(percent*tile.length), tile.length-1)
		]);
		const checkAdj=(x, y) => {
			let adj={};
			adj.u=this.world[x][y-1];
			adj.d=this.world[x][y+1];
			adj.l=(this.world[x-1] || [])[y];
			adj.r=(this.world[x+1] || [])[y];
			adj.ul=(this.world[x-1] || [])[y-1];
			adj.ur=(this.world[x+1] || [])[y-1];
			adj.dl=(this.world[x-1] || [])[y+1];
			adj.dr=(this.world[x+1] || [])[y+1];
			return adj;
		};
		for(let x=0; x<this.dimensions[0]; x++) {
			for(let y=0; y<this.dimensions[1]; y++) {
				switch(this.world[x][y]) {
					case WALL:
						putTile(x, y, wall);
						break;

					case FIRE:
						putTileAnim(x, y, fire);
						break;

					case HOLE:
					case HOLE_S: {
						putTile(x, y, hole.base);
						let adj=checkAdj(x, y);
						Object
							.keys(adj)
							.filter(k => adj[k]==HOLE || adj[k]==HOLE_S)
							.forEach(k => putTile(x, y, hole[k]));
						break;
						// technically, this works for all shapes
						// however, the tileset only handles convex shapes
					}

					case FLAMMABLE:
					case FLAMMABLE_S:
						putTile(x, y, flammable);
						break;

					case SUPER_FOOD:
						putTileAnim(x, y, superFruit);
						break;

					case PORTAL_A:
					case PORTAL_A_S:
						putTileAnim(x, y, portalA);
						break;
					case PORTAL_B:
					case PORTAL_B_S:
						putTileAnim(x, y, portalB);
						break;
					case PORTAL_C:
					case PORTAL_C_S:
						putTileAnim(x, y, portalC);
						break;
					case PORTAL_D:
					case PORTAL_D_S:
						putTileAnim(x, y, portalD);
						break;

					case KEY:
						putTile(x, y, key);
						break;
					case DOOR:
						putTile(x, y, door);
						break;

					case SWITCH_ON:
					case SWITCH_ON_S:
						putTile(x, y, switchTile.on);
						break;
					case SWITCH_OFF:
					case SWITCH_OFF_S:
						putTile(x, y, switchTile.off);
						break;

					case SPIKES_ON:
						putTile(x, y, spikes.on);
						break;
					case SPIKES_OFF:
					case SPIKES_OFF_S:
						putTile(x, y, spikes.off);
						break;
				}
			}
		}

		// draw our decaying fruits (they have more information than just XY, so they need to be drawn here
		this.decayFood.forEach(([x, y, birth]) =>
			putTileAnimPercent(x, y, decayFruit, (this.playTime-birth)/2000)
		);

		// draw the lines between portals
		if(Object.keys(this.portals).length) {
			this.ctx.strokeStyle='rgba(128, 128, 128, 20%)';
			this.ctx.lineCap='round';
			this.ctx.lineWidth=cellSize*.15;
			const drawTunnel=([xa, ya], [xb, yb]) => {
				const angle=(Math.floor(Date.now()/10)%360)*(Math.PI/180);
				for(let i=0; i<=1; i++) {
					const dx=cellSize/3*Math.cos(angle+i*Math.PI);
					const dy=cellSize/3*Math.sin(angle+i*Math.PI);
					this.ctx.beginPath();
					this.ctx.moveTo(
						offsetX+cellSize*(xa+1/2)+dx,
						offsetY+cellSize*(ya+1/2)+dy
					);
					this.ctx.lineTo(
						offsetX+cellSize*(xb+1/2)+dx,
						offsetY+cellSize*(yb+1/2)+dy
					);
					this.ctx.stroke();
				}
			};
			if(this.portals.a && this.portals.b) drawTunnel(this.portals.a, this.portals.b);
			if(this.portals.c && this.portals.d) drawTunnel(this.portals.c, this.portals.d);
		}

		// draw our snake (it gets drawn completely differently, so here it goes)
		const snake=assets.get('snake');
		this.ctx.fillStyle=snake.color;
		this.ctx.strokeStyle=snake.color;
		this.ctx.lineCap=snake.cap;
		this.ctx.lineJoin=snake.join;
		this.ctx.lineWidth=cellSize*snake.tailSize;

		this.ctx.beginPath();
		this.ctx.ellipse(
			offsetX+cellSize*(this.snake[0][0]+1/2),
			offsetY+cellSize*(this.snake[0][1]+1/2),
			cellSize/2*snake.headSize,
			cellSize/2*snake.headSize,
			0,
			0,
			Math.PI*2
		);
		this.ctx.fill();

		this.ctx.beginPath();
		this.snake.forEach(([x, y], i, a) => {
			this.ctx.lineTo(
				offsetX+cellSize*(x+1/2),
				offsetY+cellSize*(y+1/2)
			);
			if(i!=0 && Math.hypot(x-a[i-1][0], y-a[i-1][1])>1) {
				this.ctx.lineWidth=cellSize*snake.tailWrapSize;
			} else {
				this.ctx.lineWidth=cellSize*snake.tailSize;
			}
			this.ctx.stroke();
			this.ctx.beginPath()
			this.ctx.moveTo(
				offsetX+cellSize*(x+1/2),
				offsetY+cellSize*(y+1/2)
			);
		});
		this.ctx.stroke();

		// our fruit has a nice animation to it between .8 and 1.2 scale
		const ms=Date.now();
		const fruitScale=Math.sin(ms/400*Math.PI)*.2+1
		const fruit=assets.get('fruit');
		this.fruits.forEach(([x, y]) => {
			this.ctx.drawImage(
				fruit,
				offsetX+cellSize*x+(1-fruitScale)*cellSize/2,
				offsetY+cellSize*y+(1-fruitScale)*cellSize/2,
				cellSize*fruitScale,
				cellSize*fruitScale
			);
		});

		// show the timer
		if(this.rules.winCondition=='time') {
			if(config.getS('appearance.timer')=='border' || config.getS('appearance.timer')=='both') {
				let remaining=(this.rules.gameDuration-this.playTime)/this.rules.gameDuration;
				const w=this.dimensions[0]*cellSize;
				const h=this.dimensions[1]*cellSize;
				const p=w*2+h*2;

				const wp=w/p;
				const hp=h/p;

				const pdst=(st, ed, frac) =>
					(ed-st)*frac+st;

				this.ctx.strokeStyle='#930a16';
				this.ctx.lineJoin='miter';
				this.ctx.lineCap='round';
				this.ctx.lineWidth=5;
				this.ctx.beginPath();
				this.ctx.moveTo(this.canvas.width/2, offsetY+2);

				let sp=Math.min(wp/2, remaining);
				remaining-=sp;
				this.ctx.lineTo(pdst(this.canvas.width/2, w+offsetX-2, sp/wp*2), offsetY+2);
				if(remaining) {
					sp=Math.min(hp, remaining);
					remaining-=sp;
					this.ctx.lineTo(w+offsetX-2, pdst(offsetY+2, offsetY+h-2, sp/hp));
				}
				if(remaining) {
					sp=Math.min(wp, remaining);
					remaining-=sp;
					this.ctx.lineTo(pdst(w+offsetX-2, offsetX+2, sp/wp), offsetY+h-2);
				}
				if(remaining) {
					sp=Math.min(hp, remaining);
					remaining-=sp;
					this.ctx.lineTo(offsetX+2, pdst(offsetY+h-2, offsetY+2, sp/hp));
				}
				if(remaining) {
					this.ctx.lineTo(pdst(offsetX+2, this.canvas.width/2, remaining/wp*2), offsetY+2);
				}
				this.ctx.stroke();
			}
			if(config.getS('appearance.timer')=='number' || config.getS('appearance.timer')=='both') {
				let remaining=''+Math.ceil((this.rules.gameDuration-this.playTime)/1000);
				while(remaining.length<(''+this.rules.gameDuration/1000).length) remaining='0'+remaining;

				this.ctx.fillStyle='#930a16';
				this.ctx.textAlign='center';
				this.ctx.textBaseline='middle';
				this.ctx.font='4rem "Fira Code"';
				this.ctx.fillText(remaining, this.canvas.width/2, this.canvas.height/2);
			}
		}

		// draw the border around our game area
		this.ctx.fillStyle='black';
		this.ctx.fillRect(0, 0, this.canvas.width, offsetY);
		this.ctx.fillRect(0, 0, offsetX, this.canvas.height);
		this.ctx.fillRect(offsetX+cellSize*this.dimensions[0], 0, offsetX, this.canvas.height);
		this.ctx.fillRect(0, offsetY+cellSize*this.dimensions[1], this.canvas.width, offsetY);
	}

	step() {
		this.tickId++;
		this.lastDirection=this.direction;

		// compute our new head
		let head;
		if(!this.portaled && [PORTAL_A_S, PORTAL_B_S, PORTAL_C_S, PORTAL_D_S].includes(this.world[this.snake[0][0]][this.snake[0][1]])) {
			const tile=this.world[this.snake[0][0]][this.snake[0][1]];
			if(tile==PORTAL_A_S) head=this.portals.b;
			if(tile==PORTAL_B_S) head=this.portals.a;
			if(tile==PORTAL_C_S) head=this.portals.d;
			if(tile==PORTAL_D_S) head=this.portals.c;
			this.portaled=true;
		} else {
			head=[
				this.snake[0][0]+this.direction[0],
				this.snake[0][1]+this.direction[1]
			];
			this.portaled=false;
		}

		// get our tail out of the way
		const tail=this.snake.pop();
		switch(this.world[tail[0]][tail[1]]) {
			case HOLE_S:
				this.world[tail[0]][tail[1]]=HOLE;
				break;
			case FLAMMABLE_S:
				this.world[tail[0]][tail[1]]=FLAMMABLE;
				break;
			case PORTAL_A_S:
				this.world[tail[0]][tail[1]]=PORTAL_A;
				break;
			case PORTAL_B_S:
				this.world[tail[0]][tail[1]]=PORTAL_B;
				break;
			case PORTAL_C_S:
				this.world[tail[0]][tail[1]]=PORTAL_C;
				break;
			case PORTAL_D_S:
				this.world[tail[0]][tail[1]]=PORTAL_D;
				break;
			case SWITCH_ON_S:
				this.world[tail[0]][tail[1]]=SWITCH_ON;
				break;
			case SWITCH_OFF_S:
				this.world[tail[0]][tail[1]]=SWITCH_OFF;
				break;
			case SPIKES_OFF_S:
				this.world[tail[0]][tail[1]]=SPIKES_OFF;
				break;
			default:
				this.world[tail[0]][tail[1]]=EMPTY;
		}

		// check for out of world conditions
		if(head[0]<0 || head[0]>=this.dimensions[0] || head[1]<0 || head[1]>=this.dimensions[1]) {
			if(this.rules.worldWrap) {
				head[0]=(head[0]+this.dimensions[0])%this.dimensions[0];
				head[1]=(head[1]+this.dimensions[1])%this.dimensions[1];
			} else {
				return this.die("literally fell out of the world", "exited the grid");
			}
		}

		switch(this.world[head[0]][head[1]]) {
			// you hit, you die
			case WALL: return this.die("thought walls were edible", "hit a wall");
			case FIRE: return this.die("burned to a crisp", "hit fire");
			case DOOR: return this.die("forgot to OPEN the door", "hit a door");
			case SPIKES_ON: return this.die("thought they were a girl's drink in a nightclub", "hit spikes");

			// congratilations, you played yourself!
			case SNAKE:
			case HOLE_S:
			case FLAMMABLE_S:
			case PORTAL_A_S:
			case PORTAL_B_S:
			case PORTAL_C_S:
			case PORTAL_D_S:
			case SWITCH_OFF_S:
			case SWITCH_ON_S:
			case SPIKES_OFF_S:
				return this.die("achieved every dog's dream", "ate their own tail");

			// if either 3 consecutive segments or the whole snake is on a hole, you die
			case HOLE:
				if(
					this.snake.length==0 ||
					this.snake.length==1 &&
						this.world[this.snake[0][0]][this.snake[0][1]]==HOLE_S ||
					this.snake.length>=2 &&
						this.world[this.snake[0][0]][this.snake[0][1]]==HOLE_S &&
						this.world[this.snake[1][0]][this.snake[1][1]]==HOLE_S
				) return this.die("fell harder than their grades", "fell in a hole");
				break;

			// you eat, you get a massive score boost
			case SUPER_FOOD:
				this.score+=10;
				break;

			// you eat, you get a small score boost
			case DECAY_FOOD:
				this.score+=5;
				this.decayFood=this.decayFood.filter(
					([x, y, _]) => !(x==head[0] && y==head[1])
				);
				break;

			// you eat, you destroy all doors
			case KEY:
				this.getTilesOfType(DOOR).forEach(([x, y]) => this.world[x][y]=EMPTY);
				break;

			// you step on, you trigger
			case SWITCH_ON:
			case SWITCH_OFF: {
				this.world[head[0]][head[1]]=this.world[head[0]][head[1]]==SWITCH_ON?SWITCH_OFF:SWITCH_ON;
				if(this.getTilesOfType(SPIKES_OFF_S).length) return this.die("spiked themselves", "activated spikes");
				const oldSpikes=this.getTilesOfType(SPIKES_ON);
				this.getTilesOfType(SPIKES_OFF).forEach(([x, y]) => this.world[x][y]=SPIKES_ON);
				oldSpikes.forEach(([x, y]) => this.world[x][y]=SPIKES_OFF);
			} break;

			// you eat, you grow
			case FOOD:
				// re-grow the snake partially (can't hit the tail, but it's there for all other intents and purposes
				this.snake.push(tail);
				this.length++;

				// remove the fruit from existence
				this.world[head[0]][head[1]]=SNAKE;
				this.fruits=this.fruits.filter(
					([x, y]) => !(x==head[0] && y==head[1])
				);

				// increase score
				this.score++;

				// custom rules
				if(this.rules.fruitRegrow) {
					const emptyCells=this.getTilesOfType(EMPTY);

					const cell=emptyCells[Math.floor(Math.random()*emptyCells.length)];
					this.fruits.push(cell);
					this.world[cell[0]][cell[1]]=FOOD;
				}

				if(this.rules.superFruitGrow) {
					if(Math.random()<.1) { // 10% chance
						const emptyCells=this.getTilesOfType(EMPTY);
						const cell=emptyCells[Math.floor(Math.random()*emptyCells.length)];
						this.world[cell[0]][cell[1]]=SUPER_FOOD;
					}
				}

				if(this.rules.decayingFruitGrow) {
					if(Math.random()<.2) { // 20% chance
						const emptyCells=this.getTilesOfType(EMPTY);
						const cell=emptyCells[Math.floor(Math.random()*emptyCells.length)];
						this.world[cell[0]][cell[1]]=DECAY_FOOD;
						this.decayFood.push([cell[0], cell[1], this.playTime]);
					}
				}

				if(this.rules.speedIncrease) {
					this.delay*=this.rules.speedMultiplier;
					if(this.delay<this.rules.speedCap) this.delay=this.rules.speedCap;
				}
		}

		// move our head forward
		switch(this.world[head[0]][head[1]]) {
			case HOLE:
				this.world[head[0]][head[1]]=HOLE_S;
				break;
			case FLAMMABLE:
				this.world[head[0]][head[1]]=FLAMMABLE_S;
				break;
			case PORTAL_A:
				this.world[head[0]][head[1]]=PORTAL_A_S;
				break;
			case PORTAL_B:
				this.world[head[0]][head[1]]=PORTAL_B_S;
				break;
			case PORTAL_C:
				this.world[head[0]][head[1]]=PORTAL_C_S;
				break;
			case PORTAL_D:
				this.world[head[0]][head[1]]=PORTAL_D_S;
				break;
			case SWITCH_ON:
				this.world[head[0]][head[1]]=SWITCH_ON_S;
				break;
			case SWITCH_OFF:
				this.world[head[0]][head[1]]=SWITCH_OFF_S;
				break;
			case SPIKES_OFF:
				this.world[head[0]][head[1]]=SPIKES_OFF_S;
				break;
			default:
				this.world[head[0]][head[1]]=SNAKE;
		}
		this.snake.unshift(head);

		// decay decaying food
		this.decayFood.forEach(
			([x, y, birth]) => {
				if(this.playTime>=birth+2000) this.world[x][y]=EMPTY;
			}
		);
		this.decayFood=this.decayFood.filter(
			([_, __, birth]) => this.playTime<birth+2000
		);

		// automatic speed increase
		if(this.rules.autoSpeedIncrease) {
			if(this.delay>50 && this.tickId%this.rules.autoSpeadIncreaseTicks==0) this.delay--;
		}

		// automatic size grow
		if(this.rules.autoSizeGrow) {
			if(this.tickId%this.rules.autoSizeGrowTicks==0) this.snake.push(tail);
		}

		// fire tick
		if(this.tickId%this.rules.fireTickSpeed==0) {
			const touchingFire=([x, y]) => {
				const surrounding=[
					this.world[x][y-1],
					this.world[x][y+1],
					(this.world[x-1]||[])[y],
					(this.world[x+1]||[])[y]
				];
				return surrounding.some(tile => tile==FIRE);
			};
			if(this.getTilesOfType(FLAMMABLE_S).some(touchingFire)) return this.die("didn't know oil was flammable", "stood on oil when it caught on fire");
			this.getTilesOfType(FLAMMABLE).filter(touchingFire).forEach(([x, y]) => this.world[x][y]=FIRE);
		}

		// THE WORLD!
		if(!this.rules.timeFlow) {
			this.lastDirection=[0, 0];
			this.direction=[0, 0];
		}

		// victory condition
		if(this.rules.winCondition=='fruit') {
			if(!this.fruits.length) return this.win();
		}
		if(this.rules.winCondition=='time') {
			if(this.playTime>=this.rules.gameDuration) return this.win();
		}
		if(this.rules.winCondition=='score') {
			if(this.score>=this.rules.scoreObjective) return this.win();
		}
		if(this.rules.scoreSystem=='moves') {
			if(this.score) this.score--;
		}
	}

	tick() {
		if(!this.playing) return;
		if(!this.lastStep) this.lastStep=this.firstStep;
		this.draw();
		if(this.callback) this.callback('tick');
		if(this.rules.timeFlow && this.lastStep+this.delay<Date.now()) {
			this.lastStep+=this.delay;
			this.step();
		}
		if(!this.rules.timeFlow && (this.direction[0]!=0 || this.direction[1]!=0)) {
			this.step();
		}
		requestAnimationFrame(() => this.tick());
	}

	win() {
		this.playing=false;
		this.endPlayTime=this.playTime;
		if(this.callback) this.callback('win');
	}

	die(message='died', reason='died') {
		this.playing=false;
		this.endPlayTime=this.playTime;
		this.death={message, reason};
		if(this.callback) this.callback('die');
	}

	handleInputs(inputs) {
		const config=require('config');

		// change direction if the input is valid
		const trySet=(dir) => {
			if(!dir.every((e, i) => e==this.lastDirection[i] || e==-this.lastDirection[i])) {
				this.direction=dir;
				return true;
			}
		}

		// reduce buffer duration
		Object
			.keys(inputs)
			.forEach(k => {
				let v=inputs[k];
				if(v===true) v=5;
				v--;
				if(!v) delete inputs[k];
				else inputs[k]=v;
			});

		// try all inputs in order and unbuffer them if valid
		if(inputs.left && trySet([-1, 0])) delete inputs.left;
		else if(inputs.right && trySet([ 1, 0])) delete inputs.right;
		else if(inputs.up && trySet([ 0,-1])) delete inputs.up;
		else if(inputs.down &&  trySet([ 0, 1])) delete inputs.down;

		// buffering might be disabled
		if(!config.getB('input.buffer')) {
			Object
				.keys(inputs)
				.forEach(k => delete inputs[k]);
		}
	}

	start() {
		this.firstStep=Date.now();
		this.tickId=0;
		this.playing=true;
		requestAnimationFrame(() => this.tick());
	}
}

return module.exports=SnekGame;