MAZE GAME

This basic maze game can be used to create other more complex ones. It comes with a maze game building JavaScript API. This particular example requires PHP to load the media files. You can download the game source, and even play the game

MAZE.JS

var Directions = {FORWARD: 1, BACK: -1, UP: 2, DOWN: 3, RIGHT: 4, LEFT: 5};
var Connections = {END_TO_END: 0, END_TO_START: 1, START_TO_START: 2, START_TO_END: 3};


/********************************************************************************************
//
// MAZE OBJECT
//
*********************************************************************************************/

function maze (size) {
	this.spacing = 41.4, this.offsetX = 95, this.offsetY = 60;
	
	this.paths = new Array(size);
	
	this.bounceSound = null;
	
	this.render = function () {
		for(var i = 0; i < this.paths.length; i++) {
			if(this.paths[i] != null) {
				this.paths[i].render();
			}
		}
	}
	
	this.addPath = function (i, start, end) {
		if(i < this.paths.length) {
			this.paths[i] = new path(new vector2(start.x * this.spacing + this.offsetX, start.y * this.spacing + this.offsetY), new vector2(end.x * this.spacing + this.offsetX, end.y * this.spacing + this.offsetY));
		} 
	}
	
	this.addObject = function (i, mazeObj, position) {
		if(position <  0) {position = 0} 
		if(position >  1) {position = 1} 
		
		if(i < this.paths.length) {
			this.paths[i].addObject(mazeObj, position);
		}
	}
	
	this.fillPath = function (i, mazeObj, frontPad, endPad) {
		var dx = this.paths[i].end.x - this.paths[i].start.x;
		var dy = this.paths[i].end.y - this.paths[i].start.y;
		var fills = Math.round(Math.sqrt(dx * dx + dy * dy) / this.spacing);
		
		for(var j = frontPad; j <= fills - endPad; j++) {
			this.addObject(i, mazeObj, j / fills);
		}
	}
	
	this.connectPaths = function (i, j) {
		if(this.paths[i] == null || this.paths[j] == null) {
			return(false);
		}
		
		var endToEnd = new vector2(this.paths[j].end.x - this.paths[i].end.x, this.paths[j].end.y - this.paths[i].end.y);
		var endToStart = new vector2(this.paths[j].start.x - this.paths[i].end.x, this.paths[j].start.y - this.paths[i].end.y);
		var startToStart = new vector2(this.paths[j].start.x - this.paths[i].start.x, this.paths[j].start.y - this.paths[i].start.y);
		var startToEnd = new vector2(this.paths[j].end.x - this.paths[i].start.x, this.paths[j].end.y - this.paths[i].start.y);
		
		var endToEndMag = Math.sqrt(Math.pow(endToEnd.x, 2) + Math.pow(endToEnd.y, 2));
		var endToStartMag = Math.sqrt(Math.pow(endToStart.x, 2) + Math.pow(endToStart.y, 2));
		var startToStartMag = Math.sqrt(Math.pow(startToStart.x, 2) + Math.pow(startToStart.y, 2));
		var startToEndMag= Math.sqrt(Math.pow(startToEnd.x, 2) + Math.pow(startToEnd.y, 2));
		
		var endMag;
		var startMag;
		
		var closestToEnd, closestToStart, closest;
		
		if(endToEndMag < endToStartMag) {
			endMag = endToEndMag;
			closestToEnd = Connections.END_TO_END;
		} else {
			endMag = endToStartMag;
			closestToEnd = Connections.END_TO_START;
		}
		
		if(startToStartMag < startToEndMag) {
			startMag = startToStartMag;
			closestToStart = Connections.START_TO_START;
		} else {
			startMag = startToEndMag;
			closestToStart = Connections.START_TO_END;
		}
		
		closest = endMag < startMag ? closestToEnd : closestToStart;
		
		switch(closest) {
			case Connections.END_TO_END:
			this.connectEndToEnd(i, j);
			break;
			
			case Connections.END_TO_START:
			this.connectEndToStart(i, j);
			break;
			
			case Connections.START_TO_START:
			this.connectStartToStart(i, j);
			break;
			
			case Connections.START_TO_END:
			this.connectStartToEnd(i, j);
			break;
		}
		
		return(true);
	}
	
	this.resetPathObjects = function () {
		for(var i = 0; i < this.paths.length; i++) {
			this.paths[i].resetObjects();
		}
	}
	
	this.numberOfCoinsLeft = 0;
	this.numberOfPathObjects = function () {
		var _numberOfPathObjects = 0;
		for(var i = 0; i < this.paths.length; i++) {
			//console.log(_numberOfPathObjects + " += " + this.paths[i].numberOfCoins());
			_numberOfPathObjects += this.paths[i].numberOfCoins();
		}
		
		return(_numberOfPathObjects);
	}
	
	this.connectEndToEnd = function (i, j) {
		this.paths[i].addEndToEnd(j, this.paths[j].turnDirection(Directions.BACK));
		this.paths[j].addEndToEnd(i, this.paths[i].turnDirection(Directions.BACK));
	}
	
	this.connectEndToStart = function (i, j) {
		this.paths[i].addEndToStart(j, this.paths[j].turnDirection(Directions.FORWARD));
		this.paths[j].addStartToEnd(i, this.paths[i].turnDirection(Directions.BACK));
	}
	
	this.connectStartToStart = function (i, j) {
		this.paths[i].addStartToStart(j, this.paths[j].turnDirection(Directions.FORWARD));
		this.paths[j].addStartToStart(i, this.paths[i].turnDirection(Directions.FORWARD));
	}
	
	this.connectStartToEnd = function (i, j) {
		this.paths[i].addStartToEnd(j, this.paths[j].turnDirection(Directions.BACK));
		this.paths[j].addEndToStart(i, this.paths[i].turnDirection(Directions.FORWARD));
	}
	
	this.runnerCollide = function (runner1, runner2) {
		if(runner1.pathIndex == null || runner2.pathIndex == null) {
			return(false);
		}
		
		var path1 = runner1.maze.paths[runner1.pathIndex];
		var path2 = runner2.maze.paths[runner2.pathIndex];
		
		var path1Length = Math.sqrt((path1.end.x - path1.start.x) * (path1.end.x - path1.start.x) + (path1.end.y - path1.start.y) * (path1.end.y - path1.start.y));
		var path2Length = Math.sqrt((path2.end.x - path2.start.x) * (path2.end.x - path2.start.x) + (path2.end.y - path2.start.y) * (path2.end.y - path2.start.y));

		var reach = (runner1.anim.width / 2) + (runner2.anim.width / 2);
		
		var runner1x = path1.start.x + (path1.end.x - path1.start.x) * runner1.position;
		var runner1y = path1.start.y + (path1.end.y - path1.start.y) * runner1.position;
		var runner2x = path2.start.x + (path2.end.x - path2.start.x) * runner2.position;
		var runner2y = path2.start.y + (path2.end.y - path2.start.y) * runner2.position;
		
		if(Math.sqrt((runner2x - runner1x) * (runner2x - runner1x) + (runner2y - runner1y) * (runner2y - runner1y)) < reach) {
			if(runner1.blocked == false) {
				runner1.direction *= -1;
				this.bounceSound.play();
			}
			
			if(runner2.blocked == false) {
				runner2.direction *= -1;
			}
			
			return(true);
		} else {
			return(false);
		}
	}
	
	return(this);
}


/********************************************************************************************
//
// PATH OBJECT
//
*********************************************************************************************/

function path (start, end) {
	this.start = start;
	this.end = end;
	
	this.render = function () {
		for(var i = 0; i < this.mazeObjects.length; i++) {
			if(this.mazeObjects[i].alive) {
				context.drawImage(this.mazeObjects[i].img, 0, 0, this.mazeObjects[i].width, this.mazeObjects[i].height, 
					this.start.x + (this.end.x - this.start.x) * this.mazeObjects[i].position - this.mazeObjects[i].width / 2, 
					this.start.y + (this.end.y - this.start.y) * this.mazeObjects[i].position - this.mazeObjects[i].height / 2, 
					this.mazeObjects[i].width, this.mazeObjects[i].height);
			}
		}
	}
	
	this.mazeObjects = new Array();
	
	this.numberOfCoins = function () {
		var _numberOfCoins = 0
		for(var i = 0; i < this.mazeObjects.length; i++) {
			if(this.mazeObjects[i].alive) {
				_numberOfCoins++;
			}
		}
		
		return(_numberOfCoins);
	}
	
	this.addObject = function (mazeObj, position) {
		if(position <  0) {position = 0} 
		if(position >  1) {position = 1} 

		var _mazeObject = new mazeObject(mazeObj, mazeObj.points, mazeObj.pickUpSound);
		_mazeObject.position = position;
		this.mazeObjects.push(_mazeObject);
	}
	
	this.resetObjects = function () {
		for(var i = 0; i < this.mazeObjects.length; i++) {
			this.mazeObjects[i].alive = true;
		}
	}
	
	this.end_to_end = new Array();
	this.addEndToEnd = function (i, direction) {
		var _connection = new connection(i, direction);
		this.end_to_end.push(_connection);
	}
	
	this.end_to_start = new Array();
	this.addEndToStart = function (i, direction) {
		var _connection = new connection(i, direction);
		this.end_to_start.push(_connection);
	}
	
	this.start_to_start = new Array();
	this.addStartToStart = function (i, direction) {
		var _connection = new connection(i, direction);
		this.start_to_start.push(_connection);
	}
	
	this.start_to_end = new Array();
	this.addStartToEnd = function (i, direction) {
		var _connection = new connection(i, direction);
		this.start_to_end.push(_connection);
	}
	
	this.velocityNormal = function () {
		var dx = (end.x - start.x);
		var dy = (end.y - start.y);
		var length =  Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
			
		if(length == 0) {
			var velocity = new vector2(0, 0);
		} else {	
			var velocity = new vector2(dx / length, dy / length);
		}
		
		return(velocity);
	}
	
	this.turnDirection = function (direction) {
		direction = direction  > 0 ? 1 : -1;
		
		var vn = this.velocityNormal();
		
		if(Math.abs(vn.x) > Math.abs(vn.y)) {
			if(vn.x * direction > 0) {
				return(Directions.RIGHT);
			} else {
				return(Directions.LEFT);
			}
		} else {
			if(vn.y * direction > 0) {
				return(Directions.DOWN);
			} else {
				return(Directions.UP);
			}
		}
	}
	
	return(this);
}


/********************************************************************************************
//
// MAZE OBJECT AND MAZE RUNNER OBJECTS
//
*********************************************************************************************/

function mazeObject (img, points, pickUpSound) {	
	this.img = img.img;
	this.pickUpSound = pickUpSound;
	this.width = img.width;
	this.height = img.height;
	this.points = points;
	this.position = 0;
	this.alive = true;
	
	return(this);
}

function mazeRunner (anim, maze) {
	this.render = function () {
		if(this.pathIndex != null) {
			var x = this.maze.paths[this.pathIndex].start.x + (this.maze.paths[this.pathIndex].end.x - this.maze.paths[this.pathIndex].start.x) * this.position;
			var y = this.maze.paths[this.pathIndex].start.y + (this.maze.paths[this.pathIndex].end.y - this.maze.paths[this.pathIndex].start.y) * this.position;
			
			var angle = 0;
			
			if(this.rotate == true) {
				var vn = this.maze.paths[this.pathIndex].velocityNormal();
			
				var angle = Math.asin(-vn.y * this.direction / Math.sqrt(vn.x * vn.x + vn.y * vn.y));
				
				if(vn.x * this.direction > 0) {
					angle += Math.PI - 2 * angle;
				}
			}
			
			this.anim.render(x, y, angle);
		}
	}
	
	this.runDirection = function () {
		var _velocityNormal = this.maze.paths[this.pathIndex].velocityNormal();
		
		if(Math.abs(_velocityNormal.x) > Math.abs(_velocityNormal.y)) {
			if(_velocityNormal.x * this.direction > 0) {
				return(Directions.RIGHT);
			} else {
				return(Directions.LEFT);
			}
		} else {
			if(_velocityNormal.y * this.direction > 0) {
				return(Directions.DOWN);
			} else {
				return(Directions.UP);
			}
		}
	}
	
	this.run = function () {
		if(this.maze == null || this.pathIndex == null) {
			return(false);
		}
		
		var path = this.maze.paths[this.pathIndex];
		
		var reach = 0.1;
		
		var dx = this.speed * this.direction / Math.sqrt(Math.pow(path.end.x - path.start.x, 2) + Math.pow(path.end.y - path.start.y, 2));
		
		var _runDirection = this.runDirection();
		var continuingPathIndex = null;
		var continuingPosition = 0;
		
		if(this.position + dx >= 1 || this.position + dx <= 0) {
			this.blocked = true;
			
			if(this.ai == this.aiRandom || this.ai == this.aiFindCoins) {
				this.ai();
			}
			
			if(this.ai == this.aiFindRunner || this.ai == this.aiChaseRunner) {
				if(this.target != null) {
					this.ai(this.target);
				} else {
					this.aiRandom();
				}
			}
		}
		
		if(this.position + dx >= 1) {
			for(var i = 0; i < path.end_to_end.length; i++) {
				this.pickUpAdjacentObjects(path.end_to_end[i].i, 1, reach);
			}
			
			for(var i = 0; i < path.end_to_start.length; i++) {
				this.pickUpAdjacentObjects(path.end_to_start[i].i, 0, reach);
			}
			
			for(var i = 0; i < path.end_to_end.length; i++) {
				if(path.end_to_end[i].direction == this.turnDirection) {
					this.addToPath(path.end_to_end[i].i, 1, Directions.BACK);
					
					return(true);
				}
				
				if(path.end_to_end[i].direction == _runDirection) {
					continuingPathIndex = path.end_to_end[i].i;
					continuingPosition = 1;
				}
			}
			
			for(var i = 0; i < path.end_to_start.length; i++) {
				if(path.end_to_start[i].direction == this.turnDirection) {
					this.addToPath(path.end_to_start[i].i, 0, Directions.FORWARD);
					
					return(true);
				}
				
				if(path.end_to_start[i].direction == _runDirection) {
					continuingPathIndex = path.end_to_start[i].i;
				}
			}
			
			if(continuingPathIndex != null) {
				if(continuingPosition == 1) {
					this.addToPath(continuingPathIndex, 1, Directions.BACK);
				} else {
					this.addToPath(continuingPathIndex, 0, Directions.FORWARD);
				}
			}
			
			return(false);
		}
		
		if(this.position + dx <= 0) {
			for(var i = 0; i < path.start_to_start.length; i++) {
				this.pickUpAdjacentObjects(path.start_to_start[i].i, 0, reach);
			}
			
			for(var i = 0; i < path.start_to_end.length; i++) {
				this.pickUpAdjacentObjects(path.start_to_end[i].i, 1, reach);
			}
			
			for(var i = 0; i < path.start_to_start.length; i++) {
				if(path.start_to_start[i].direction == this.turnDirection) {
					this.addToPath(path.start_to_start[i].i, 0, Directions.FORWARD);
					
					return(true);
				}
				
				if(path.start_to_start[i].direction == _runDirection) {
					continuingPathIndex = path.start_to_start[i].i;
				}
			}
			
			for(var i = 0; i < path.start_to_end.length; i++) {
				if(path.start_to_end[i].direction == this.turnDirection) {
					this.addToPath(path.start_to_end[i].i, 1, Directions.BACK);
					
					return(true);
				}
				
				if(path.start_to_end[i].direction == _runDirection) {
					continuingPathIndex = path.start_to_end[i].i;
					continuingPosition = 1;
				}
			}
			
			if(continuingPathIndex != null) {
				if(continuingPosition == 1) {
					this.addToPath(continuingPathIndex, 1, Directions.BACK);
				} else {
					this.addToPath(continuingPathIndex, 0, Directions.FORWARD);
				}
			}
			
			return(false);
		}
		
		this.position+= dx;
		
		this.pickUpObjects(reach);
	}
	
	this.pickUpObjects = function (reach) {
		var path = this.maze.paths[this.pathIndex];
		
		for(var i = 0; i < path.mazeObjects.length; i++) {
			if(Math.abs(path.mazeObjects[i].position - this.position) < reach) {
				if(path.mazeObjects[i].alive == true) {
					path.mazeObjects[i].alive = false;
					path.mazeObjects[i].pickUpSound.play();
					this.score += path.mazeObjects[i].points;
					this.maze.numberOfCoinsLeft--;
				}
			}
		}
	}
	
	this.pickUpAdjacentObjects = function (pathIndex, position, reach) {
		var path = this.maze.paths[pathIndex];
		
		for(var i = 0; i < path.mazeObjects.length; i++) {
			if(Math.abs(path.mazeObjects[i].position - position) < reach) {
				if(path.mazeObjects[i].alive == true) {
					path.mazeObjects[i].alive = false;
					path.mazeObjects[i].pickUpSound.play();
					this.score += path.mazeObjects[i].points;
					this.maze.numberOfCoinsLeft--;
				}
			}
		}
	}
	
	this.addToPath = function (pathIndex, position, direction) {
		this.pathIndex = pathIndex;
		
		if(position <  0) {position = 0} 
		if(position >  1) {position = 1} 
		this.position = position;
		
		this.direction = direction;
		
		this.turnDirection = this.runDirection();
		
		this.blocked = false;
	}
	
	this.anim = anim;
	
	this.maze = maze;
	this.score = 0;
	this.pathIndex = null;
	this.position = 0;
	this.direction = Directions.FORWARD;
	this.turnDirection = Directions.RIGHT;
	this.speed = 0;
	this.rotate = false;
	this.blocked = false;
	
	this.ai = null;
	this.target = null;
	
	this.aiRandom = function () {
		var possibleDirections = new Array();
		var _path = this.maze.paths[this.pathIndex];
		
		if(this.direction == Directions.FORWARD) {
			for(var i = 0; i < _path.end_to_end.length; i++) {
				possibleDirections.push(_path.end_to_end[i].direction);
			}
			
			for(var i = 0; i < _path.end_to_start.length; i++) {
				possibleDirections.push(_path.end_to_start[i].direction);
			}
		} else {
			for(var i = 0; i < _path.start_to_start.length; i++) {
				possibleDirections.push(_path.start_to_start[i].direction);
			}
			
			for(var i = 0; i < _path.start_to_end.length; i++) {
				possibleDirections.push(_path.start_to_end[i].direction);
			}
		}
		
		this.turnDirection = possibleDirections[Math.floor(Math.random() * possibleDirections.length)];
	}
	
	this.aiFindCoins = function () {
		var _path = this.maze.paths[this.pathIndex];
		
		var theMostCoins = 0;
		var moreCoins;
		var _turnDirection;
		
		if(this.direction == Directions.FORWARD) {
			for(var i = 0; i < _path.end_to_end.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.end_to_end[i].i], Directions.BACK, 3);
				if(moreCoins > theMostCoins) {
					theMostCoins = moreCoins;
					_turnDirection =  _path.end_to_end[i].direction;
				}
			}
			
			for(var i = 0; i < _path.end_to_start.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.end_to_start[i].i], Directions.FORWARD, 3);
				if(moreCoins > theMostCoins) {
					theMostCoins = moreCoins;
					_turnDirection =  _path.end_to_start[i].direction;
				}
			}
		} else {
			for(var i = 0; i < _path.start_to_start.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.start_to_start[i].i], Directions.FORWARD, 3);
				if(moreCoins > theMostCoins) {
					theMostCoins = moreCoins;
					_turnDirection =  _path.start_to_start[i].direction;
				}
			}
			
			for(var i = 0; i < _path.start_to_end.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.start_to_end[i].i], Directions.BACK, 3);
				if(moreCoins > theMostCoins) {
					theMostCoins = moreCoins;
					_turnDirection =  _path.start_to_end[i].direction;
				}
			}
		}
		
		if(theMostCoins > 0) {
			this.turnDirection = _turnDirection;
		} else {
			this.aiRandom();
		}
	}
	
	this.numberOfCoins = function (_path, direction, depth) {
		var _numberOfCoins = _path.numberOfCoins();
		
		if(depth == 0) {
			return(_numberOfCoins);
		}
		
		var theMostCoins = 0;
		var moreCoins;
		
		if(direction == Directions.FORWARD) {
			for(var i = 0; i < _path.end_to_end.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.end_to_end[i].i], Directions.BACK, depth -1);
				theMostCoins = moreCoins > theMostCoins ? moreCoins : theMostCoins;
			}
			
			for(var i = 0; i < _path.end_to_start.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.end_to_start[i].i], Directions.FORWARD, depth -1);
				theMostCoins = moreCoins > theMostCoins ? moreCoins : theMostCoins;
			}
		} else {
			for(var i = 0; i < _path.start_to_start.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.start_to_start[i].i], Directions.FORWARD, depth -1);
				theMostCoins = moreCoins > theMostCoins ? moreCoins : theMostCoins;
			}
			
			for(var i = 0; i < _path.start_to_end.length; i++) {
				moreCoins = this.numberOfCoins(this.maze.paths[ _path.start_to_end[i].i], Directions.BACK, depth -1);
				theMostCoins = moreCoins > theMostCoins ? moreCoins : theMostCoins;
			}
		}
		
		return(_numberOfCoins + theMostCoins);
	}
	
	this.aiFindRunner = function (runner) {
		var _path = this.maze.paths[this.pathIndex];
		
		if(this.direction == Directions.FORWARD) {
			for(var i = 0; i < _path.end_to_end.length; i++) {
				if(this.aiFoundRunner(_path.end_to_end[i].i, runner, Directions.BACK, 3)) {
					this.turnDirection = _path.end_to_end[i].direction;
					return(true);
				}
			}
			
			for(var i = 0; i < _path.end_to_start.length; i++) {
				if(this.aiFoundRunner(_path.end_to_start[i].i, runner, Directions.FORWARD, 3)) {
					this.turnDirection = _path.end_to_start[i].direction;
					return(true);
				}
			}
		} else {
			for(var i = 0; i < _path.start_to_start.length; i++) {
				if(this.aiFoundRunner(_path.start_to_start[i].i, runner, Directions.FORWARD, 3)) {
					this.turnDirection = _path.start_to_start[i].direction;
					return(true);
				}
			}
			
			for(var i = 0; i < _path.start_to_end.length; i++) {
				if(this.aiFoundRunner(_path.start_to_end[i].i, runner, Directions.BACK, 3)) {
					this.turnDirection = _path.start_to_end[i].direction;
					return(true);
				}
			}
		}
		
		this.aiRandom();
	}
	
	this.aiFoundRunner = function (pathIndex, runner, direction, depth) {
		if(depth == 0) {
			if(runner.pathIndex == pathIndex) {
				return(true);
			} else {
				return(false);
			}
		} else {
			if(runner.pathIndex == pathIndex) {
				return(true);
			}
			
			var _path = runner.maze.paths[pathIndex];
			
			if(direction == Directions.FORWARD) {
				for(var i = 0; i < _path.end_to_end.length; i++) {
					if(this.aiFoundRunner(_path.end_to_end[i].i, runner, Directions.BACK, depth -1)) {
						return(true);
					}
				}
				
				for(var i = 0; i < _path.end_to_start.length; i++) {
					if(this.aiFoundRunner(_path.end_to_start[i].i, runner, Directions.FORWARD, depth -1)) {
						return(true);
					}
				}
			} else {
				for(var i = 0; i < _path.start_to_start.length; i++) {
					if(this.aiFoundRunner(_path.start_to_start[i].i, runner, Directions.FORWARD, depth -1)) {
						return(true);
					}
				}
				
				for(var i = 0; i < _path.start_to_end.length; i++) {
					if(this.aiFoundRunner(_path.start_to_end[i].i, runner, Directions.BACK, depth -1)) {
						return(true);
					}
				}
			}
			
			return(false);
		}
	}
	
	this.aiChaseRunner = function (runner) {
		var _path = this.maze.paths[this.pathIndex];
		var _runnerPath = runner.maze.paths[runner.pathIndex];
		
		var dx = (_runnerPath.start.x + (_runnerPath.end.x - _runnerPath.start.x) * runner.position) - (_path.start.x + (_path.end.x - _path.start.x) * this.position);
		var dy =  (_runnerPath.start.y + (_runnerPath.end.y - _runnerPath.start.y) * runner.position) - (_path.start.y + (_path.end.y - _path.start.y) * this.position);
		
		var possibleDirections = new Array();
		
		if(this.direction == Directions.FORWARD) {
			for(var i = 0; i < _path.end_to_end.length; i++) {
				if(this.matchTurn(_path.end_to_end[i].direction, dx, dy)) {
					possibleDirections.push(_path.end_to_end[i].direction);
				}
			}
			
			for(var i = 0; i < _path.end_to_start.length; i++) {
				if(this.matchTurn(_path.end_to_start[i].direction, dx, dy)) {
					possibleDirections.push(_path.end_to_start[i].direction);
				}
			}
		} else {
			for(var i = 0; i < _path.start_to_start.length; i++) {
				if(this.matchTurn(_path.start_to_start[i].direction, dx, dy)) {
					possibleDirections.push(_path.start_to_start[i].direction);
				}
			}
			
			for(var i = 0; i < _path.start_to_end.length; i++) {
				if(this.matchTurn(_path.start_to_end[i].direction, dx, dy)) {
					possibleDirections.push(_path.start_to_end[i].direction);
				}
			}
		}
		
		if(possibleDirections.length == 0) {
			this.aiRandom();
		} else {
			this.turnDirection = possibleDirections[Math.floor(Math.random() * possibleDirections.length)];
		}
	}
	
	this.matchTurn = function (direction, dx, dy) {
		switch(direction) {
			case Directions.RIGHT:
				if(dx > 0) {
					return(true);
				}
				break;
				
			case Directions.LEFT:
				if(dx < 0) {
					return(true);
				}
				break;
				
			case Directions.DOWN:
				if(dy > 0) {
					return(true);
				}
				break;
				
			case Directions.UP:
				if(dy < 0) {
					return(true);
				}
				break;
		}
		
		return(false);
	}
	
	return(this);
}

/********************************************************************************************
//
// HELPER OBJECTs
//
*********************************************************************************************/

function vector2 (x, y) {
	this.x = x;
	this.y = y;

	return(this);
}

function connection (i, direction) {
	this.i = i;
	this.direction = direction;

	return(this);
}

GAME.JS

function getXMLObject ()
{
         var xmlHttp = null;
         try
         {
           xmlHttp = new XMLHttpRequest();
         }
         catch(e)
         {
              try
              {
                  xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");
              }
              catch(e)
              {
                   try
                   {
                       xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
                   }
                   catch(e)
                   {
                         xmlHttp = null;
                   }
              }
         }

         return(xmlHttp);
}

function displayScore (score, x, y) {
	if(score > 999) {
		score = 999;
	}
	
	if(score < 0) {
		score = 0;
	}
	
	if(score == 0) {
		return(false);
	}
	
	var _scoreDigits = new Array(3);
	var padding = 10;
	
	for(var i = 0; i < _scoreDigits.length; i++) {
		_scoreDigits[_scoreDigits.length - i - 1] = score % 10;
		score = Math.floor(score / 10);
	}
	
	for(var i = 0; i < _scoreDigits.length; i++) {
		scoreDigits.currentFrame = _scoreDigits[i];
		scoreDigits.render(x + (i - 1) * (scoreDigits.width + padding), y, 0);
	}
}

function runnerCollide () {
	for(var i = 0; i < otherRunners.length; i++) {
		_runnerCollide(mainRunner, otherRunners[i]);
	}
	
	for(var i = 0; i < otherRunners.length; i++) {
		for(var j = i; j < otherRunners.length; j++) {
			if(i != j) {
				_runnerCollide(otherRunners[i], otherRunners[j]);
			}
		}
	}
}

function _runnerCollide (runner1, runner2) {
	if(runner1.pathIndex == null || runner2.pathIndex == null) {
		return(false);
	}
	
	if(runner1.pathIndex == runner2.pathIndex && (runner1.direction != runner2.direction || (runner1.stopped != true && runner2.stopped != true))) {
		gameMaze.runnerCollide(runner1, runner2);
	}
	
	var _path = runner1.maze.paths[runner1.pathIndex];
	
	if(runner1.direction == Directions.FORWARD && runner2.direction == Directions.FORWARD) {
		for(var i = 0; i < _path.end_to_end.length; i++) {
			if(runner2.pathIndex == _path.end_to_end[i].i) {
				gameMaze.runnerCollide(runner1, runner2);
			}
		}
	} 
	
	if(runner1.direction == Directions.FORWARD && runner2.direction == Directions.BACK) {
		for(var i = 0; i < _path.end_to_start.length; i++) {
			if(runner2.pathIndex == _path.end_to_start[i].i) {
				gameMaze.runnerCollide(runner1, runner2);
			}
		}
	}
	
	if(runner1.direction == Directions.BACK && runner2.direction == Directions.BACK) {
		for(var i = 0; i < _path.start_to_start.length; i++) {
			if(runner2.pathIndex == _path.start_to_start[i].i) {
				gameMaze.runnerCollide(runner1, runner2);
			}
		}
	}
	
	if(runner1.direction == Directions.BACK && runner2.direction == Directions.FORWARD) {
		for(var i = 0; i < _path.start_to_end.length; i++) {
			if(runner2.pathIndex == _path.start_to_end[i].i) {
				gameMaze.runnerCollide(runner1, runner2);
			}
		}
	}
}

var canvas;
var context;
var gameLoopTimer;
var loadCounter;
var loadEvent;

var bg;
var _1;
var _2;
var golfBall;
var puck;
var scoreDigits;
var buttonFrames;
var introMusic;
var pickUpSound, bounceSound;

var gameMaze = new maze(66);
var mainRunner;
var otherRunners;
var startButton;
var pickUp1, pickUp2;

function setUpGame () {
	window.addEventListener('keydown', onKeyDown, true);
	
	startButton = new button(canvas.width / 2, canvas.height / 2, buttonFrames, puckOff);
	window.addEventListener('mousemove', buttonEvents);
	canvas.addEventListener('mousedown', buttonEvents);
	canvas.addEventListener('mouseup', buttonEvents);
	canvas.addEventListener('click', buttonEvents);
	
	canvas.addEventListener('focus', startGameLoop);
	canvas.focus();
	
	pickUp1 = new mazeObject(_1, 1, pickUpSound);
	pickUp2 = new mazeObject(_2, 2, pickUpSound);
	
	gameMaze.bounceSound = bounceSound;

	//1st row.
	
	gameMaze.addPath(0, new vector2(0, 0), new vector2(4, 0));
	gameMaze.fillPath(0, pickUp1, 1, 1);
	gameMaze.addObject(0, pickUp2, 0);
	gameMaze.addPath(1, new vector2(4, 0), new vector2(6, 0));
	gameMaze.fillPath(1, pickUp1, 0, 0);
	gameMaze.addPath(2, new vector2(6, 0), new vector2(11, 0));
	gameMaze.fillPath(2, pickUp1, 1, 1);
	gameMaze.addPath(3, new vector2(11, 0), new vector2(16, 0));
	gameMaze.fillPath(3, pickUp1, 1, 1);
	gameMaze.addObject(3, pickUp2, 0);
	gameMaze.addPath(4, new vector2(16, 0), new vector2(18, 0));
	gameMaze.fillPath(4, pickUp1, 0, 0);
	gameMaze.addPath(5, new vector2(18, 0), new vector2(22, 0));
	gameMaze.fillPath(5, pickUp1, 1, 1);
	gameMaze.addObject(5, pickUp2, 1);
	
	gameMaze.connectPaths(0, 1);
	gameMaze.connectPaths(1, 2);
	gameMaze.connectPaths(2, 3);
	gameMaze.connectPaths(3, 4);
	gameMaze.connectPaths(4, 5);
	
	//2nd row.
	
	gameMaze.addPath(6, new vector2(0, 3), new vector2(2, 3));
	gameMaze.fillPath(6, pickUp1, 1, 1);
	gameMaze.addObject(6, pickUp2, 0);
	gameMaze.addPath(19, new vector2(2, 3), new vector2(4, 3));
	gameMaze.fillPath(19, pickUp1, 0, 1);
	gameMaze.addPath(7, new vector2(4, 3), new vector2(6, 3));
	gameMaze.fillPath(7, pickUp1, 0, 0);
	gameMaze.addPath(8, new vector2(6, 3), new vector2(11, 3));
	gameMaze.fillPath(8, pickUp1, 1, 1);
	gameMaze.addPath(9, new vector2(11, 3), new vector2(16, 3));
	gameMaze.fillPath(9, pickUp1, 0, 1);
	gameMaze.addPath(10, new vector2(16, 3), new vector2(18, 3));
	gameMaze.fillPath(10, pickUp1, 0, 0);
	gameMaze.addPath(20, new vector2(18, 3), new vector2(20, 3));
	gameMaze.fillPath(20, pickUp1, 1, 1);
	gameMaze.addPath(11, new vector2(20, 3), new vector2(22, 3));
	gameMaze.fillPath(11, pickUp1, 0, 1);
	gameMaze.addObject(11, pickUp2, 1);
	
	gameMaze.connectPaths(6, 19);
	gameMaze.connectPaths(19, 7);
	gameMaze.connectPaths(7, 8);
	gameMaze.connectPaths(8, 9);
	gameMaze.connectPaths(9, 10);
	gameMaze.connectPaths(10, 20);
	gameMaze.connectPaths(20, 11);
	
	//1st and 2nd row connection.
	
	gameMaze.addPath(12, new vector2(0, 0), new vector2(0, 3));
	gameMaze.fillPath(12, pickUp1, 1, 1);
	gameMaze.addPath(13, new vector2(4, 0), new vector2(4, 3));
	gameMaze.fillPath(13, pickUp1, 1, 1);
	gameMaze.addPath(14, new vector2(6, 0), new vector2(6, 3));
	gameMaze.fillPath(14, pickUp1, 1, 1);
	gameMaze.addPath(15, new vector2(11, 0), new vector2(11, 3));
	gameMaze.fillPath(15, pickUp1, 1, 1);
	gameMaze.addPath(16, new vector2(16, 0), new vector2(16, 3));
	gameMaze.fillPath(16, pickUp1, 1, 1);
	gameMaze.addPath(17, new vector2(18, 0), new vector2(18, 3));
	gameMaze.fillPath(17, pickUp1, 1, 1);
	gameMaze.addPath(18, new vector2(22, 0), new vector2(22, 3));
	gameMaze.fillPath(18, pickUp1, 1, 1);
	
	gameMaze.connectPaths(12, 0); gameMaze.connectPaths(12, 6);
	gameMaze.connectPaths(13, 1); gameMaze.connectPaths(13, 7); gameMaze.connectPaths(13, 0); gameMaze.connectPaths(13, 19);
	gameMaze.connectPaths(14, 2); gameMaze.connectPaths(14, 8); gameMaze.connectPaths(14, 1); gameMaze.connectPaths(14, 7);
	gameMaze.connectPaths(15, 3); gameMaze.connectPaths(15, 9); gameMaze.connectPaths(15, 2); gameMaze.connectPaths(15, 8);
	gameMaze.connectPaths(16, 4); gameMaze.connectPaths(16, 10); gameMaze.connectPaths(16, 3); gameMaze.connectPaths(16, 9);
	gameMaze.connectPaths(17, 5); gameMaze.connectPaths(17, 20); gameMaze.connectPaths(17, 4); gameMaze.connectPaths(17, 10);
	gameMaze.connectPaths(18, 5); gameMaze.connectPaths(18, 11);
	
	//3rd row.
	
	gameMaze.addPath(21, new vector2(-2, 5), new vector2(2, 5));
	gameMaze.fillPath(21, pickUp1, 1, 0);
	gameMaze.addPath(22, new vector2(2, 5), new vector2(6, 6));
	gameMaze.fillPath(22, pickUp1, 1, 0);
	gameMaze.addPath(23, new vector2(6, 6), new vector2(9, 6));
	gameMaze.fillPath(23, pickUp1, 1, 0);
	
	gameMaze.addPath(24, new vector2(13, 6), new vector2(16, 6));
	gameMaze.fillPath(24, pickUp1, 0, 0);
	gameMaze.addPath(25, new vector2(16, 6), new vector2(20, 5));
	gameMaze.fillPath(25, pickUp1, 1, 0);
	gameMaze.addPath(26, new vector2(20, 5), new vector2(24, 5));
	gameMaze.fillPath(26, pickUp1, 1, 1);
	
	gameMaze.connectPaths(21, 22);
	gameMaze.connectPaths(22, 23);
	
	gameMaze.paths[23].addEndToStart(24, Directions.RIGHT);
	gameMaze.paths[24].addStartToEnd(23, Directions.LEFT);
	
	gameMaze.connectPaths(24, 25);
	gameMaze.connectPaths(25, 26);
	
	gameMaze.paths[21].addStartToEnd(26, Directions.LEFT);
	gameMaze.paths[26].addEndToStart(21, Directions.RIGHT);

	//2nd and 3rd row connection.

    gameMaze.addPath(27, new vector2(2, 3), new vector2(2, 5));
	gameMaze.fillPath(27, pickUp1, 1, 1);
	gameMaze.connectPaths(27, 6);
	gameMaze.connectPaths(27, 19);
	gameMaze.connectPaths(27, 21);
	gameMaze.connectPaths(27, 22);
	
	gameMaze.addPath(28, new vector2(6, 3), new vector2(6, 6));
	gameMaze.fillPath(28, pickUp1, 1, 1);
	gameMaze.connectPaths(28, 7);
	gameMaze.connectPaths(28, 8);
	gameMaze.connectPaths(28, 14);
	gameMaze.connectPaths(28, 22);
	gameMaze.connectPaths(28, 23);
	
	gameMaze.addPath(29, new vector2(16, 3), new vector2(16, 6));
	gameMaze.fillPath(29, pickUp1, 1, 1, 1);
	gameMaze.connectPaths(29, 9);
	gameMaze.connectPaths(29, 10);
	gameMaze.connectPaths(29, 16);
	gameMaze.connectPaths(29, 24);
	gameMaze.connectPaths(29, 25);
	
	gameMaze.addPath(30, new vector2(20, 3), new vector2(20, 5));
	gameMaze.fillPath(30, pickUp1, 1, 1);
	gameMaze.connectPaths (30, 20);
	gameMaze.connectPaths (30, 11);
	gameMaze.connectPaths (30, 25);
	gameMaze.connectPaths (30, 26);

	//4th row.

	gameMaze.addPath(31, new vector2(-2, 9), new vector2(2, 9));
	gameMaze.fillPath(31, pickUp1, 1, 1);
	gameMaze.addPath(32, new vector2(2, 9), new vector2(6, 8));
	gameMaze.fillPath(32, pickUp1, 0, 1);
	gameMaze.addPath(33, new vector2(6, 8), new vector2(9, 8));
	gameMaze.fillPath(33, pickUp1, 0, 0);
	
	gameMaze.addPath(34, new vector2(13, 8), new vector2(16, 8));
	gameMaze.fillPath(34, pickUp1, 0, 0);
	gameMaze.addPath(35, new vector2(16, 8), new vector2(20, 9));
	gameMaze.fillPath(35, pickUp1, 1, 0);
	gameMaze.addPath(36, new vector2(20, 9), new vector2(24, 9));
	gameMaze.fillPath(36, pickUp1, 1, 1);
	
	gameMaze.connectPaths (31, 32);
	gameMaze.connectPaths (32, 33);
	
	gameMaze.paths[33].addEndToStart(34, Directions.RIGHT);
	gameMaze.paths[34].addStartToEnd(33, Directions.LEFT);
	
	gameMaze.connectPaths (34, 35);
	gameMaze.connectPaths (35, 36);
	
	gameMaze.paths[31].addStartToEnd(36, Directions.LEFT);
	gameMaze.paths[36].addEndToStart(31, Directions.RIGHT);
	
	//3rd and 4th row connection.
	
	gameMaze.addPath(37, new vector2(2, 9), new vector2(2, 5));
	gameMaze.fillPath(37, pickUp1, 1, 1);
	gameMaze.addPath(38, new vector2(20, 9), new vector2(20, 5));
	gameMaze.fillPath(38, pickUp1, 1, 1);
	
	gameMaze.connectPaths(37, 21);
	gameMaze.connectPaths(37, 22);
	gameMaze.connectPaths(37, 27);
	gameMaze.connectPaths(37, 31);
	gameMaze.connectPaths(37, 32);

	gameMaze.connectPaths(38, 25);
	gameMaze.connectPaths(38, 26);
	gameMaze.connectPaths(38, 30);
	gameMaze.connectPaths(38, 35);
	gameMaze.connectPaths(38, 36);
	
	//5th row.
	
	gameMaze.addPath(39, new vector2(0, 11), new vector2(2, 11));
	gameMaze.fillPath(39, pickUp1, 1, 1);
	gameMaze.addObject(39, pickUp2, 0);
	gameMaze.addPath(40, new vector2(2, 11), new vector2(4, 11));
	gameMaze.fillPath(40, pickUp1, 0, 1);
	gameMaze.addPath(41, new vector2(4, 11), new vector2(6, 11));
	gameMaze.fillPath(41, pickUp1, 0, 1);
	gameMaze.addPath(42, new vector2(6, 11), new vector2(11, 11));
	gameMaze.fillPath(42, pickUp1, 0, 1);
	gameMaze.addPath(43, new vector2(11, 11), new vector2(16, 11));
	gameMaze.fillPath(43, pickUp1, 0, 1);
	gameMaze.addPath(44, new vector2(16, 11), new vector2(18, 11));
	gameMaze.fillPath(44, pickUp1, 0, 1);
	gameMaze.addPath(45, new vector2(18, 11), new vector2(20, 11));
	gameMaze.fillPath(45, pickUp1, 0, 1);
	gameMaze.addPath(46, new vector2(20, 11), new vector2(22, 11));
	gameMaze.fillPath(46, pickUp1, 0, 1);
	gameMaze.addObject(46, pickUp2, 1);
	
	gameMaze.connectPaths(39, 40);
	gameMaze.connectPaths(40, 41);
	gameMaze.connectPaths(41, 42);
	gameMaze.connectPaths(42, 43);
	gameMaze.connectPaths(43, 44);
	gameMaze.connectPaths(44, 45);
	gameMaze.connectPaths(45, 46);
	
	//4th and 5th row connection.
	
	gameMaze.addPath(47, new vector2(2, 9), new vector2(2, 11));
	gameMaze.fillPath(47, pickUp1, 1, 1);
	gameMaze.addPath(48, new vector2(6, 8), new vector2(6, 11));
	gameMaze.fillPath(48, pickUp1, 1, 1);
	gameMaze.addPath(49, new vector2(16, 8), new vector2(16, 11));
	gameMaze.fillPath(49, pickUp1, 1, 1);
	gameMaze.addPath(50, new vector2(20, 9), new vector2(20, 11));
	gameMaze.fillPath(50, pickUp1, 1, 1);
	
	gameMaze.connectPaths(47, 31);
	gameMaze.connectPaths(47, 32);
	gameMaze.connectPaths(47, 37);
	gameMaze.connectPaths(47, 39);
	gameMaze.connectPaths(47, 40);

	gameMaze.connectPaths(48, 32);
	gameMaze.connectPaths(48, 33);
	gameMaze.connectPaths(48, 41);
	gameMaze.connectPaths(48, 42);

	gameMaze.connectPaths(49, 34);
	gameMaze.connectPaths(49, 35);
	gameMaze.connectPaths(49, 43);
	gameMaze.connectPaths(49, 44);

	gameMaze.connectPaths(50, 35);
	gameMaze.connectPaths(50, 36);
	gameMaze.connectPaths(50, 38);
	gameMaze.connectPaths(50, 45);
	gameMaze.connectPaths(50, 46);
	
	//6th row.
	
	gameMaze.addPath(51, new vector2(0, 14), new vector2(4, 14));
	gameMaze.fillPath(51, pickUp1, 1, 0);
	gameMaze.addObject(51, pickUp2, 0);
	gameMaze.addPath(52, new vector2(4, 14), new vector2(6, 14));
	gameMaze.fillPath(52, pickUp1, 1, 0);
	gameMaze.addPath(53, new vector2(6, 14), new vector2(11, 14));
	gameMaze.fillPath(53, pickUp1, 1, 1);
	gameMaze.addObject(53, pickUp2, 1);
	gameMaze.addPath(54, new vector2(11, 14), new vector2(16, 14));
	gameMaze.fillPath(54, pickUp1, 1, 0);
	gameMaze.addPath(55, new vector2(16, 14), new vector2(18, 14));
	gameMaze.fillPath(55, pickUp1, 1, 0);
	gameMaze.addPath(56, new vector2(18, 14), new vector2(22, 14));
	gameMaze.fillPath(56, pickUp1, 1, 1);
	gameMaze.addObject(56, pickUp2, 1);
	
	gameMaze.connectPaths(51, 52);
	gameMaze.connectPaths(52, 53);
	gameMaze.connectPaths(53, 54);
	gameMaze.connectPaths(54, 55);
	gameMaze.connectPaths(55, 56);
	
	//5th and 6th row connection.
	
	gameMaze.addPath(57, new vector2(0, 11), new vector2(0, 14));
	gameMaze.fillPath(57, pickUp1, 1, 1);
	gameMaze.addPath(58, new vector2(4, 11), new vector2(4, 14));
	gameMaze.fillPath(58, pickUp1, 1, 1);
	gameMaze.addPath(59, new vector2(6, 11), new vector2(6, 14));
	gameMaze.fillPath(59, pickUp1, 1, 1);
	gameMaze.addPath(60, new vector2(11, 11), new vector2(11, 14));
	gameMaze.fillPath(60, pickUp1, 1, 1);
	gameMaze.addPath(61, new vector2(16, 11), new vector2(16, 14));
	gameMaze.fillPath(61, pickUp1, 1, 1);
	gameMaze.addPath(62, new vector2(18, 11), new vector2(18, 14));
	gameMaze.fillPath(62, pickUp1, 1, 1);
	gameMaze.addPath(63, new vector2(22, 11), new vector2(22, 14));
	gameMaze.fillPath(63, pickUp1, 1, 1);
	
	gameMaze.connectPaths(57, 39); gameMaze.connectPaths(57, 51);
	gameMaze.connectPaths(58, 40); gameMaze.connectPaths(58, 52); gameMaze.connectPaths(58, 41); gameMaze.connectPaths(58, 51);
	gameMaze.connectPaths(59, 41); gameMaze.connectPaths(59, 53); gameMaze.connectPaths(59, 42); gameMaze.connectPaths(59, 52);
	gameMaze.connectPaths(60, 42); gameMaze.connectPaths(60, 54); gameMaze.connectPaths(60, 43); gameMaze.connectPaths(60, 53);
	gameMaze.connectPaths(61, 43); gameMaze.connectPaths(61, 55); gameMaze.connectPaths(61, 44); gameMaze.connectPaths(61, 54);
	gameMaze.connectPaths(62, 44); gameMaze.connectPaths(62, 56); gameMaze.connectPaths(62, 45); gameMaze.connectPaths(62, 55);
	gameMaze.connectPaths(63, 46); gameMaze.connectPaths(63, 56);

	gameMaze.connectPaths(59, 48);
	gameMaze.connectPaths(61, 49);
	
	//center maze.
	
	gameMaze.addPath(64, new vector2(9, 6), new vector2(13, 6));
	gameMaze.addPath(65, new vector2(9, 8), new vector2(13, 8));
	
	gameMaze.paths[64].addStartToEnd(23, Directions.LEFT);
	gameMaze.paths[64].addEndToStart(24, Directions.RIGHT);
	
	gameMaze.paths[65].addStartToEnd(33, Directions.LEFT);
	gameMaze.paths[65].addEndToStart(34, Directions.RIGHT);
	
	introMusic.play();
	
	mainRunner = new mazeRunner(puck, gameMaze);
	mainRunner.speed = 2;
	
	otherRunners = new Array(2);
	
	otherRunners[0] = new mazeRunner(golfBall, gameMaze);
	otherRunners[0].rotate = true;
	otherRunners[0].speed = 2;
	otherRunners[0].ai = otherRunners[0].aiFindCoins;
	
	otherRunners[1] = new mazeRunner(golfBall, gameMaze);
	otherRunners[1].rotate = false;
	otherRunners[1].speed = 2;
	otherRunners[1].ai = otherRunners[1].aiChaseRunner;
	otherRunners[1].target = otherRunners[0];
	
	startGameLoop();
}

function onLoad () {
	canvas = document.getElementById("canvas");
	context = canvas.getContext("2d");
	
	if(!context) {
		alert("hell no!");
	} else {
		canvas.addEventListener('blur', stopGameLoop);
		
		context.viewportWidth = canvas.width;
    	context.viewportHeight = canvas.height;
		
		bg = new img();
		_1 = new img();
		_2 = new img();
		golfBall = new anim();
		puck = new anim();
		scoreDigits = new anim();
		buttonFrames = new anim();
		scoreDigits.frameRate = 0;
		
		loadCounter = 10;
		loadEvent = setUpGame;		
		loadAnim(golfBall, "golfBall");
		loadAnim(puck, "puck");
		loadAnim(scoreDigits, "score");
		loadAnim(buttonFrames, "puckOffButton");
		loadImg(bg, "walls");
		loadImg(_1, "1");
		loadImg(_2, "2");
		introMusic = new sound("music/intro.0.wav");
		pickUpSound = new sound("music/pickup.wav");
		bounceSound = new sound("music/bounce.wav");
	}
}

function onKeyDown (event) {
	if(event.char == "p") {
		toggleGameLoop();
	}
	
	var _velocityNormal = gameMaze.paths[mainRunner.pathIndex].velocityNormal();
	
	if(event.key == "ArrowUp") {
		event.preventDefault();
		if(Math.abs(_velocityNormal.y) > Math.abs(_velocityNormal.x) && _velocityNormal.y * mainRunner.direction > 0) {
			mainRunner.direction*= -1;
		}
		
		mainRunner.turnDirection = Directions.UP;
	}
	
	if(event.key == "ArrowDown") {
		event.preventDefault();
		if(Math.abs(_velocityNormal.y) > Math.abs(_velocityNormal.x) && _velocityNormal.y * mainRunner.direction < 0) {
			mainRunner.direction*= -1;
		}
		
		mainRunner.turnDirection = Directions.DOWN;
	}
	
	if(event.key == "ArrowLeft") {
		if(Math.abs(_velocityNormal.x) > Math.abs(_velocityNormal.y) && _velocityNormal.x * mainRunner.direction > 0) {
			mainRunner.direction*= -1;
		}
		
		mainRunner.turnDirection = Directions.LEFT;
	}
	
	if(event.key == "ArrowRight") {
		if(Math.abs(_velocityNormal.x) > Math.abs(_velocityNormal.y) && _velocityNormal.x * mainRunner.direction < 0) {
			mainRunner.direction*= -1;
		}
		
		mainRunner.turnDirection = Directions.RIGHT;
	}
}

function buttonEvents (event) {
	startButton.mouse(event);
}

function button(x, y, anim, onClick) {
	this.render = function () {
		if(this.active == true) {
			this.anim.render(this.x, this.y, 0);
		}
	}
	
	this.mouse = function (event) {
		var x = event.x - context.canvas.offsetLeft;
		var y = event.y - context.canvas.offsetTop;
		
		if(x > this.x - this.anim.width / 2 && x < this.x + this.anim.width / 2 &&
			y > this.y - this.anim.height / 2 && y < this.y + this.anim.height / 2 &&
			this.active == true) {
				if(event.type == "mousedown") {
					this.anim.currentFrame = 2;
				}
				
				if(event.type == "mousemove" && this.anim.currentFrame != 2) {
					this.anim.currentFrame = 1;
				}
				
				if(event.type == "mouseup") {
					this.anim.currentFrame = 1;
				}
				
				if(event.type == "click") {
					this.onClick();
				}
		} else {
			this.anim.currentFrame = 0;
		}
	}
	
	this.x = x;
	this.y = y;
	this.anim = anim;
	this.anim.frameRate = 0;
	this.onClick = onClick;
	this.active = true;
	
	return(this);
}

function puckOff () {
	startButton.active = false;
	
	mainRunner.addToPath(64, 0.5, Directions.BACK);
	otherRunners[0].addToPath(65, 0, Directions.BACK);
	otherRunners[1].addToPath(65, 1, Directions.FORWARD);
	
	gameMaze.numberOfCoinsLeft = gameMaze.numberOfPathObjects();
}

function gameOver () {
	startButton.active = true;
	gameMaze.resetPathObjects();
	
	mainRunner.pathIndex = null;
	mainRunner.score = 0;
	otherRunners[0].pathIndex = null;
	otherRunners[0].score = 0;
	otherRunners[1].pathIndex = null;
	otherRunners[1].score = 0;
}

function sound (file) {
	this.audio = new Audio(file);
	
	this.audio.oncanplaythrough = mediaOnload;

	this.play = function () {
		this.audio.play();
	}

	return(this);
}

function anim () {
	this.render = function (x, y, angle) {
		if(this.frames > 0) {
			
			context.save();
			context.translate(x, y);
			context.rotate(angle);
			context.drawImage(this.img, 0, this.currentFrame * this.height, this.width, this.height, - this.width / 2, - this.height / 2, this.width, this.height);
			context.restore();
			
			this.currentFrame = (this.currentFrame + this.frameRate) % this.frames;
		}
	}
	
	this.ajax = getXMLObject();
	
	this.img = new Image();
	this.width = 0;
	this.height = 0;
	this.frames = 0;
	this.currentFrame = 0;
	this.frameRate = 1;
	return(this);
}

function loadAnim (animObj, folder) {
	animObj.ajax.onreadystatechange = function(data) {
			if(this.readyState == 4 && this.status == 200) {
				animObj.img.onload = mediaOnload;
				animObj.img.src = "anim.php?folder=" + folder;
				var animInfo = JSON.parse(data.currentTarget.response);
				animObj.width = animInfo.width;
				animObj.height = animInfo.height;
				animObj.frames = animInfo.frames;
			}
		}
		
	animObj.ajax.open("GET", "loadAnim.php?folder=" + folder, true);
	animObj.ajax.send();
}

function img () {
	this.render = function (x, y) {
		if(this.width > 0 && this.height > 0) {
			context.drawImage(this.img, 0, 0, this.width, this.height, x, y, this.width, this.height);
		}
	}
	
	this.ajax = getXMLObject();
	
	this.img = new Image();
	this.width = 0;
	this.height = 0;
}

function loadImg (imgObj, file) {
	imgObj.ajax.onreadystatechange = function(data) {
			if(this.readyState == 4 && this.status == 200) {
				imgObj.img.onload = mediaOnload;
				var imgInfo = JSON.parse(data.currentTarget.response);
				imgObj.img.src = "images/" + imgInfo.file + ".png";
				imgObj.width = imgInfo.width;
				imgObj.height = imgInfo.height;
			}
		}
		
	imgObj.ajax.open("GET", "loadImg.php?file=" + file, true);
	imgObj.ajax.send();
}

function mediaOnload (parameter) {
	loadCounter--;
	
	if(loadCounter == 0) {
		loadEvent();
	}
}

function toggleGameLoop () {
	if(gameLoopTimer != null) {
		stopGameLoop();
	} else {
		startGameLoop();
	}
}

function startGameLoop () {
	if(gameLoopTimer == null) {
		gameLoopTimer = setInterval(gameLoop, 1000 / 60);
	}
}

function stopGameLoop () {
	clearTimeout(gameLoopTimer);
	gameLoopTimer = null;
}

function gameLoop () {
	for(var i = 0; i < otherRunners.length; i++) {
		otherRunners[i].run();
	}
	
	mainRunner.run();
	
	runnerCollide();
	
	context.clearRect(0, 0, canvas.width, canvas.height);
	bg.render(0, 0);
	
	gameMaze.render();
	
	displayScore(mainRunner.score, canvas.width / 2, canvas.height / 2 - 50);
	
	var otherRunnersScore = 0;
	
	for(var i = 0; i < otherRunners.length; i++) {
		otherRunnersScore += otherRunners[i].score;
	}
	
	displayScore(otherRunnersScore, canvas.width / 2, canvas.height / 2 + 50);
	
	for(var i = 0; i < otherRunners.length; i++) {
		otherRunners[i].render();
	}
	
	mainRunner.render();
	
	startButton.render();
	
	if(gameMaze.numberOfCoinsLeft <= 0) {
		gameOver();
	}
}

MAZE GAME

MAZE.JS

GAME.JS

MAZE-GAME.HTML

LOADIMG.PHP

ANIM.PHP

LOADANIM.PHP