if (!this.entityLoaded) {
    return;
}

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

    this.initialized = true;

    R3.Event.Emit(R3.Event.STOP_ALL_AUDIO);

    R3.Event.Emit(
        R3.Event.PLAY_AUDIO,
        {
            name: 'Audio - Xmas'
        }
    );

    if (this.blastSubscription) {
        this.blastSubscription.remove();
    }

    this.blastSubscription = R3.Event.Subscribe(
        R3.Event.AUDIO_ENDED,
        function (data) {
            if (data.audio.name.indexOf('Blast') !== -1) {
                var play = R3.Utils.GetRandomIntInclusive(1, 5);
                if (play === 1) {
                    R3.Event.Emit(
                        R3.Event.PLAY_AUDIO,
                        {
                            name: 'Audio - Ho ho ho'
                        }
                    );
                }
            }
        }.bind(this)
    );

    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.meshes = this.entityLoaded.meshes;
    this.raycaster = this.entityLoaded.raycaster;
    this.kanister = this.entityLoaded.kanister;
    this.lightDirectional = this.entityLoaded.lightDirectional;
    this.lightAmbient = this.entityLoaded.lightAmbient;	
    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(
        data.delta * 3,
        data.delta * 3,
        data.delta * 3
    );

    this.toRed = new THREE.Color(
        data.delta * 1.2,
        0,
        0
    );

    this.treesBurning = 0;
    this.treesBurningToStart = R3.Utils.GetRandomIntInclusive(1, 3);

    this.running = false;

    this.totalTime = 0;

    this.kanisters = 2;
    this.kanisterTime = 0;
    this.kanisterLife = 16.344;
    this.kanisterLeakTime = 0.1;
    this.kanisterSpawnScore = 500;

    this.enemiesBurned = 0;
    this.enemiesExploded = 0;

    this.setNextKanisterSpawnScore = function () {

        if (this.score > 500) {
            this.kanisterSpawnScore = 1000;
        }

        if (this.score > 1000) {
            this.kanisterSpawnScore = 1500;
        }

        if (this.score > 1500) {
            this.kanisterSpawnScore = 2500;
        }

        if (this.score > 2500) {
            this.kanisterSpawnScore = 5000;
        }

        if (this.score > 5000) {
            var dice = R3.Utils.GetRandomIntInclusive(1, 10);

            /**
             * Max average spawn = 5.41
             * @type {number}
             */
            dice += 6.41;

            /**
             * 53 is one more than average score, in total - should be against your odds to win.
             */
            this.kanisterSpawnScore = this.score + (dice * 53 * this.level);
        }

        console.log('next kanister spawn score: ' + this.kanisterSpawnScore);

        R3.Event.Emit(
            R3.Event.GAME_DATA,
            {
                event: 'nextKanisterSpawnScoreUpdate',
                kanisterSpawnScore: this.kanisterSpawnScore
            }
        );
    };

    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.burnLife = 1;
                mesh.burningTreeParticleEngine.enabled = false;
            }
        }.bind(this)
    );

    this.enemies = [];

    this.scores = [];

    this.enemiesSpawned = 0;

    this.lightDirectional.intensity = 0;
    this.lightDirectional.updateInstance('intensity');

	this.lightAmbient.intensity = 0;
    this.lightAmbient.updateInstance('intensity');
	
    this.setLevelProperties = function () {

        this.prevLevel = this.level;

        this.level = Math.floor(this.enemiesExploded / 10) + 1;

        //this.enemySpawnInterval = Math.pow(this.level, 2) - 3 * this.level + 2;

        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);

        R3.Event.Emit(
            R3.Event.GAME_DATA,
            {
                level: this.level,
                enemySpawnInterval: this.enemySpawnInterval,
                event: 'levelIncrease'
            }
        );
    };


    this.getNextMesh = function (meshType) {

        var mesh = null;

        for (var i = 0; i < this.meshes[meshType].length; i++) {
            if (this.meshes[meshType][i].inUse === false) {
                this.meshes[meshType][i].inUse = true;
                mesh = this.meshes[meshType][i].mesh;
                return mesh;
            }
        }

        return mesh;
    }

    this.spawnEnemy = function (kanister) {

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

        var meshTypeIndex;

        if (kanister) {
            meshTypeIndex = 6;
        } else {
            meshTypeIndex = R3.Utils.GetRandomIntInclusive(1, 5);
        }

        var meshType = null;
        var speed = 1;
        var score = 0;
        var burnLife = 1;
        var explodeLife = 1;

        if (meshTypeIndex === 1) {
            meshType = 'bull';
            score = 10;
            speed = 0.2;
        } else if (meshTypeIndex === 2) {
            meshType = 'star';
            score = 20;
            speed = 0.3;
        } else if (meshTypeIndex === 3) {
            meshType = 'burger';
            score = 50;
            speed = 0.4;
        } else if (meshTypeIndex === 4) {
            meshType = 'parcel';
            score = 75;
            speed = 0.5;
        } else if (meshTypeIndex === 5) {
            meshType = 'santa';
            score = 100;
            speed = 0.6;
        } else if (meshTypeIndex === 6) {
            meshType = 'kanister';
            score = 50;
            speed = 0.7;
            burnLife = 0;
            explodeLife = 0;
        } else {
            console.warn('unknown mesh type index: ' + meshTypeIndex);
            return;
        }

        var mesh = this.getNextMesh(meshType);

        if (!mesh) {
            console.log('buffer empty.. waiting a bit');
            return;
        }

        mesh.burnLife = burnLife;
        mesh.explodeLife = explodeLife;
        mesh.instance.material[0].color.setRGB(1, 1, 1);
        mesh.instance.material[0].opacity = 1;
        mesh.visible = true;
        mesh.updateInstance('visible');

        if (kanister) {

            this.setNextKanisterSpawnScore();

            R3.Event.Emit(
                R3.Event.GAME_DATA,
                {
                    event: 'kanisterCountUpdate',
                    kanisters: this.kanisters
                }
            );

        } else {
            this.enemiesSpawned++;
            this.setLevelProperties();
        }

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

        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
        };

        /**
         * Link the enemy to the mesh
         */
        mesh.enemy = enemy;

        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.updateInstance('position');

        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.updateInstance('quaternion');

        enemy.velocity = velocity;
        enemy.rotation = rotation;

        enemy.lifeTime = 0;
        enemy.life = life;

        enemy.exploding = false;
        enemy.burning = false;
        enemy.burnLife = 1.5;
        enemy.burnTime = 0;
        enemy.explodingLife = 2;
        enemy.meshType = meshType;
        enemy.score = score * this.level;
        enemy.isKanister = false;

        if (kanister) {
            enemy.isKanister = true;
        } else {
            R3.Event.Emit(
                R3.Event.GAME_DATA,
                {
                    enemiesSpawned: this.enemiesSpawned,
                    enemy: enemy,
                    event: 'enemySpawned'
                }
            );
        }

        this.enemies.push(enemy);
    };

    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.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';
        }

        mesh.explodeParticleEngine.position.x = mesh.position.x;
        mesh.explodeParticleEngine.position.y = mesh.position.y;
        mesh.explodeParticleEngine.position.z = mesh.position.z;
        mesh.explodeParticleEngine.updateInstance('position');
        mesh.explodeParticleEngine.enabled = true;

        R3.Event.Emit(
            R3.Event.PLAY_AUDIO,
            {
                name: name
            }
        );
    };

    this.explode = function (mesh) {

        mesh.enemy.exploding = true;

        if (mesh.enemy.isKanister) {

            this.kanisters += 1;

            if (this.kanisters > 9) {
                this.kanisters = 9;
            }

            console.log('exploding kanister, total count: ' + this.kanisters);

        } else {

            console.log('exploding enemy');

            this.enemiesExploded += 1;

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

            this.score += mesh.enemy.score;

            this.drawScore(mesh.enemy);

            console.log('score : ' + this.score);

            R3.Event.Emit(
                R3.Event.GAME_DATA,
                {
                    event: 'scoreUpdate',
                    score: this.score
                }
            );
        }

        this.explodeMesh(mesh);
    };

    this.burn = function (mesh) {

        console.log('burning enemy ' + mesh.name);

        this.enemiesBurned += 1;

        mesh.enemy.burning = true;

        R3.Event.Emit(
            R3.Event.GAME_DATA,
            {
                enemy: mesh.enemy,
                event: 'enemyBurned'
            }
        );

        mesh.smokeParticleEngine.position.x = mesh.position.x;
        mesh.smokeParticleEngine.position.y = mesh.position.y;
        mesh.smokeParticleEngine.position.z = mesh.position.z;
        mesh.smokeParticleEngine.updateInstance('position');
        mesh.smokeParticleEngine.enabled = true;

        mesh.fireParticleEngine.position.x = mesh.position.x;
        mesh.fireParticleEngine.position.y = mesh.position.y;
        mesh.fireParticleEngine.position.z = mesh.position.z;
        mesh.fireParticleEngine.updateInstance('position');
        mesh.fireParticleEngine.enabled = true;

        R3.Event.Emit(
            R3.Event.PLAY_AUDIO,
            {
                name: 'Audio - Burning'
            }
        );
    };

    this.kill = function (enemy) {

        var found = false;

        for (var i = 0; i < 5; i++) {
            if (this.meshes[enemy.meshType][i].mesh === enemy.mesh) {
                found = true;
                this.meshes[enemy.meshType][i].inUse = false;
                this.meshes[enemy.meshType][i].mesh.visible = false;
                this.meshes[enemy.meshType][i].mesh.updateInstance('visible');
            }
        }

        if (!found) {
            console.warn('could not find mesh to kill');
        }

        if (enemy.mesh.smokeParticleEngine) {
            enemy.mesh.smokeParticleEngine.enabled = false;
        }

        if (enemy.mesh.fireParticleEngine) {
            enemy.mesh.fireParticleEngine.enabled = false;
        }

        if (enemy.mesh.explodeParticleEngine) {
            enemy.mesh.explodeParticleEngine.enabled = false;
        }

    }.bind(this);

    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;
                R3.Event.Emit(
                    R3.Event.GAME_DATA,
                    {
                        event: 'gameRunning',
                        message: 'we have enough trees burning now to start - the enemy will spawn now'
                    }
                );
            }

            R3.Event.Emit(
                R3.Event.GAME_DATA,
                {
                    event: 'treeBurned',
                    treesBurning: this.treesBurning,
                    treesBurningToStart: this.treesBurningToStart
                }
            );

            this.minimumRendererRed += 0.01;

            this.lightDirectional.intensity += 0.1;
            if (this.lightDirectional.intensity >= 1.2) {
                this.lightDirectional.intensity = 1.2;
            }
            this.lightDirectional.updateInstance('intensity');
            
			this.lightAmbient.intensity += 0.1;
            if (this.lightAmbient.intensity >= 1) {
                this.lightAmbient.intensity = 1;
            }
            this.lightAmbient.updateInstance('intensity');
            
            mesh.burningTreeParticleEngine.enabled = true;

            R3.Event.Emit(
                R3.Event.PLAY_AUDIO,
                {
                    name: 'Audio - Burning'
                }
            );
        }
    };

    R3.Event.Emit(
        R3.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.emissive) {
            mesh.instance.material.emissive.sub(this.toRed);
        }
    }.bind(this)
);

if (this.mouseIsDown) {

    this.kanisterTime += data.delta * 1.125;

    this.throwerLight.intensity += 0.05;
    if (this.throwerLight.intensity > 2.5) {
        this.throwerLight.intensity = 2.5;
    }
    this.throwerLight.updateInstance('intensity');

    var intersects = this.raycaster.getIntersectedObjects(this.scene.clones);
    intersects.map(
        function (intersect) {

            var mesh = intersect.mesh;

            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
                mesh.name.indexOf('Kanister') !== -1 //kanister
            ) {

                if (mesh.materials[0].name.indexOf('Trees') === -1) {

                    if (!mesh.enemy.burning) {

                        mesh.burnLife -= data.delta * 1.5;

                        if (mesh.burnLife < 0) {
                            mesh.burnLife = 0;
                            this.burn(mesh);
                        }

                        mesh.instance.material[0].color.setRGB(
                            mesh.burnLife,
                            mesh.burnLife,
                            mesh.burnLife
                        );

                    } else {

                        if (!mesh.enemy.exploding) {
                            mesh.explodeLife -= data.delta * 2.5;
                            if (mesh.explodeLife < 0) {
                                mesh.explodeLife = 0;
                                this.explode(mesh);
                            }

                            if (mesh.instance.material.emissive) {
                                mesh.instance.material.emissive.setRGB(
                                    1 - mesh.explodeLife,
                                    0,
                                    0
                                );
                            }
                        }
                    }

                } else {

                    /**
                     * This happens to trees
                     */
                    if (R3.Utils.UndefinedOrNull(mesh.burnLife)) {
                        mesh.burnLife = 1;
                        mesh.burning = false;
                    }

                    if (!mesh.burning) {

                        mesh.burnLife -= data.delta * 2;

                        if (mesh.burnLife <= 0) {
                            mesh.burnLife = 0;
                            this.burnTree(mesh);
                        }

                        if (mesh.instance.material.emissive) {
                            mesh.instance.material.emissive.setRGB(
                                1 - mesh.burnLife,
                                0,
                                0
                            );
                        }
                    }
                }
            }
        }.bind(this)
    );

}
else {
    this.kanisterTime += (data.delta * this.kanisterLeakTime);

    this.throwerLight.intensity -= data.delta * 3;
    if (this.throwerLight.intensity < 0) {
        this.throwerLight.intensity = 0;
    }
    this.throwerLight.updateInstance('intensity');
}

var used = this.kanisterTime / this.kanisterLife;

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

    console.log('kanister count: ' + this.kanisters);

    R3.Event.Emit(
        R3.Event.GAME_DATA,
        {
            event: 'kanisterCountUpdate',
            kanisters: this.kanisters
        }
    );

    if (this.kanisters < 0) {
        console.log('no more kanisters');
        R3.Event.Emit(
            R3.Event.GAME_OVER,
            {
                game: this
            }
        );
    }
}

if (this.enemySpawnTime > this.enemySpawnInterval && this.running) {
    this.enemySpawnTime = 0;
    this.spawnEnemy(false);
}

this.enemies = this.enemies.reduce(
    function (result, enemy) {

        /**
         * Update enemy position and rotation
         */
        enemy.mesh.position.x += enemy.velocity.x * data.delta * 60;
        enemy.mesh.position.y += enemy.velocity.y * data.delta * 60;
        enemy.mesh.position.z += enemy.velocity.z * data.delta * 60;
        enemy.mesh.updateInstance('position');

        enemy.mesh.quaternion.angle += enemy.rotation.angle * data.delta * 60;
        enemy.mesh.updateInstance('quaternion');

        /**
         * Update its lifetime
         */
        enemy.lifeTime += data.delta;
        if (enemy.lifeTime > enemy.life) {

            R3.Event.Emit(
                R3.Event.GAME_DATA,
                {
                    event: 'enemyLifetimeReached',
                    enemy: enemy
                }
            );

            /**
             * We only remove the things we cloned
             */
            this.kill(enemy);
            return result;
        }

        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;
        }

        if (enemy.burning) {

            if (!enemy.exploding) {
                enemy.burnTime += data.delta;
                if (enemy.burnTime > enemy.burnLife) {
                    this.explode(enemy.mesh);
                }
            }

            if (enemy.mesh.smokeParticleEngine) {
                enemy.mesh.smokeParticleEngine.position.x = enemy.mesh.position.x;
                enemy.mesh.smokeParticleEngine.position.y = enemy.mesh.position.y;
                enemy.mesh.smokeParticleEngine.position.z = enemy.mesh.position.z;
                enemy.mesh.smokeParticleEngine.updateInstance('position');
            }

            if (enemy.mesh.fireParticleEngine) {
                enemy.mesh.fireParticleEngine.position.x = enemy.mesh.position.x;
                enemy.mesh.fireParticleEngine.position.y = enemy.mesh.position.y;
                enemy.mesh.fireParticleEngine.position.z = enemy.mesh.position.z;
                enemy.mesh.fireParticleEngine.updateInstance('position');
            }

            result.push(enemy);
            return result;
        }

        result.push(enemy);
        return result;

    }.bind(this),
    []
);

if (this.score > this.kanisterSpawnScore) {
    this.spawnEnemy(true);
}

return null;//# sourceURL=beforeRender.js