diff --git a/zo950m57cc.js b/zo950m57cc.js
new file mode 100644
index 0000000..054056e
--- /dev/null
+++ b/zo950m57cc.js
@@ -0,0 +1,995 @@
+if (!this.entityLoaded) {
+	return;
+}
+
+if (GameLib.Utils.UndefinedOrNull(this.initialized)) {
+
+	this.initialized = true;
+
+	GameLib.Event.Emit(GameLib.Event.STOP_ALL_AUDIO);
+
+	GameLib.Event.Emit(
+		GameLib.Event.PLAY_AUDIO,
+		{
+			name : 'Audio - Xmas'
+		}
+	);
+
+	if (this.blastSubscription) {
+		this.blastSubscription.remove();
+	}
+	
+	this.blastSubscription = GameLib.Event.Subscribe(
+		GameLib.Event.AUDIO_ENDED,
+		function(data) {
+			if (data.audio.name.indexOf('Blast') !== -1) {
+				var play = GameLib.Utils.GetRandomIntInclusive(1,5);
+				if (play === 1) {
+					GameLib.Event.Emit(
+						GameLib.Event.PLAY_AUDIO,
+						{
+							name : 'Audio - Ho ho ho'
+						}
+					);
+				}				
+			}
+		}.bind(this)
+	);
+	
+	this.fog = this.entityLoaded.fog;
+	this.bull = this.entityLoaded.bull;
+	this.star = this.entityLoaded.star;
+	this.santa = this.entityLoaded.santa;
+	this.scene = this.entityLoaded.scene;
+	this.camera = this.entityLoaded.camera;
+	this.burger = this.entityLoaded.burger;
+	this.parcel = this.entityLoaded.parcel;
+	this.renderer = this.entityLoaded.renderer;
+	this.raycaster = this.entityLoaded.raycaster;
+	this.kanister = this.entityLoaded.kanister;
+	this.leftLight = this.entityLoaded.leftLight;
+	this.rightLight = this.entityLoaded.rightLight;
+	this.scoreCanvas = this.entityLoaded.scoreCanvas;
+	this.scoreTexture = this.entityLoaded.scoreTexture;
+	this.scoreMesh = this.entityLoaded.scoreMesh;
+	this.throwerLight = this.entityLoaded.throwerLight;
+	this.fireParticleEngine = this.entityLoaded.fireParticleEngine;
+	this.smokeParticleEngine = this.entityLoaded.smokeParticleEngine;
+	this.explodeParticleEngine = this.entityLoaded.explodeParticleEngine;
+	this.burningTreeParticleEngine = this.entityLoaded.burningTreeParticleEngine;
+	
+	this.minimumRendererRed = 0.1;
+
+	this.toBlack = new THREE.Color(0.05, 0.05, 0.05);
+	this.toRed = new THREE.Color(0.02, 0, 0);
+
+	this.bull.instance.visible = false;
+	this.star.instance.visible = false;
+	this.burger.instance.visible = false;
+	this.parcel.instance.visible = false;
+	this.santa.instance.visible = false;
+	this.kanister.instance.visible = false;
+
+	this.treesBurning = 0;
+	this.treesBurningToStart = GameLib.Utils.GetRandomIntInclusive(1, 3);
+
+	this.running = false;
+	
+	this.totalTime = 0;
+
+	this.kanisters = 3;
+	this.kanisterTime = 0;
+	this.kanisterLife = 16.344;
+	this.kanisterLeakTime = 0.1;
+	this.kanisterSpawnScore = 50;
+	
+	this.setNextKanisterSpawnScore = function() {
+
+		this.kanisterSpawnScore = this.score + 100;
+
+		if (this.score > 200) {
+			this.kanisterSpawnScore = this.score + 200;
+		}
+
+		if (this.score > 500) {
+			this.kanisterSpawnScore = this.score + 300;
+		}
+
+		if (this.score > 800) {
+			this.kanisterSpawnScore = this.score + 400;
+		}
+
+		if (this.score > 1100) {
+			this.kanisterSpawnScore = this.score + 500;
+		}
+
+		if (this.score > 1400) {
+			this.kanisterSpawnScore = this.score + 600;
+		}
+
+		if (this.score > 1800) {
+			this.kanisterSpawnScore = this.score + 700;
+		}
+
+		if (this.score > 2500) {
+			this.kanisterSpawnScore = this.score + 800;
+		}
+
+		if (this.score > 3200) {
+			this.kanisterSpawnScore = this.score + 900;
+		}
+
+		if (this.score > 4000) {
+			this.kanisterSpawnScore = this.score + 1000;
+		}
+
+		if (this.score > 5000) {
+			this.kanisterSpawnScore = this.score + 1100;
+		}
+
+		console.log('next kanister spawn score: ' + this.kanisterSpawnScore);
+
+		GameLib.Event.Emit(
+			GameLib.Event.GAME_DATA,
+			{
+				event : 'nextKanisterSpawnScoreUpdate',
+				kanisterSpawnScore : this.kanisterSpawnScore
+			}
+		);
+	};
+
+	this.fuelFinished = false;
+
+	this.level = 1;
+
+	this.enemySpawnInterval = 5;
+	this.enemySpawnTime = this.enemySpawnInterval;
+
+	this.score = 0;
+
+	if (this.enemies instanceof Array && this.enemies.length !== 0) {
+		this.enemies.map(
+			function(enemy) {
+				this.kill(enemy);
+			}.bind(this)
+		)
+	}
+
+	this.scene.meshes.map(
+		function(mesh) {
+			if (mesh.burningTreeParticleEngine) {
+				mesh.burning = false;
+				mesh.life = 1.2;
+				mesh.burningTreeParticleEngine.remove();
+				mesh.burningTreeParticleEngine = null;
+			}
+		}.bind(this)
+	);
+
+	this.enemies = [];
+
+	this.scores = [];
+	
+	this.enemiesSpawned = 0;
+
+	this.fog.density = 0.01;
+	this.fog.updateInstance('density');
+	this.leftLight.intensity = 0.3;
+	this.leftLight.updateInstance('intensity');
+	this.rightLight.intensity = 0.3;
+	this.rightLight.updateInstance('intensity');
+
+	GameLib.Event.Emit(
+		GameLib.Event.GET_GRAPHICS_IMPLEMENTATION,
+		null,
+		function(graphics) {
+			this.graphics = graphics
+		}.bind(this)
+	);
+
+	this.setLevelProperties = function() {
+
+		this.prevLevel = this.level;
+
+		this.level = Math.floor(this.enemiesSpawned / 10) + 1;
+
+		if (this.level === 1) {
+			this.enemySpawnInterval = 4;
+		}
+
+		if (this.level === 2) {
+			this.enemySpawnInterval = 3;
+		}
+
+		if (this.level === 3) {
+			this.enemySpawnInterval = 2;
+		}
+
+		if (this.level > 3) {
+			this.enemySpawnInterval = 1.5;
+		}
+
+		console.log('level : ' + this.level +', spawn interval : ' + this.enemySpawnInterval);
+
+		GameLib.Event.Emit(
+			GameLib.Event.GAME_DATA,
+			{
+				level : this.level,
+				enemySpawnInterval : this.enemySpawnInterval,
+				event : 'levelIncrease'
+			}
+		);
+	};
+
+
+	this.getNextMesh = function(meshType) {
+		
+		var mesh = this.meshes[meshType].reduce(
+			function(result, object) {
+				
+				if (object.inUse === false) {
+					object.inUse = true;
+					result = object.mesh;
+				}
+				
+				return result;
+			},
+			null
+		);
+		
+		if (meshType == 1) {
+	
+		}
+	}
+	
+	this.spawnEnemy = function(kanister) {
+
+		var enemyType	= GameLib.Utils.GetRandomIntInclusive(1, 5);
+		var meshType	= GameLib.Utils.GetRandomIntInclusive(1, 5);
+
+		if (kanister) {
+			meshType = 6;
+		} else {
+			this.enemiesSpawned++;
+			this.setLevelProperties();
+		}
+
+		var y = GameLib.Utils.GetRandomIntInclusive(2, 10);
+
+		var speed = 1;
+
+		var score = 10;
+
+		var material = null;
+
+		var mesh = null;
+		if (meshType === 1) {
+			mesh = this.bull.clone();
+			material = this.bull.materials[0].clone();
+			speed = 0.3;
+		} else if (meshType === 2) {
+			mesh = this.star.clone();
+			score = 20;
+			material = this.star.materials[0].clone();
+			speed = 0.4;
+		} else if (meshType === 3) {
+			mesh = this.burger.clone();
+			score = 50;
+			material = this.burger.materials[0].clone();
+			speed = 0.45;
+		} else if (meshType === 4) {
+			mesh = this.parcel.clone();
+			score = 75;
+			material = this.parcel.materials[0].clone();
+			speed = 0.5;
+		} else if (meshType === 5) {
+			mesh = this.santa.clone();
+			score = 100;
+			material = this.santa.materials[0].clone();
+			speed = 0.6;
+		} else if (meshType === 6) {
+			mesh = this.kanister.clone();
+			score = 100;
+			material = this.kanister.materials[0].clone();
+			speed = 0.7;
+		}
+		else {
+			console.log('unknown mesh type : ' + meshType);
+		}
+
+		mesh.materials = [material];
+
+		mesh.updateInstance();
+
+		mesh.instance.visible = true;
+
+		var velocity = null;
+
+		var axis = new GameLib.API.Vector3(
+			GameLib.Utils.GetRandomIntInclusive(1,10) * 0.1,
+			GameLib.Utils.GetRandomIntInclusive(1,10) * 0.1,
+			GameLib.Utils.GetRandomIntInclusive(1,10) * 0.1
+		);
+
+		axis = axis.normalize();
+
+		var angle = GameLib.Utils.GetRandomIntInclusive(1,100) * 0.001;
+
+		var position = {x : 0, y: y, z :0};
+
+		var rotation = {
+			axis : axis,
+			angle : angle
+		};
+
+		var enemy = {
+			mesh : mesh
+		};
+
+		var distance = 100;
+		var angledistance = distance * Math.sin(Math.PI / 4);
+
+		var life = 5 / speed;
+
+		if (enemyType === 1) {
+			position.x = -distance;
+			life += 3 / speed;
+			velocity = {x:speed,y:0,z:0};
+		}
+
+		if (enemyType === 2) {
+			position.x = distance;
+			life += 3 / speed;
+			velocity = {x:-speed,y:0,z:0};
+		}
+
+		if (enemyType === 3) {
+			position.x = -angledistance;
+			position.z = -angledistance;
+			velocity = {x:speed,y:0,z:speed};
+		}
+
+		if (enemyType === 4) {
+			position.x = angledistance;
+			position.z = -angledistance;
+			velocity = {x:-speed,y:0,z:speed};
+		}
+
+		if (enemyType === 5) {
+			position.x = 0;
+			position.z = -distance;
+			velocity = {x:0,y:0,z:speed};
+		}
+
+		enemy.mesh.position.x = position.x;
+		enemy.mesh.position.y = position.y;
+		enemy.mesh.position.z = position.z;
+		enemy.mesh.updateInstancePosition();
+
+		enemy.mesh.useQuaternion = true;
+		enemy.mesh.quaternion.axis.x = rotation.axis.x;
+		enemy.mesh.quaternion.axis.y = rotation.axis.y;
+		enemy.mesh.quaternion.axis.z = rotation.axis.z;
+		enemy.mesh.quaternion.angle = rotation.angle;
+		enemy.mesh.updateInstanceRotation();
+
+		enemy.velocity = velocity;
+		enemy.rotation = rotation;
+
+		enemy.lifeTime = 0;
+		enemy.life = life;
+
+		enemy.exploding = false;
+		enemy.burning = false;
+		enemy.burnLife = 3;
+		enemy.burnTime = 0;
+		enemy.explodingLife = 2;
+		enemy.meshType = meshType;
+		enemy.score = score;
+		enemy.isKanister = false;
+
+		if (kanister) {
+			enemy.isKanister = true;
+		} else {
+
+			GameLib.Event.Emit(
+				GameLib.Event.GAME_DATA,
+				{
+					enemiesSpawned: this.enemiesSpawned,
+					enemy: enemy,
+					event: 'enemySpawned'
+				}
+			);
+		}
+
+		this.enemies.push(enemy);
+	};
+
+	this.spawnKanister = function() {
+
+		console.log('spawning kanister');
+
+		this.setNextKanisterSpawnScore();
+
+		GameLib.Event.Emit(
+			GameLib.Event.GAME_DATA,
+			{
+				event : 'kanisterCountUpdate',
+				kanisters : this.kanisters
+			}
+		);
+
+		this.spawnEnemy(true);
+	};
+
+
+	this.explodeMesh = function(mesh) {
+
+		mesh.visible = false;
+
+		mesh.updateInstance('visible');
+
+		var sound = GameLib.Utils.GetRandomIntInclusive(1,3);
+
+		var name = 'Audio - Blast 1';
+
+		if (sound === 2) {
+			name = 'Audio - Blast 2';
+		}
+
+		if (sound === 3) {
+			name = 'Audio - Blast 3';
+		}
+
+		GameLib.Event.Emit(
+			GameLib.Event.PLAY_AUDIO,
+			{
+				name : name
+			}
+		);
+
+		var explodeParticleEngine = this.explodeParticleEngine.clone();
+		explodeParticleEngine.position = mesh.position.clone();
+		explodeParticleEngine.updateInstance('position');
+		explodeParticleEngine.enabled = true;
+		mesh.explodeParticleEngine = explodeParticleEngine;
+
+	};
+
+	this.drawScore = function(enemy) {
+
+		this.scoreMesh.materials[0].opacity = 1.0;
+		this.scoreMesh.materials[0].updateInstance('opacity');
+		
+		this.scoreMesh.position = enemy.mesh.position.clone();
+		this.scoreMesh.updateInstance('position');
+		
+		this.scoreMesh.instance.quaternion.copy(this.camera.instance.quaternion);
+		
+		var context = this.scoreCanvas.instance.getContext('2d');
+
+		context.textBaseline = "middle";
+
+		context.clearRect(0,0,this.scoreCanvas.width, this.scoreCanvas.height);
+
+		/**
+			 * Write text
+			 */
+		context.fillStyle = '#e0b899';
+		context.font = '230pt BkBold';
+		context.fillText(enemy.score, 0, this.scoreCanvas.height/2);
+
+		this.scoreTexture.instance.needsUpdate = true;
+
+	}.bind(this)
+
+	
+	this.explode = function(mesh) {
+
+		this.enemies.map(
+			function(enemy) {
+				if (enemy.mesh === mesh && !enemy.exploding) {
+
+					enemy.exploding = true;
+
+					if (enemy.isKanister) {
+						this.kanisters += 1;
+
+						if (this.kanisters > 9) {
+							this.kanisters = 9;
+						}
+						
+						console.log('exploding kanister');
+					} else {
+
+						console.log('exploding enemy');
+
+						this.score += enemy.score;
+
+						this.drawScore(enemy);
+						
+						console.log('score : ' + this.score);
+
+						GameLib.Event.Emit(
+							GameLib.Event.GAME_DATA,
+							{
+								event : 'scoreUpdate',
+								score : this.score
+							}
+						);
+
+						if (this.score > this.kanisterSpawnScore) {
+							this.spawnKanister();
+						}
+
+						GameLib.Event.Emit(
+							GameLib.Event.GAME_DATA,
+							{
+								enemy : enemy,
+								event : 'enemyExploded'
+							}
+						);
+					}
+
+					this.explodeMesh(mesh);
+				}
+			}.bind(this)
+		);
+	};
+
+	this.burn = function(mesh) {
+
+		this.enemies.map(
+			function(enemy) {
+				if (enemy.mesh === mesh && !enemy.burning) {
+
+					console.log('burning enemy ' + mesh.name);
+					enemy.burning = true;
+
+					GameLib.Event.Emit(
+						GameLib.Event.GAME_DATA,
+						{
+							enemy : enemy,
+							event : 'enemyBurned'
+						}
+					);
+
+					var smokeParticleEngine = this.smokeParticleEngine.clone();
+					smokeParticleEngine.position = mesh.position.clone();
+					smokeParticleEngine.updateInstance('position');
+					smokeParticleEngine.enabled = true;
+					mesh.smokeParticleEngine = smokeParticleEngine;
+
+					GameLib.Event.Emit(
+						GameLib.Event.PLAY_AUDIO,
+						{
+							name : 'Audio - Burning'
+						}
+					);
+
+					var fireParticleEngine = this.fireParticleEngine.clone();
+					fireParticleEngine.position = mesh.position.clone();
+					fireParticleEngine.updateInstance('position');
+					fireParticleEngine.enabled = true;
+					mesh.fireParticleEngine = fireParticleEngine;
+				}
+			}.bind(this)
+		);
+
+
+	};
+
+	this.kill = function(enemy) {
+		
+		this.meshes[enemy.meshType].map(
+			function(object) {
+				if (object.mesh === enemy.mesh) {
+					object.inUse = false;
+					object.mesh.visible = false;
+					object.mesh.updateInstance('visibile');
+				}
+			}
+		)
+		
+		/**
+             * We only remove the things we cloned
+             */
+/*		
+GameLib.Event.Emit(
+			GameLib.Event.REMOVE_COMPONENT,
+			{
+				component : enemy.mesh.materials[0]
+			}
+		);
+
+		GameLib.Event.Emit(
+			GameLib.Event.REMOVE_COMPONENT,
+			{
+				component : enemy.mesh
+			}
+		);
+*/
+		/**
+             * Also dispose of the THREE.js objects
+             */
+		//enemy.mesh.instance.geometry.dispose();
+		//enemy.mesh.instance.material.dispose();
+
+		if (enemy.mesh.smokeParticleEngine) {
+			enemy.mesh.smokeParticleEngine.remove();
+			enemy.mesh.smokeParticleEngine = null;
+		}
+
+		if (enemy.mesh.fireParticleEngine) {
+			enemy.mesh.fireParticleEngine.remove();
+			enemy.mesh.fireParticleEngine = null;
+		}
+
+		if (enemy.mesh.explodeParticleEngine) {
+			enemy.mesh.explodeParticleEngine.remove();
+			enemy.mesh.explodeParticleEngine = null;
+		}
+
+	};
+
+	this.burnTree = function(mesh) {
+
+		if (mesh.burning) {
+			/**
+                 * Do nothing, this tree is burning
+                 */
+		} else {
+
+			mesh.burning = true;
+
+			this.treesBurning++;
+
+			if (
+				(this.treesBurning > this.treesBurningToStart) &&
+				!this.running
+			) {
+				this.running = true;
+				GameLib.Event.Emit(
+					GameLib.Event.GAME_DATA,
+					{
+						event : 'gameRunning',
+						message : 'we have enough trees burning now to start - the enemy will spawn now'
+					}
+				);
+			}
+
+			GameLib.Event.Emit(
+				GameLib.Event.GAME_DATA,
+				{
+					event : 'treeBurned',
+					treesBurning : this.treesBurning,
+					treesBurningToStart : this.treesBurningToStart
+				}
+			);
+
+			this.minimumRendererRed += 0.01;
+
+			this.fog.density -= 0.00025;
+			if (this.fog.density < 0.0055) {
+				this.fog.density = 0.0055;
+			}
+			this.fog.updateInstance('density');
+
+			if (mesh.position.x < 0) {
+				this.leftLight.intensity += 0.07;
+
+				if (this.leftLight.intensity >= 1) {
+					this.leftLight.intensity = 1;
+				}
+
+				this.leftLight.updateInstance('intensity');
+
+			} else {
+				this.rightLight.intensity += 0.07;
+
+				if (this.rightLight.intensity >= 1) {
+					this.rightLight.intensity = 1;
+				}
+
+				this.rightLight.updateInstance('intensity');
+
+			}
+
+			GameLib.Event.Emit(
+				GameLib.Event.PLAY_AUDIO,
+				{
+					name : 'Audio - Burning'
+				}
+			);
+
+			var burningTreeParticleEngine = this.burningTreeParticleEngine.clone();
+			burningTreeParticleEngine.position = mesh.position.clone();
+			burningTreeParticleEngine.position.y += mesh.dimensions.y + 5;
+			burningTreeParticleEngine.updateInstance('position');
+			burningTreeParticleEngine.enabled = true;
+			mesh.burningTreeParticleEngine = burningTreeParticleEngine;
+		}
+	};
+
+	GameLib.Event.Emit(
+		GameLib.Event.GAME_STARTED,
+		{
+			game : this
+		}
+	);
+}
+
+this.totalTime += data.delta;
+this.enemySpawnTime += data.delta;
+
+this.scoreMesh.materials[0].opacity -= data.delta * 0.5;
+if (this.scoreMesh.materials[0].opacity < 0) {
+	this.scoreMesh.materials[0].opacity = 0;
+}
+this.scoreMesh.materials[0].updateInstance('opacity');
+
+this.scene.meshes.map(
+	function(mesh) {
+		if (mesh.instance.material instanceof Array) {
+			mesh.instance.material.map(
+				function(material) {
+					if (material.emissive) {
+						material.emissive.sub(this.toRed);
+					}
+				}.bind(this)
+			);
+		} else {
+			if (mesh.instance.material.emissive) {
+				mesh.instance.material.emissive.sub(this.toRed);
+			}
+		}
+	}.bind(this)
+);
+
+if (this.mouseIsDown)
+{	
+	this.kanisterTime += data.delta;
+
+	this.renderer.clearColor.r += 0.01;
+	if (this.renderer.clearColor.r > 0.45) {
+		this.renderer.clearColor.r = 0.45;
+	}
+	this.renderer.updateInstance('clearColor');
+
+	this.throwerLight.intensity += 0.05;
+	if (this.throwerLight.intensity > 2) {
+		this.throwerLight.intensity = 2;
+	}
+	this.throwerLight.updateInstance('intensity');
+
+	var intersects = this.raycaster.getIntersectedObjects(this.scene.meshes);
+	intersects.map(
+		function(intersect) {
+
+			var mesh = intersect.mesh;
+
+			if (mesh.name.indexOf('Kanister') !== -1) {
+				this.explode(mesh);
+				return;
+			}
+
+			if (this.fuelFinished) {
+				GameLib.Event.Emit(GameLib.Event.MOUSE_UP);
+				return;
+			}
+
+			if (
+				mesh.name.indexOf('Tree - Medium') !== -1 || //tree medium
+				mesh.name.indexOf('Hamburger') !== -1 || //burger
+				mesh.name.indexOf('Star Cookie') !== -1 || //cookie
+				mesh.name.indexOf('Parcel') !== -1 || //parcel
+				mesh.name.indexOf('Bull') !== -1|| //bull
+				mesh.name.indexOf('Tree - Large') !== -1 || //tree large
+				mesh.name.indexOf('Santa') !== -1 || //santa
+				mesh.name.indexOf('Tree - Small') !== -1 //tree small
+			) {
+
+				if (mesh.materials[0].name.indexOf('Trees') === -1) {
+
+					mesh.instance.material.color.sub(this.toBlack);
+
+					mesh.materials[0].color.r = mesh.instance.material.color.r;
+					mesh.materials[0].color.g = mesh.instance.material.color.g;
+					mesh.materials[0].color.b = mesh.instance.material.color.b;
+
+					mesh.materials[0].color.instance = mesh.instance.material.color;
+
+					if (mesh.instance.material.color.r <= 0) {
+
+						this.burn(mesh);
+
+						if (mesh.instance.material.emissive) {
+							mesh.instance.material.emissive.add(this.toRed);
+							mesh.instance.material.emissive.add(this.toRed);
+
+							if (mesh.instance.material.emissive.r >= 0.8) {
+								this.explode(mesh);
+							}
+						}
+					}
+				} else {
+					/**
+                         * This happens to trees
+                         */
+					if (GameLib.Utils.UndefinedOrNull(mesh.life)) {
+						mesh.life = 1.2;
+					}
+
+					mesh.life -= 0.2;
+
+					if (mesh.life  <= 0) {
+						this.burnTree(mesh);
+
+						if (mesh.instance.material.emissive) {
+							mesh.instance.material.emissive.add(this.toRed);
+							mesh.instance.material.emissive.add(this.toRed);
+						}
+					}
+
+				}
+			}
+		}.bind(this)
+	);
+
+}
+else
+{
+	this.kanisterTime += (data.delta * this.kanisterLeakTime);
+
+	this.renderer.clearColor.r -= 0.01;
+	if (this.renderer.clearColor.r < this.minimumRendererRed) {
+		this.renderer.clearColor.r = this.minimumRendererRed;
+	}
+	this.renderer.updateInstance('clearColor');
+
+	this.throwerLight.intensity -= 0.05;
+	if (this.throwerLight.intensity < 0) {
+		this.throwerLight.intensity = 0;
+	}
+	this.throwerLight.updateInstance('intensity');
+}
+
+var used = this.kanisterTime / this.kanisterLife;
+
+GameLib.Event.Emit(
+	GameLib.Event.GAME_DATA,
+	{
+		event : 'fuelUsed',
+		used  : used,
+		percentage : Math.round(used * 100) + '%',
+		kanisters : this.kanisters
+	}
+);
+
+if (this.kanisterTime > this.kanisterLife) {
+
+	this.kanisterTime = 0;
+	this.kanisters -= 1;
+
+	GameLib.Event.Emit(
+		GameLib.Event.GAME_DATA,
+		{
+			event : 'kanisterCountUpdate',
+			kanisters : this.kanisters
+		}
+	);
+
+	if (this.kanisters < 0) {
+		GameLib.Event.Emit(
+			GameLib.Event.GAME_OVER,
+			{
+				game : this
+			}
+		);
+	}
+}
+
+if (this.enemySpawnTime > this.enemySpawnInterval && this.running) {
+	this.enemySpawnTime = 0;
+	this.spawnEnemy();
+}
+//
+
+// if (this.kanister.explodeParticleEngine) {
+//     if (GameLib.Utils.UndefinedOrNull(this.kanister.waiting)) {
+//         this.kanister.waiting = true;
+//     } else {
+//         this.kanister.explodeParticleEngine.remove();
+//         this.kanister.explodeParticleEngine = null;
+//         delete this.kanister.waiting;
+//     }
+// }
+//
+// if (this.kanisterTime > (this.kanisterLife / 2)) {
+//
+//     this.kanister.visible = true;
+//     this.kanister.updateInstance('visible');
+//
+//     GameLib.Event.Emit(
+//         GameLib.Event.GAME_DATA,
+//         {
+//             event : 'kanisterAppeared'
+//         }
+//     );
+// }
+
+this.enemies = this.enemies.reduce(
+	function(result, enemy) {
+
+		if (enemy.exploding === true) {
+			/**
+                 * We need to wait one render cycle for the smoke explode particle engine
+                 * and then kill the enemy
+                 */
+			if (GameLib.Utils.UndefinedOrNull(enemy.waiting)) {
+				enemy.waiting = true;
+				result.push(enemy);
+			} else {
+				this.kill(enemy);
+			}
+
+			return result;
+		}
+
+		enemy.mesh.position.add(enemy.velocity);
+		enemy.mesh.updateInstancePosition();
+
+		enemy.mesh.quaternion.angle += enemy.rotation.angle;
+		enemy.mesh.updateInstanceRotation();
+
+		enemy.lifeTime += data.delta;
+
+		if (enemy.lifeTime > enemy.life) {
+
+			GameLib.Event.Emit(
+				GameLib.Event.GAME_DATA,
+				{
+					event : 'enemyLifetimeReached',
+					enemy : enemy
+				}
+			);
+
+			/**
+                 * We only remove the things we cloned
+                 */
+			this.kill(enemy);
+
+			return result;
+
+		} else {
+
+			if (enemy.burning) {
+
+				enemy.burnTime += data.delta;
+
+				if (enemy.burnTime > enemy.burnLife) {
+					enemy.mesh.smokeParticleEngine.remove();
+					enemy.mesh.fireParticleEngine.remove();
+					enemy.lifeTime = enemy.life + 1;
+				} else {
+					enemy.mesh.smokeParticleEngine.position = enemy.mesh.position.clone();
+					enemy.mesh.smokeParticleEngine.updateInstance('position');
+					enemy.mesh.fireParticleEngine.position = enemy.mesh.position.clone();
+					enemy.mesh.fireParticleEngine.updateInstance('position');
+				}
+
+				enemy.mesh.materials[0].opacity -= 0.005;
+				enemy.mesh.materials[0].updateInstance('opacity');
+
+			}
+
+			result.push(enemy);
+			return result;
+		}
+
+	}.bind(this),
+	[]
+);
+
+return null;
+//# sourceURL=beforeRender.js
\ No newline at end of file