if (this.parentEntity === data.entity) {
	console.log('snake entity loaded');
} else {
	return;
}

/**
 * Defines
 */
GameLib.CustomCode.BODY_TYPE_NORMAL	= 0x1;
GameLib.CustomCode.BODY_TYPE_TAIL	= 0x2;

GameLib.CustomCode.GRID_WIDTH 	= 11;
GameLib.CustomCode.GRID_HEIGHT 	= 11;

GameLib.CustomCode.GRID_OFFSET_X = 1;
GameLib.CustomCode.GRID_OFFSET_Y = 5;

GameLib.CustomCode.SPEED_INITIAL = 1;

/**
 * Get runtime
 */
this.runtime = GameLib.Utils.GetRuntime();

/**
 * Custom Code Components
 */
this.beforeRender 	= GameLib.EntityManager.Instance.findComponentById('zjq6ach3jt');
this.keyUp			= GameLib.EntityManager.Instance.findComponentById('306204wy29');

/**
 * Geometries
 */
this.geometryBody = GameLib.EntityManager.Instance.findComponentById('8f5q7k5ozp'); 

/**
 * Images
 */
this.imageBreadEnd		= GameLib.EntityManager.Instance.findComponentById('swkla3wpp');
this.imageBreadPatty	= GameLib.EntityManager.Instance.findComponentById('01r51k9ptr');
this.imageBreadCorner	= GameLib.EntityManager.Instance.findComponentById('iljpuouaok');
this.imagePatty			= GameLib.EntityManager.Instance.findComponentById('4lf0fw24su');

/**
 * Other Objects (Scene)
 */
this.scene = GameLib.EntityManager.Instance.findComponentById('pllp034hsj');

/**
 * Game objects
 */
this.snake 	= [];
this.grid 	= [];
this.speed	= GameLib.CustomCode.SPEED_INITIAL;
this.advanceTime = 0;
this.state = {
	direction : {
		x : 0,
		y : 1
	},
	rotation : 0
};

GameLib.CustomCode.prototype.createMaterial = function(image) {
	var diffuseMap = new GameLib.D3.Texture.Image(
		this.runtime.graphics,
		{
			image : image
		}
	)
	
	return new GameLib.D3.Material.Phong(
		this.runtime.graphics,
		{
			diffuseMap : diffuseMap
		}
	);
}.bind(this);

GameLib.CustomCode.prototype.createGameMesh = function(image) {
	
	var mesh = new GameLib.D3.Mesh(
		this.runtime.graphics,
		{
			geometry  : this.geometryBody,
			materials : [this.createMaterial(image)]
		}
	)
	
	this.scene.addClone(mesh);
	
	return mesh;
	
}.bind(this)

/**
 * Create our objects
 */
this.meshBreadEnd 					= this.createGameMesh(this.imageBreadEnd);
this.meshBreadEnd.useQuaternion 	= false;

this.meshPatty			= this.createGameMesh(this.imagePatty);

this.meshBreadPatty		= this.createGameMesh(this.imageBreadPatty);
this.meshBreadCorner	= this.createGameMesh(this.imageBreadCorner);

GameLib.CustomCode.SnakeBody = function(
	mesh,
	position,
	rotation
) {	
	if (GameLib.Utils.UndefinedOrNull(bodyType)) {
		throw new Error('no body type specified');
	}
	this.bodyType = bodyType;

	if (GameLib.Utils.UndefinedOrNull(mesh)) {
		throw new Error('no mesh specified');		
	}
	this.mesh = mesh.clone();
	
	if (GameLib.Utils.UndefinedOrNull(position)) {	
		position = {
			x : Math.round(GameLib.CustomCode.GRID_WIDTH / 2),
			y : Math.round(GameLib.CustomCode.GRID_HEIGHT / 2)
		};
	}
	this.position = position;
	
	if (GameLib.Utils.UndefinedOrNull(rotation)) {	
		rotation = 0;
	}
	this.rotation = rotation;
		
	this.applyToMesh();
};

GameLib.CustomCode.SnakeBody.prototype.applyToMesh = function() {
	
	this.mesh.position.x = this.position.x + GameLib.CustomCode.GRID_OFFSET_X;
	this.mesh.position.y = this.position.y + GameLib.CustomCode.GRID_OFFSET_Y;
	
	this.mesh.rotation.z = this.rotation;
	
	/**
	 * TODO: We don't update instance position - animation should do this 
	 */
	this.mesh.updateInstance('position');
	this.mesh.updateInstance('rotation');
}

GameLib.CustomCode.SnakeBody.prototype.advance = function(direction, rotation) {
	this.position.x += direction.x;
	this.position.y += direction.y;
	
	this.rotation = rotation;
}

GameLib.CustomCode.prototype.advanceSnake = function(delta) {
	
	this.advanceTime += delta;
	
	if (this.advanceTime > this.speed) {
		this.advanceTime = 0;
	} else {
		return;
	}
	
	var position = {x:0, y:0};
	//var rotation = 0;
	
	this.snake.map(
		function(body, index) {
				
			if (index === 0) {

				position.x = body.position.x;
				position.y = body.position.y;

				//rotation = body.rotation;
				
				body.advance(
					this.state.direction,
					this.state.rotation
				);
			
			} else {
				
				var tempPosition = {
					x : body.position.x,
					y : body.position.y
				};
			
				//var tempRotation = body.rotation;
				
				body.position.x = position.x;
				body.position.y = position.y;
				
				//body.rotation += this.state.rotation;
			
				position.x = tempPosition.x;
				position.y = tempPosition.y;
				
				//rotation = tempRotation;
				
			}
					
			body.applyToMesh();
		}.bind(this)
	);
	
	this.state.rotation = 0;

}.bind(this);

/*
GameLib.CustomCode.prototype.initializeGrid = function() {
	
	this.grid = [];
	
	for (var x = 0; x < GameLib.CustomCode.GRID_WIDTH; x++) {
		this.grid[x] = [];
		for (var y = 0; y < GameLib.CustomCode.GRID_HEIGHT; y++) {
			this.grid[x][y] = {
				mesh : null,
				direction : {
					x : 0,
					y : 0
				}
			}
		}
	}
	
}.bind(this);
*/

GameLib.Event.Subscribe(
	GameLib.Event.GAME_START,
	function() {
		
		/**
		 * Remove all existing snake parts
		 */
		this.snake.map(
			function(body) {
				body.geometry 	= null;
				body.materials 	= null;
				body.remove();
			}
		)
		
		this.state = {
			direction : {
				x : 0,
				y : 1
			},
			rotation : 0
		};
		
		this.snake = [
			new GameLib.CustomCode.SnakeBody(
				this.meshBreadEnd,
				{
					x : 4,
					y : 4
				},
				0
			),
			new GameLib.CustomCode.SnakeBody(
				this.meshBreadPatty,
				{
					x : 4,
					y : 3
				},
				0
			),
			new GameLib.CustomCode.SnakeBody(
				this.meshBreadPatty,
				{
					x : 4,
					y : 2
				},
				0
			),
			new GameLib.CustomCode.SnakeBody(
				this.meshBreadEnd,
				{
					x : 4,
					y : 1
				},
				Math.PI
			)
		];
		
		/**
		 * Cleanup grid
		 *
		this.grid.map(
			function(x) {
				x.map(
					function(y) {
						y.mesh.geometry		= null;
						y.mesh.materials	= null;
						y.mesh.remove();
					}
				);
			}
		);
		
		this.initializeGrid();
		*/
		
		/**
		 * Other Settings
		 */
		this.speed = GameLib.CustomCode.SPEED_INITIAL;

		/**
		 * Re-initialize our other custom code components
		 */
		this.beforeRender.initialized	= false;
		this.beforeRender.entityLoaded 	= this;
		
		this.keyUp.initialized 	= false;
		this.keyUp.entityLoaded = this;
		
		console.log('starting game snake');
	}.bind(this)
);

GameLib.Event.Subscribe(
	GameLib.Event.GAME_OVER,
	function() {

		this.keyUp.initialized 	= false;
		this.keyUp.entityLoaded = null;
		
		this.beforeRender.initialized = false;
		this.beforeRender.entityLoaded = null;
		
		console.log('starting game snake');
	}.bind(this)
)

GameLib.Event.Emit(GameLib.Event.GAME_LOADED);

//@ sourceURL=entityLoaded.js