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

this.beforeRender = R3.EntityManager.Instance.findComponentById('skmfv0tk0w');
this.renderer = R3.EntityManager.Instance.findComponentById('fhfk8i6u7v');
this.keyDown = R3.EntityManager.Instance.findComponentById('4sjzwfvciu');
this.touchStart = R3.EntityManager.Instance.findComponentById('fs7e9y1lhh');
this.touchEnd = R3.EntityManager.Instance.findComponentById('3b588t2jz1');
this.box2 = R3.EntityManager.Instance.findComponentById('rr7z2fcdax');
this.image7 = R3.EntityManager.Instance.findComponentById('tzoiov5vo4');
this.image10 = R3.EntityManager.Instance.findComponentById('md3iest7ox');
this.image11 = R3.EntityManager.Instance.findComponentById('ofn6o71n9b');
this.image13 = R3.EntityManager.Instance.findComponentById('1026puir3d');
this.image14 = R3.EntityManager.Instance.findComponentById('vr9yv8qd2q');
this.image15 = R3.EntityManager.Instance.findComponentById('jg7m44cfjc');
this.boxCenter = R3.EntityManager.Instance.findComponentById('onflseabh3');
this.animation = R3.EntityManager.Instance.findComponentById('0429064v9c');
this.canvas = R3.EntityManager.Instance.findComponentById('kttg10l8u6');
this.burnLight = R3.EntityManager.Instance.findComponentById('zstk8iq2p2');
this.flamesSmall = R3.EntityManager.Instance.findComponentById('a3s12sqr9a');
this.camera = R3.EntityManager.Instance.findComponentById('gruhmdgjmi');
this.glow = R3.EntityManager.Instance.findComponentById('8ygsthn4n8');
this.glowMaterial = R3.EntityManager.Instance.findComponentById('3kg5h22b3h');
this.scoreTexture = R3.EntityManager.Instance.findComponentById('9azkxtbiaf');
this.scene = R3.EntityManager.Instance.findComponentById('h30wqcvha0');
this.gridMaterial = R3.EntityManager.Instance.findComponentById('jkpel4rvsy');
this.animationSystems = R3.EntityManager.Instance.queryComponents(R3.Component.SYSTEM_ANIMATION);

R3.CustomCode.TETRIS_BLOCK_I = 0;
R3.CustomCode.TETRIS_BLOCK_L = 1;
R3.CustomCode.TETRIS_BLOCK_L2 = 2;
R3.CustomCode.TETRIS_BLOCK_Z = 3;
R3.CustomCode.TETRIS_BLOCK_Z2 = 4;
R3.CustomCode.TETRIS_BLOCK_T = 5;
R3.CustomCode.TETRIS_BLOCK_O = 6;
R3.CustomCode.TETRIS_BLOCK_MAX = 7;

R3.CustomCode.TETRIS_GRID_WIDTH = 11;
R3.CustomCode.TETRIS_GRID_HEIGHT = 24;
R3.CustomCode.TETRIS_GRID_HEADSPACE = 4;

R3.CustomCode.TETRIS_GRID_NOT_TAKEN = 0;
R3.CustomCode.TETRIS_GRID_TAKEN = 1;
R3.CustomCode.TETRIS_GRID_DISAPPEARING = 2;

R3.CustomCode.prototype.visualizeGrid = function (color) {

	if (this.starsMesh) {
		this.scene.instance.remove(this.starsMesh);
	}

	this.starsGeometry = new THREE.Geometry();

	for (var y = 0; y < this.beforeRender.grid.length; y++) {
		for (var x = 0; x < this.beforeRender.grid[y].length; x++) {
			if (this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
				this.starsGeometry.vertices.push(
					new THREE.Vector3(
						x,
						y,
						5
					)
				);
			}
		}
	}

	var starsMaterial = new THREE.PointsMaterial({color: color, size: 0.1});

	this.starsMesh = new THREE.Points(this.starsGeometry, starsMaterial);

	this.scene.instance.add(this.starsMesh);

}.bind(this)

R3.CustomCode.prototype.startAnimation = function (index) {

	var glow = this.glow.clone();

	glow.position.y = index;
	glow.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
	glow.position.z = 2;
	glow.updateInstance('position');

	var flames = this.flamesSmall.clone();

	flames.position.y = index + 1;
	flames.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
	flames.position.z = 2;
	flames.updateInstance('position');

	var animationObject = {
		rowNumber: index,
		glow: glow,
		flames: flames,
		flamesArray: [],
		time: 0
	}

	this.animationObjects.push(animationObject);

}.bind(this)

R3.CustomCode.prototype.removeLines = function () {

	var indices = [];

	for (var y = 0; y < R3.CustomCode.TETRIS_GRID_HEIGHT; y++) {

		var line = true;

		for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
			if (
				this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_NOT_TAKEN ||
				this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_DISAPPEARING
			) {
				line = false;
			}
		}

		if (line) {
			indices.push(y);
		}
	}

	var multiplier = 1;

	if (indices.length === 4) {
		multiplier = 10000;
	}

	if (indices.length === 3) {
		multiplier = 1000;
	}

	if (indices.length === 2) {
		multiplier = 100;
	}

	if (indices.length === 1) {
		multiplier = 10;
	}

	this.score += (multiplier * this.level);

	this.rows += indices.length;

	this.level = Math.floor(this.rows / 5) + 1;

	if (this.level === 1) {
		this.speed = 1;
	}

	if (this.level === 2) {
		this.speed = 0.9;
	}

	if (this.level === 3) {
		this.speed = 0.85;
	}

	if (this.level === 4) {
		this.speed = 0.8;
	}

	if (this.level === 5) {
		this.speed = 0.75;
	}

	if (this.level === 6) {
		this.speed = 0.7;
	}

	if (this.level === 7) {
		this.speed = 0.65;
	}

	if (this.level === 8) {
		this.speed = 0.6;
	}

	if (this.level === 9) {
		this.speed = 0.55;
	}

	if (this.level === 10) {
		this.speed = 0.5;
	}

	if (this.level === 11) {
		this.speed = 0.45;
	}

	if (this.level === 12) {
		this.speed = 0.4;
	}

	if (this.level === 13) {
		this.speed = 0.35;
	}

	if (this.level === 14) {
		this.speed = 0.3;
	}

	if (this.level === 15) {
		this.speed = 0.25;
	}

	if (this.level === 16) {
		this.speed = 0.2;
	}

	if (this.level >= 17) {
		this.speed = 0.18;
	}

	this.drawStatus();

	this.animationsDone = [];

	indices.map(
		function (index) {
			for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
				this.beforeRender.grid[index][x].value = R3.CustomCode.TETRIS_GRID_DISAPPEARING;
			}
			this.startAnimation(index);
		}.bind(this)
	);

}.bind(this);


R3.CustomCode.prototype.drawStatus = function () {
	var context = this.canvas.instance.getContext('2d');

	context.textBaseline = "middle";

	context.clearRect(0, 0, this.canvas.width, this.canvas.height);

	context.fillStyle = "rgba(15, 15, 15, 0.7)";
	context.fillRect(12, 30, 485, 178);

	context.lineWidth = 8;

	context.strokeStyle = '#05c870';
	context.strokeRect(12, 30, 485, 178);

	context.beginPath();
	context.moveTo(11, 68);
	context.lineTo(498, 68);
	context.stroke();

	context.beginPath();
	context.moveTo(172, 30);
	context.lineTo(172, 208);
	context.stroke();

	context.beginPath();
	context.moveTo(172, 135);
	context.lineTo(498, 135);
	context.stroke();

	context.beginPath();
	context.moveTo(172, 172);
	context.lineTo(498, 172);
	context.stroke();

	/**
         * Write text
         */
	context.fillStyle = '#3db5e6';
	context.font = '20pt BkBold';
	context.fillText('NEXT TILES', 23, 52);

	context.fillText('SCORE', 182, 52);

	context.fillText('LEVEL', 182, 156);

	context.fillText('ROWS', 182, 193);

	context.fillStyle = '#ffffff';

	context.font = '50pt BkBold';

	var str = this.score.toString();
	var pad = "0000000";
	var ans = pad.substring(0, pad.length - str.length) + str;

	context.fillText(ans, 225, 110);

	str = this.level.toString();
	pad = "000";
	ans = pad.substring(0, pad.length - str.length) + str;

	context.font = '20pt BkBold';
	context.fillText(ans, 435, 156);

	str = this.rows.toString();
	pad = "000";
	ans = pad.substring(0, pad.length - str.length) + str;

	context.font = '20pt BkBold';
	context.fillText(ans, 435, 193);

	this.scoreTexture.instance.needsUpdate = true;
}.bind(this)

R3.CustomCode.prototype.getBlockGridPositions = function (block) {

	var object = new THREE.Mesh();

	object.position.x = block.center.position.x;
	object.position.y = block.center.position.y;
	object.position.z = block.center.position.z;
	object.rotation.x = block.center.rotation.x;
	object.rotation.y = block.center.rotation.y;
	object.rotation.z = block.center.rotation.z;

	var children = block.meshes.map(
		function (mesh) {
			var child = new THREE.Mesh();
			child.position.x = mesh.position.x;
			child.position.y = mesh.position.y;
			child.position.z = mesh.position.z;
			object.add(child);
			child.mesh = mesh;
			return child;
		}
	);

	object.updateMatrixWorld();

	var positions = children.map(
		function (child) {

			var vector = new THREE.Vector3();

			vector.setFromMatrixPosition(child.matrixWorld);

			var x = vector.x;
			var y = vector.y;

			x = Math.round(x);
			y = Math.round(y);

			return {
				x: x,
				y: y,
				mesh: child.mesh
			}
		}
	);

	return positions;

}.bind(this);

R3.CustomCode.prototype.stopAnimations = function () {
	this.animationSystems.map(
		function (system) {
			if (system.started) {
				system.stop();
			}
		}
	);
}.bind(this)

R3.CustomCode.prototype.startAnimations = function () {
	this.animationSystems.map(
		function (system) {
			if (!system.started) {
				system.start();
			}
		}
	);
}.bind(this)

R3.CustomCode.prototype.drawGrid = function () {

	this.gridMaterial.color.fromHex('#3db5e6');
	this.gridMaterial.color.updateInstance('color');

	var geometry = new THREE.Geometry();

	for (var y = 0; y < (R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE); y++) {
		for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
			geometry.vertices.push(
				new THREE.Vector3(
					x,
					y,
					0.17
				)
			)
		}
	}

	this.scene.instance.add(new THREE.Points(geometry, this.gridMaterial.instance));

	geometry = new THREE.Geometry();

	geometry.vertices.push(
		new THREE.Vector3(
			-0.5,
			R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE - 0.5,
			5
		),
		new THREE.Vector3(
			-0.5,
			-0.5,
			5
		),
		new THREE.Vector3(
			R3.CustomCode.TETRIS_GRID_WIDTH - 0.5,
			-0.5,
			5
		),
		new THREE.Vector3(
			R3.CustomCode.TETRIS_GRID_WIDTH - 0.5,
			R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE - 0.5,
			5
		)
	);

	this.scene.instance.add(
		new THREE.Line(
			geometry,
			new THREE.LineBasicMaterial(
				{
					linewidth: 3,
					color: 0x3db5e6
				}
			)
		)
	);


}.bind(this)

R3.CustomCode.prototype.checkBoundaries = function (block) {

	/**
         * collisions are true only for out of bounds indexes, and if the current block is taken
         */
	var gridPositions = this.getBlockGridPositions(block);

	var leftHit = false;
	var rightHit = false;
	var bottomHit = false;
	var topHit = false;
	var collision = false;
	var bottomDisappearing = false;

	gridPositions.map(
		function (position) {

			/**
                 * Check grid boundaries
                 */
			if (position.x === 0) {
				leftHit = true;
			}

			if (position.x === (R3.CustomCode.TETRIS_GRID_WIDTH - 1)) {
				rightHit = true;
			}

			if (position.y === 0) {
				bottomHit = true;
			}

			if (position.y === (R3.CustomCode.TETRIS_GRID_HEIGHT - 1)) {
				topHit = true;
			}

			/**
                 * Check outside of bounds
                 */
			if (position.x < 0) {
				collision = true;
			}

			if (position.x >= R3.CustomCode.TETRIS_GRID_WIDTH) {
				collision = true;
			}

			if (position.y < 0) {
				collision = true;
			}

			if (position.y >= R3.CustomCode.TETRIS_GRID_HEIGHT) {
				collision = true;
			}

			/**
                 * We want to see if the block to the right is taken, but we cannot
                 * be sure x+1 is inside bounds
                 */
			if (
				((position.x + 1) < R3.CustomCode.TETRIS_GRID_WIDTH) &&
				((position.x + 1) >= 0)
			) {
				/**
                     * But we cannot be sure y is inside bounds
                     */
				if (position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0) {
					if (this.beforeRender.grid[position.y][position.x + 1].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
						/**
                             * Ok - we found a block to the right - its over
                             */
						rightHit = true;
					}
				}
			}


			/**
                 * We want to see if the block to the left is taken, but we cannot be sure x - 1 is inside bounds
                 */
			if (
				((position.x) > 0) &&
				((position.x - 1) >= 0) &&
				((position.x - 1) < R3.CustomCode.TETRIS_GRID_WIDTH)
			) {

				/**
                     * But we cannot be sure y is inside bounds
                     */
				if (position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0) {
					if (this.beforeRender.grid[position.y][position.x - 1].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
						/**
                             * We found a block to the left - its over also
                             */
						leftHit = true;
					}
				}
			}

			/**
                 * Now we want to see if the block above is taken, we cannot be sure y+1 is inside bounds
                 */
			if (
				((position.y + 1) < R3.CustomCode.TETRIS_GRID_HEIGHT) &&
				((position.y + 1) >= 0)
			) {
				/**
                     * We cannot be sure, position.x is inside bounds
                     */
				if (position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) {

					if (this.beforeRender.grid[position.y + 1][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
						/**
                             * Ok - this block is at the top
                             */
						topHit = true;
					}
				}
			}

			/**
                 * Now we want to see if the block below is taken, we cannot be sure y-1 is inside bounds
                 */
			if (
				((position.y) > 0) &&
				((position.y - 1) >= 0) &&
				((position.y - 1) < R3.CustomCode.TETRIS_GRID_HEIGHT)
			) {
				/**
                     * We cannot be sure, position.x is inside bounds
                     */
				if (position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) {
					if (this.beforeRender.grid[position.y - 1][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
						/**
                             * Ok - this block hit bottom
                             */
						bottomHit = true;
					}

					if (this.beforeRender.grid[position.y - 1][position.x].value === R3.CustomCode.TETRIS_GRID_DISAPPEARING) {
						bottomDisappearing = true;
					}
				}
			}

			/**
                 * Now we want to see if the block is inside another block,
                 * we cannot be sure, x and y is inside bounds
                 */
			if (
				(position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) &&
				(position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0)
			) {
				if (this.beforeRender.grid[position.y][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
					collision = true;
				}
			}
		}.bind(this)
	);

	return {
		left: leftHit,
		top: topHit,
		right: rightHit,
		bottom: bottomHit,
		bottomDisappearing: bottomDisappearing,
		collision: collision
	}

}.bind(this)

R3.CustomCode.prototype.rotateBlock = function (clockwise) {

	if (this.beforeRender.gameOver) {
		return;
	}

	if (clockwise) {
		var targetRotation = this.block.center.rotation.z - Math.PI / 2;
	} else {
		var targetRotation = this.block.center.rotation.z + Math.PI / 2;
	}

	this.stopAnimations();

	var originalRotation = this.block.center.rotation.z;

	this.block.center.rotation.z = targetRotation;
	this.block.center.updateInstance('rotation');

	var boundaries = this.checkBoundaries(this.block);

	if (boundaries.collision) {

		this.block.center.rotation.z = originalRotation;
		this.block.center.updateInstance('rotation');

		this.startAnimations();

	} else {

		this.block.center.rotation.z = originalRotation;

		this.startAnimations();

		this.block.center.rotation.z = targetRotation;
		this.block.center.updateInstance('rotation');

	}

}.bind(this);

R3.CustomCode.prototype.moveBlock = function (block, direction, units, collisionCheck) {

	if (!units) {
		units = 1;
	}

	var boundaries = null;
	var moved = false;

	if (collisionCheck) {
		boundaries = this.checkBoundaries(block);
	}

	if (boundaries && boundaries.collision) {
		return moved;
	}

	if (direction.left) {

		if (boundaries && boundaries.left) {
			//Do nothing
		} else {
			block.center.position.x -= units;
			moved = true;
		}
	}

	if (direction.right) {

		if (boundaries && boundaries.right) {
			//Do nothing
		} else {
			block.center.position.x += units;
			moved = true;
		}
	}

	if (direction.down) {

		if (boundaries && boundaries.bottom) {
			//Do nothing
		} else if (boundaries && boundaries.bottomDisappearing) {
			/**
                 * Set moved to 'null' instead of 'false' - null indicates to called we should wait - while still being 'false'
                 */
			moved = null;
		} else {
			block.center.position.y -= units;
			moved = true;
		}
	}

	if (direction.up) {

		if (boundaries && boundaries.top) {
			//Do nothing
		} else {
			block.center.position.y += units;
			moved = true;
		}
	}

	if (moved) {
		block.center.updateInstance('position');
	}

	return moved;
}.bind(this);

R3.CustomCode.prototype.spawnBlock = function () {

	var blockType = Math.floor(Math.random() * 7);

	var mesh0 = null;
	var mesh1 = null;
	var mesh2 = null;
	var mesh3 = null;

	var offsetX = 0;
	var offsetY = 0;

	var tinyPositionX = 0;
	var tinyPositionY = 0;

	var nextPositionX = 0;
	var nextPositionY = 0;

	var center = this.boxCenter.clone();

	center.position.y = 0;
	center.position.x = 0;
	center.position.z = 0.4;

	if (blockType === R3.CustomCode.TETRIS_BLOCK_I) {

		mesh0 = this.box11.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.x -= 1;

		mesh1 = this.box13.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.x -= 2;

		mesh2 = this.box14.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;
		mesh2.position.x += 0;

		mesh3 = this.box15.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x += 1;

		offsetX = 0.5;
		offsetY = 1;

		tinyPositionX = 1.32;
		tinyPositionY = 16.7;

		nextPositionX = 2.12;
		nextPositionY = 15.5;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_L) {
		mesh0 = this.box14.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.x += 1;
		mesh0.position.y += 1;

		mesh1 = this.box11.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.x += 1;

		mesh2 = this.box14.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;
		mesh2.position.x += 0;

		mesh3 = this.box15.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x -= 1;

		offsetX = 0.5;
		offsetY = 2;

		tinyPositionX = 1.00;
		tinyPositionY = 16.65;

		nextPositionX = 1.78;
		nextPositionY = 15.3;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_L2) {
		mesh0 = this.box14.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.x -= 1;
		mesh0.position.y += 1;

		mesh1 = this.box11.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.x += 1;

		mesh2 = this.box14.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;
		mesh2.position.x += 0;

		mesh3 = this.box15.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x -= 1;

		offsetX = 0.5;
		offsetY = 2;

		tinyPositionX = 1.00;
		tinyPositionY = 16.65;

		nextPositionX = 1.78;
		nextPositionY = 15.3;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_Z) {
		mesh0 = this.box10.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.y += 1;

		mesh1 = this.box11.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.x -= 1;
		mesh1.position.y += 1;

		mesh2 = this.box15.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;

		mesh3 = this.box7.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x += 1;

		offsetX = 0.5;
		offsetY = 2;

		tinyPositionX = 1.00;
		tinyPositionY = 16.65;

		nextPositionX = 1.78;
		nextPositionY = 15.3;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_Z2) {

		mesh0 = this.box10.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.y += 1;

		mesh1 = this.box11.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.x += 1;
		mesh1.position.y += 1;

		mesh2 = this.box15.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;

		mesh3 = this.box7.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x -= 1;

		offsetX = 0.5;
		offsetY = 2;

		tinyPositionX = 1.00;
		tinyPositionY = 16.65;

		nextPositionX = 1.78;
		nextPositionY = 15.3;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_T) {
		mesh0 = this.box14.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.y -= 1;

		mesh1 = this.box13.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;

		mesh2 = this.box11.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;
		mesh2.position.x -= 1;

		mesh3 = this.box15.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.x += 1;

		offsetX = 0.5;
		offsetY = 1;

		tinyPositionX = 1.00;
		tinyPositionY = 17;

		nextPositionX = 1.78;
		nextPositionY = 16;
	}

	if (blockType === R3.CustomCode.TETRIS_BLOCK_O) {
		mesh0 = this.box10.clone();
		mesh0.position.setFrom(center.position);
		mesh0.position.z = -0.1;
		mesh0.position.y += 0.5;
		mesh0.position.x += 0.5;

		mesh1 = this.box2.clone();
		mesh1.position.setFrom(center.position);
		mesh1.position.z = -0.1;
		mesh1.position.y += 0.5;
		mesh1.position.x -= 0.5;

		mesh2 = this.box13.clone();
		mesh2.position.setFrom(center.position);
		mesh2.position.z = -0.1;
		mesh2.position.y -= 0.5;
		mesh2.position.x -= 0.5;

		mesh3 = this.box15.clone();
		mesh3.position.setFrom(center.position);
		mesh3.position.z = -0.1;
		mesh3.position.y -= 0.5;
		mesh3.position.x += 0.5;

		offsetX = 0;
		offsetY = 1.5;

		tinyPositionX = 1.00;
		tinyPositionY = 16.85;

		nextPositionX = 1.78;
		nextPositionY = 15.65;
	}

	mesh0.setParentMesh(center);
	mesh1.setParentMesh(center);
	mesh2.setParentMesh(center);
	mesh3.setParentMesh(center);

	center.updateInstance('position');

	mesh0.updateInstance('position');
	mesh1.updateInstance('position');
	mesh2.updateInstance('position');
	mesh3.updateInstance('position');

	var block = {
		type: blockType,
		offset: {
			x: offsetX,
			y: offsetY
		},
		tinyPosition: {
			x: tinyPositionX,
			y: tinyPositionY
		},
		nextPosition: {
			x: nextPositionX,
			y: nextPositionY
		},
		meshes: [
			mesh0,
			mesh1,
			mesh2,
			mesh3
		],
		angle: center.rotation.z,
		center: center
	};

	return block;

}.bind(this)

R3.CustomCode.prototype.spawnTinyBlock = function () {

	var block = this.spawnBlock();

	/**
         * Set the scale for the blocks
         */
	block.center.scale.x = 0.333;
	block.center.scale.y = 0.333;
	block.center.scale.z = 0.333;
	block.center.updateInstance('scale');

	/**
         * move tiny block a bit up - then a bit right
         */
	block.center.position.x = block.tinyPosition.x;
	block.center.position.y = block.tinyPosition.y;
	block.center.position.z = 0.4;
	block.center.updateInstance('position');

	return block;
}.bind(this)

R3.CustomCode.prototype.spawnNextBlock = function () {

	if (!this.tinyBlock) {
		this.tinyBlock = this.spawnTinyBlock();
	}

	var block = this.tinyBlock;

	block.center.scale.x = 0.666;
	block.center.scale.y = 0.666;
	block.center.scale.z = 0.666;
	block.center.updateInstance('scale');

	block.center.position.x = block.nextPosition.x;
	block.center.position.y = block.nextPosition.y;
	block.center.position.z = 0.4;
	block.center.updateInstance('position');

	this.tinyBlock = this.spawnTinyBlock();

	return block;
}.bind(this)

R3.CustomCode.prototype.spawnBigBlock = function () {

	if (!this.nextBlock) {
		this.nextBlock = this.spawnNextBlock();
	}

	var block = this.nextBlock;

	block.center.scale.x = 1;
	block.center.scale.y = 1;
	block.center.scale.z = 1;
	block.center.updateInstance('scale');

	block.center.position.x = 0;
	block.center.position.y = 0;
	block.center.position.z = 0.4;
	block.center.updateInstance('position');

	this.moveBlock(block, {up: true}, (R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE), false);
	this.moveBlock(block, {right: true}, R3.CustomCode.TETRIS_GRID_WIDTH / 2, false);
	this.moveBlock(block, {left: true}, block.offset.x, false);
	this.moveBlock(block, {down: true}, block.offset.y, false);

	this.nextBlock = this.spawnNextBlock();

	return block;
}.bind(this)

R3.CustomCode.prototype.getNextBlock = function () {

	this.stopAnimations();

	this.beforeRender.block = this.spawnBigBlock();

	this.block = this.beforeRender.block;

	R3.Event.Emit(
		R3.Event.COMPONENT_REGISTER,
		{
			component: this.block.center
		}
	);

	this.startAnimations();

	this.animation.addMesh(this.block.center);

}.bind(this);

if (R3.Utils.UndefinedOrNull(this.subscriptions)) {

	this.subscriptions = [];

	R3.Event.Subscribe(
		R3.Event.CUSTOM_CODE_WINDOW_RESIZE,
		function (data) {
			//var aspect = data.width / data.height;			
			this.camera.offsetX = -((this.camera.maxX - this.camera.minX) / 2) + (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5 - (0.5 * this.camera.aspect);
			this.camera.updateInstance('offsetX');
		}.bind(this)
	)

	this.subscriptions.push(
		new R3.Event.Subscribe(
			R3.Event.CUSTOM_GAME_START,

			function () {

				R3.Event.Emit(
					R3.Event.WINDOW_RESIZE,
					{
						width : window.innerWidth,
						height : window.innerHeight
					}
				);
				
				this.animationObjects = [];

				this.score  = 0;
				this.level  = 1;
				this.rows   = 0;
				this.speed  = 1;

				this.drawGrid();

				this.drawStatus();

				/**
                     * Set the game parameters
                     */
				this.beforeRender.entityLoaded = null;
				this.beforeRender.initialized = false;

				/**
                     * Link the classes
                     */
				this.beforeRender.entityLoaded = this;
				this.keyDown.entityLoaded = this;
				this.touchEnd.entityLoaded = this;
				this.touchStart.entityLoaded = this;

				console.log('custom game start complete');

			}.bind(this)
		)
	);
}

/**
     * Setup the game objects
     * @type {boolean}
     */
this.box7 = this.box2.clone();
var material = this.box2.materials[0].clone();
var texture = material.diffuseMap.clone();
texture.image = this.image7;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box7.materials = [material];
this.box7.materials[0].updateInstance('diffuseMap');

this.box10 = this.box2.clone();
material = this.box2.materials[0].clone();
texture = material.diffuseMap.clone();
texture.image = this.image10;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box10.materials = [material];
this.box10.materials[0].updateInstance('diffuseMap');

this.box11 = this.box2.clone();
material = this.box2.materials[0].clone();
texture = material.diffuseMap.clone();
texture.image = this.image11;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box11.materials = [material];
this.box11.materials[0].updateInstance('diffuseMap');

this.box13 = this.box2.clone();
material = this.box2.materials[0].clone();
texture = material.diffuseMap.clone();
texture.image = this.image13;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box13.materials = [material];
this.box13.materials[0].updateInstance('diffuseMap');

this.box14 = this.box2.clone();
material = this.box2.materials[0].clone();
texture = material.diffuseMap.clone();
texture.image = this.image14;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box14.materials = [material];
this.box14.materials[0].updateInstance('diffuseMap');

this.box15 = this.box2.clone();
material = this.box2.materials[0].clone();
texture = material.diffuseMap.clone();
texture.image = this.image15;
texture.updateInstance('image');
material.diffuseMap = texture;
this.box15.materials = [material];
this.box15.materials[0].updateInstance('diffuseMap');

R3.Event.Emit(R3.Event.GAME_LOADED);

//@ sourceURL=entityLoaded.js