if (!this.entityLoaded) {
        return;
    }

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

        this.initialized = true;

        this.fog = this.entityLoaded.fog;
        this.bull = this.entityLoaded.bull;
        this.star = this.entityLoaded.star;
        this.burger = this.entityLoaded.burger;
        this.parcel = this.entityLoaded.parcel;
        this.santa = this.entityLoaded.santa;
        this.renderer = this.entityLoaded.renderer;
        this.raycaster = this.entityLoaded.raycaster;
        this.kanister = this.entityLoaded.kanister;
        this.scene = this.entityLoaded.scene;
        this.leftLight = this.entityLoaded.leftLight;
        this.rightLight = this.entityLoaded.rightLight;
        this.throwerLight = this.entityLoaded.throwerLight;
        this.smokeParticleEngine = this.entityLoaded.smokeParticleEngine;
        this.fireParticleEngine = this.entityLoaded.fireParticleEngine;
        this.burningTreeParticleEngine = this.entityLoaded.burningTreeParticleEngine;
        this.explodeParticleEngine = this.entityLoaded.explodeParticleEngine;

        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.treesBurning = 0;

        /**
         * This component is initializing - set the total time to 0
         */
        this.totalTime = 0;
        this.spawnTime = 0;
        this.kanisterTime = 0;
        this.kanisterLife = 16.344;
        this.fuelFinished = false;

        this.level = 1;
        this.spawnInterval = 5;
        this.score = 0;
        this.lives = 10;

		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.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');
		
		R3.Event.Emit(
			R3.Event.GAME_DATA,
			{
				event : 'gameStarted',
				game : this
			}
		);
		
        R3.Event.Emit(
            R3.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.prevLevel !== this.level) {
				
				var amount = 1 / this.level;
				
				if (amount < 0.1) {
					amount = 0.1;
				}
				
                this.spawnInterval -= amount;
				
				console.log('level : ' + this.level +', spawn interval : ' + this.spawnInterval);
				
				R3.Event.Emit(
					R3.Event.GAME_DATA,
					{
						level : this.level,
						spawnInterval : this.spawnInterval,
						event : 'levelIncrease'
					}
				);
            }			
        }

        this.spawnEnemy = function() {

            this.enemiesSpawned++;
			
            this.setLevelProperties();

            var enemyType	= R3.Utils.GetRandomIntInclusive(1, 5);
            var meshType	= R3.Utils.GetRandomIntInclusive(1, 5);

            var y = R3.Utils.GetRandomIntInclusive(2, 10);

            var speed = 1;

            var material = null;

            var mesh = null;
            if (meshType === 1) {
                mesh = this.bull.clone();
                material = this.bull.materials[0].clone();
                speed = 0.2;
            } else if (meshType === 2) {
                mesh = this.star.clone();
                material = this.star.materials[0].clone();
                speed = 0.3;
            } else if (meshType === 3) {
                mesh = this.burger.clone();
                material = this.burger.materials[0].clone();
                speed = 0.4;
            } else if (meshType === 4) {
                mesh = this.parcel.clone();
                material = this.parcel.materials[0].clone();
                speed = 0.5;
            } else if (meshType === 5) {
                mesh = this.santa.clone();
                material = this.santa.materials[0].clone();
                speed = 0.5;
            } else {
                console.log('unknown mesh type : ' + meshType);
            }

            mesh.materials = [material];

            mesh.updateInstance();

            mesh.instance.visible = true;

            var velocity = null;

            var axis = new R3.API.Vector3(
                R3.Utils.GetRandomIntInclusive(1,10) * 0.1,
                R3.Utils.GetRandomIntInclusive(1,10) * 0.1,
                R3.Utils.GetRandomIntInclusive(1,10) * 0.1
            );

            axis = axis.normalize();

            var angle = R3.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 = 2.5 / speed;

            if (enemyType === 1) {
                position.x = -distance;
                life += 1.5 / speed;
                velocity = {x:speed,y:0,z:0};
            }

            if (enemyType === 2) {
                position.x = distance;
                life += 1.5 / 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;
			
			R3.Event.Emit(
				R3.Event.GAME_DATA,
				{
					enemiesSpawned : this.enemiesSpawned,
					enemy : enemy,
					event : 'enemySpawned'
				}
			);
			
            this.enemies.push(enemy);
        }

        this.explodeMesh = function(mesh) {

            mesh.visible = false;

            mesh.updateInstance('visible');

            var sound = R3.Utils.GetRandomIntInclusive(1,3);

            var name = 'Audio - Blast 1';

            if (sound === 2) {
                name = 'Audio - Blast 2';
            }

            if (sound === 3) {
                name = 'Audio - Blast 3';
            }

            this.blastSubscription = R3.Event.Subscribe(
                R3.Event.AUDIO_ENDED,
                function(data) {

                    if (data.audio.name === name) {

                        if (this.blastSubscription) {

                            this.blastSubscription.remove();

                            this.blastSubscription = null;

                            var play = R3.Utils.GetRandomIntInclusive(1,3);

                            if (play === 1) {

                                R3.Event.Emit(
                                    R3.Event.PLAY_AUDIO,
                                    {
                                        name : 'Audio - Ho ho ho'
                                    }
                                );
                            }
                        }
                    }
                }.bind(this)
            );

            R3.Event.Emit(
                R3.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.explode = function(mesh) {

            this.enemies.map(
                function(enemy) {
                    if (enemy.mesh === mesh && !enemy.exploding) {
                        
						console.log('exploding enemy');

                        this.score += this.level * 100;

                        enemy.exploding = true;

						R3.Event.Emit(
							R3.Event.GAME_DATA,
							{
								score : this.score,
								enemy : enemy,
								event : 'enemyExploded'
							}
						);
						
                        this.explodeMesh(mesh);
                    }
                }.bind(this)
            );


        }

        this.explodeKanister = function() {
            this.kanisterTime = 0;
            this.fuelFinished = false;
            this.explodeMesh(this.kanister);
        }

        this.burn = function(mesh) {

            this.enemies.map(
                function(enemy) {
                    if (enemy.mesh === mesh && !enemy.burning) {
                        this.score += this.level * 10;
                        console.log('burning enemy ' + mesh.name);
                        enemy.burning = true;
						
						R3.Event.Emit(
							R3.Event.GAME_DATA,
							{
								score : this.score,
								enemy : enemy,
								event : 'enemyBurned'
							}
						);
						
                        var smokeParticleEngine = this.smokeParticleEngine.clone();
                        smokeParticleEngine.position = mesh.position.clone();
                        smokeParticleEngine.updateInstance('position');
                        smokeParticleEngine.enabled = true;
                        mesh.smokeParticleEngine = smokeParticleEngine;

                        R3.Event.Emit(
                            R3.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) {
            /**
             * We only remove the things we cloned
             */
            R3.Event.Emit(
                R3.Event.REMOVE_COMPONENT,
                {
                    component : enemy.mesh.materials[0]
                }
            );

            R3.Event.Emit(
                R3.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++;

				R3.Event.Emit(
					R3.Event.GAME_DATA,
					{
						event : 'treeBurned',
						treesBurning : this.treesBurning
					}
				);
				
                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');
                
				}

                R3.Event.Emit(
                    R3.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;
            }
        }

        this.spawnEnemy();
    }

    this.totalTime += data.delta;
    this.spawnTime += data.delta;

    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;

		R3.Event.Emit(
			R3.Event.GAME_DATA,
			{
				used  : this.kanisterTime / this.kanisterLife,
				event : 'fuelUsed',
				percentage : Math.round((this.kanisterTime / this.kanisterLife) * 100) + '%'
			}
		);
			
		
        if (this.kanisterTime > this.kanisterLife) {
            this.fuelFinished = true;
			
			R3.Event.Emit(
				R3.Event.GAME_DATA,
				{
					event : 'fuelFinished'
				}
			);
			
        }

        if (!this.fuelFinished) {

            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.explodeKanister();
                    return;
                }

                if (this.fuelFinished) {
                    R3.Event.Emit(R3.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 (R3.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.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');
    }

    if (this.spawnTime > this.spawnInterval) {
        this.spawnTime = 0;
        this.spawnEnemy();
    }

    if (this.kanister.explodeParticleEngine) {

        if (R3.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');
		
		R3.Event.Emit(
			R3.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 (R3.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) {

				R3.Event.Emit(
					R3.Event.GAME_DATA,
					{
						event : 'enemyLifetimeReached',
						enemy : enemy
					}
				);
				
                if (!enemy.burning && !enemy.exploding) {
                    
					this.lives--;
					
                    console.log('lives left: ' + this.lives);

					R3.Event.Emit(
						R3.Event.GAME_DATA,
						{
							livesLeft : this.lives,
							event : 'lifeLost'
						}
					);
					
                    if (this.lives < 0) {
						
						R3.Event.Emit(
							R3.Event.GAME_DATA,
							{
								event : 'gameOver',
								gameData : this
							}
						);
						
                        R3.Event.Emit(R3.Event.GAME_OVER);
                    }
                }

                /**
                 * 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