r3-custom-code/21g30t1e75.js

function snakeEntityLoaded(data) {

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

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

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

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

    GameLib.CustomCode.SPEED_INITIAL = 1;

    GameLib.CustomCode.ORIENTATION_UP       = 0;
    GameLib.CustomCode.ORIENTATION_LEFT     = 1;
    GameLib.CustomCode.ORIENTATION_DOWN     = 2;
    GameLib.CustomCode.ORIENTATION_RIGHT    = 3;

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

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

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

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

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

    /**
     * Game objects
     */
    this.snake 	= [];
    this.grid 	= [];
    this.speed	= GameLib.CustomCode.SPEED_INITIAL;
    this.advanceTime = 0;

    /**
     * Orientation is 0, 1, 2 or 3, (up, left, down, right) -
     * This is also the amount we need to multiply with PI to get the mesh rotation
     * @type {{direction: {x: number, y: number}, orientation: number}}
     */
    this.state = {
        orientation : 0
    };

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

        return new GameLib.D3.Material.Phong(
            this.runtime.graphics,
            {
                diffuseMap : diffuseMap
            }
        );
    }.bind(this);

    GameLib.CustomCode.prototype.createGameMesh = function(image) {

        var mesh = new GameLib.D3.Mesh(
            this.runtime.graphics,
            {
                geometry  : this.geometryBody,
                materials : [this.createMaterial(image)]
            }
        )

        this.scene.addClone(mesh);

        return mesh;

    }.bind(this)

    /**
     * Create our objects
     */
    this.meshBreadHead 					= this.createGameMesh(this.imageBreadHead);
    this.meshBreadHead.useQuaternion 	= false;

    this.meshBreadTail 					= this.createGameMesh(this.imageBreadTail);
    this.meshBreadTail.useQuaternion 	= false;
    
    this.meshBreadPatty		            = this.createGameMesh(this.imageBreadPatty);
    this.meshBreadPatty.useQuaternion 	= false;

    this.meshBreadCorner	            = this.createGameMesh(this.imageBreadCorner);
    this.meshBreadCorner.useQuaternion 	= false;

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

    /**
     * GameLib.CustomCode.SnakeBody
     * @param mesh
     * @param position
     * @param orientation
     * @constructor
     */
    GameLib.CustomCode.SnakeBody = function(
        mesh,
        position,
        orientation
    ) {

        if (GameLib.Utils.UndefinedOrNull(mesh)) {
            throw new Error('no mesh specified');
        }
        this.mesh = mesh.clone();

        if (GameLib.Utils.UndefinedOrNull(position)) {
            position = {
                x : Math.round(GameLib.CustomCode.GRID_WIDTH / 2),
                y : Math.round(GameLib.CustomCode.GRID_HEIGHT / 2)
            };
        }
        this.position = position;

        if (GameLib.Utils.UndefinedOrNull(orientation)) {
            orientation = GameLib.CustomCode.ORIENTATION_UP;
        }
        this.orientation = orientation;

        this.applyToMesh();
    };

    GameLib.CustomCode.SnakeBody.prototype.applyToMesh = function() {

        this.mesh.position.x = this.position.x + GameLib.CustomCode.GRID_OFFSET_X;
        this.mesh.position.y = this.position.y + GameLib.CustomCode.GRID_OFFSET_Y;

        this.mesh.rotation.z = this.orientation * Math.PI;

        /**
         * TODO: We don't update instance position - animation should do this
         */
        this.mesh.updateInstance('position');
        this.mesh.updateInstance('rotation');
    }

    GameLib.CustomCode.SnakeBody.prototype.advance = function(orientation) {

        if (orientation === GameLib.CustomCode.ORIENTATION_UP) {
            this.position.y += 1;
        }

        if (orientation === GameLib.CustomCode.ORIENTATION_DOWN) {
            this.position.y -= 1;
        }

        if (orientation === GameLib.CustomCode.ORIENTATION_LEFT) {
            this.position.x -= 1;
        }

        if (orientation === GameLib.CustomCode.ORIENTATION_RIGHT) {
            this.position.x += 1;
        }

        this.orientation = orientation;
    }

    GameLib.CustomCode.prototype.advanceSnake = function(delta) {

        this.advanceTime += delta;

        if (this.advanceTime > this.speed) {
            this.advanceTime = 0;
        } else {
            return;
        }

        var backup = {
            x : 0,
            y : 0,
            orientation : GameLib.CustomCode.ORIENTATION_UP
        };

        this.snake.map(
            function(body, index) {

                if (index === 0) {

                    backup.x = body.position.x;
                    backup.y = body.position.y;
                    backup.orientation = body.orientation;

                    body.advance(
                        this.state.orientation
                    );

                } else {

                    var temp = {
                        x : body.position.x,
                        y : body.position.y,
                        orientation : body.orientation
                    };

                    body.position.x = backup.x;
                    body.position.y = backup.y;
                    body.position.orientation = backup.orientation;

                    backup.x = temp.x;
                    backup.y = temp.y;
                    backup.orientation = temp.orientation;
                }

                body.applyToMesh();
            }.bind(this)
        );

    }.bind(this);

    /*
    GameLib.CustomCode.prototype.initializeGrid = function() {

        this.grid = [];

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

    }.bind(this);
    */

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

            /**
             * Remove all existing snake parts
             */
            this.snake.map(
                function(body) {
                    body.geometry 	= null;
                    body.materials 	= null;
                    body.remove();
                }
            )

            this.state = {
                orientation : GameLib.CustomCode.ORIENTATION_UP
            };

            this.snake = [
                new GameLib.CustomCode.SnakeBody(
                    this.meshBreadHead,
                    {
                        x : 4,
                        y : 4
                    },
                    0
                ),
                new GameLib.CustomCode.SnakeBody(
                    this.meshBreadPatty,
                    {
                        x : 4,
                        y : 3
                    },
                    0
                ),
                new GameLib.CustomCode.SnakeBody(
                    this.meshBreadPatty,
                    {
                        x : 4,
                        y : 2
                    },
                    0
                ),
                new GameLib.CustomCode.SnakeBody(
                    this.meshBreadTail,
                    {
                        x : 4,
                        y : 1
                    },
                    0
                )
            ];

            /**
             * Cleanup grid
             *
             this.grid.map(
             function(x) {
				x.map(
					function(y) {
						y.mesh.geometry		= null;
						y.mesh.materials	= null;
						y.mesh.remove();
					}
				);
			}
             );

             this.initializeGrid();
             */

            /**
             * Other Settings
             */
            this.speed = GameLib.CustomCode.SPEED_INITIAL;

            /**
             * Re-initialize our other custom code components
             */
            this.beforeRender.initialized	= false;
            this.beforeRender.entityLoaded 	= this;

            this.keyUp.initialized 	= false;
            this.keyUp.entityLoaded = this;

            console.log('starting game snake');
        }.bind(this)
    );

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

            this.keyUp.initialized 	= false;
            this.keyUp.entityLoaded = null;

            this.beforeRender.initialized = false;
            this.beforeRender.entityLoaded = null;

            console.log('starting game snake');
        }.bind(this)
    )

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

//@ sourceURL=entityLoaded.js
}