MV.js - Movement

// movimento -> principal
Game.Overworld.doMovement = function (object, callback) {

    new Movement().start(
        this,
        object,
        callback
    );
};

Game.Overworld.doFacing = function (object) {

    this.lol = true;

    new Movement().switchFacing(
        this,
        {
            info: this.player.data,
            sprite: this.player
        },
        object.direction
    );
    // setInterval(() => {
    //     this.key.time = 0;
    //     clearInterval(this.key.count);
    // }, 200);

    this.lol = false;
};

var Movement = function () {};

Movement.prototype.start = function (self, object, callback) {
    /*
    object ~
    type:
        0 = jogador
        1 = outro jogador (online)
        2 = npc
        3 = follower
    direction:
        0,1,2,3
    name:
        nome do objeto
    */

    var data = {};

    // verificando tipo

    switch(object.type) {

        // player
        case 0: {
            // se walk estiver em progresso: sai
            if (self.player._data.walkInProgress)
                return;

            // se jogador estiver parado: sai
            if (self.player._data.stop)
                return;

            var older = _.clone(self.player._data.position);

            // configurando sprite e flag do pé
            object.target = self.player;

            break;
        };

        // jogador online
        case 1: {
            // configurando
            object.target = self.online_player_data[object.uid];
            object.direction = object.dir;
            // limpando objeto
            delete object.dir;
            break;
        };

        // objetos, npcs e etc
        case 2:
        case 4:
        {
            object.target = self.object_data[object.name];
            break;
        };
        // followes
        case 3: {
            object.target = self.follower_data[object.name];
            //console.log("VSF", self.follower_data);
            break;
        };
        default:
            return;
        break;
    };

    // verificando qual o próximo tile e executando colisão
    var internal_callback,
        collisionType = this.execCollision(self, object, internal_callback);

    // verificando tipo novamente e vendo colisão
    switch (object.type) {

        // se for o jogador
        case 0: {

            // verificando tipo da colisão e execuntando o que deve ser feito

            switch (collisionType) {

                // não pode andar
                case 0: {
                    //** publicando no canal do mapa que andou para tal direção
                    if (self.subscribe.map.is)
                        if (self.player._data.position.facing !== object.direction)
                            self.subscribe.map.conn.publish({
                                dir: object.direction,
                                dataType: 2
                            });
                    // mudando facing na memória
                    self.player._data.position.facing = object.direction;
                    // executando animação idle para o lado
                    self.player.play(self.database.characters[object.target._data.sprite].name + "_idle_" + self.database.overworld.directions[object.direction]);

                    self.player.triggerCantMove({
                        facing: object.direction,
                        x: self.player._data.position.x,
                        y: self.player._data.position.x
                    });
                    // saindo pois não ira se mexer
                    return;
                };

                // solicitar mudança de mapa
                case 3: {
                    // pegando eventos, buscando map id e teleport id
                    var id = _.findWhere(self.cache.json.get("events_" + self.database.maps[self.Data.CurrentMap].name).map.teleport, {
                        x: self.player._data.position.x,
                        y: self.player._data.position.y
                    });

                    // adicionar callback e enviar request para o servidor
                    internal_callback = function () {
                        this[0].requestMapChange(this[1].mid, this[1].tid);
                    }.bind([self, id]);

                    break;
                };

                // solicitar batalha selvagem | criar overlay do matinho
                case 4: {
                    var pos = {
                        x: self.player._data.position.x,
                        y: self.player._data.position.y
                    };
                    // remove grass antigo
                    self.player.removeGrassOverlay();

                    // appenda particulas de grama
                    internal_callback = function () {
                        // adiciona overlay
                        self.player.addGrassOverlay(self.appendGrassOverlay(pos.x, pos.y));
                        // add particles
                        self.appendGrassParticles(pos.x, pos.y);
                    }.bind(self);

                    self.requestWildBattle();
                    break;
                };
            };

            //** pode andar

            // setando walk em progresso
            self.player._data.walkInProgress = true;
            // mudando facing
            self.player._data.position.facing = object.direction;
            // parando animação do idle para iniciar animação 'procedural'
            self.player.anims.stop();
            //** publicando no canal do mapa que andou para tal direção
            if (self.subscribe.map.is)
                self.subscribe.map.conn.publish({
                    dir: object.direction,
                    dataType: 1
                });
                //this.subscribe.map.conn.publish([object.direction]);
            if (self.player._data.follower.has)
                self.follow(older.facing, self.player._data.follower.id);

            break;
        };

        // se for um jogador online ou um npc, ou um follower, ou npc domador
        case 1:
        case 2:
        case 3:
        case 4:
        {

            // verificando tipo da colisão e execuntando o que deve ser feito
            switch (collisionType) {
                // não pode andar
                case 0: {
                    // mudando facing
                    object.target._data.position.facing = object.direction;
                    // executando animação idle para o lado
                    object.target.play(self.database.characters[object.target._data.sprite].name + "_idle_" + self.database.overworld.directions[object.direction]);
                    // saindo
                    return;

                    break;
                };

                // criar overlay do matinho
                case 4: {
                    var pos = {
                        x: object.target._data.position.x,
                        y: object.target._data.position.y
                    };
                    // remove grass antigo
                    object.target.removeGrassOverlay();
                    // appenda particulas de grama
                    internal_callback = function () {
                        // adiciona overlay
                        object.target.addGrassOverlay(self.appendGrassOverlay(pos.x, pos.y));
                        self.appendGrassParticles(pos.x, pos.y);
                    }.bind(self);
                    break;
                };
            };

            // mudando facing
            object.target._data.position.facing = object.direction;
            // parando animação do idle para iniciar animação 'procedural'
            object.target.anims.stop();

            break;
        };
    };

    //console.time("Andar");

    //console.time("walk");

    this.object = object;
    this.self = self;
    this.callback = callback;
    this.internal_callback = internal_callback;

    // executa animação de andar
    async.series([
        this.syncWalk[0].bind(this),
        this.syncWalk[1].bind(this),
        this.syncWalk[2].bind(this),
        this.syncWalk[3].bind(this),
        // no último método invoca o callback
        this.syncWalk[4].bind(this)
    ]);
};

// movimento síncrono (render)
Movement.prototype.syncWalk = [
    function (cb) {
        this.switchSpriteStep(this.self, this.object, this.object.target._data.stepFlag, "walk");
        this.changePosition(this.self, this.object, cb);
        //this.self.time.addEvent({delay: this.self.database.overworld.time.step, callback: cb});
        //setTimeout(this.self.database.overworld.time.step, cb);
    },
    function (cb) {
        this.changePosition(this.self, this.object, cb);
        //this.self.time.addEvent({delay: this.self.database.overworld.time.step, callback: cb});
    },
    function (cb) {
        this.switchSpriteStep(this.self, this.object, 0, "idle");
        this.changePosition(this.self, this.object, cb);
        //this.self.time.addEvent({delay: this.self.database.overworld.time.step, callback: cb});
    },
    function (cb) {
        // muda posição
        this.changePosition(this.self, this.object, cb);
    },
    function () {
        // se for o jogador
        if (this.object.type == 0) {
            // walk não está mais em progresso
            this.self.player._data.walkInProgress = false;
            // inicia animação idle
            this.self.player.play(this.self.database.characters[this.object.target._data.sprite].name + "_idle_" + this.self.database.overworld.directions[this.object.direction]);
            // mostra posição atual
            // console.log(
            //     "x", this.self.player._data.position.x,
            //     "\ny", this.self.player._data.position.y,
            //     "\nfacing", this.self.player._data.position.facing
            // );
        } else {
            // inicia animação idle
            //this.object.target.startAnim();
            this.object.target.play(this.self.database.characters[this.object.target._data.sprite].name + "_idle_" + this.self.database.overworld.directions[this.object.direction]);

            //console.log(this[1].currentObject, this[0].mapObjectPosition);
        };

        // atualizando profundidade dos objetos do grupo main
        //this.self.groups.main.sort("y", Phaser.Group.SORT_ASCENDING);
        this.self.depthSort();
        // chama callback interno
        if (typeof(this.callback) === "function")
            this.callback();

        // chama callback externo
        if (typeof(this.internal_callback) === "function")
            this.internal_callback();

        //console.timeEnd("walk");
    }
];

// executar colisão
Movement.prototype.execCollision = function (self, object, internal_callback) {
    object = object || {};

    if (
        !("type" in object) ||
        !("direction" in object)
    )
        return;

    // pega informações necessárias
    var isPlayer = object.type == 0,
        playerPosition = {
            x: self.player._data.position.x,
            y: self.player._data.position.y
        };
        //console.log("AKI CRL!", object);
        position = isPlayer ? playerPosition : {
            x: object.target._data.position.x,
            y: object.target._data.position.y
        };

    // incrementa nova posição
    switch(object.direction) {
        case 0: {
            position.y --;
            break;
        };

        case 1: {
            position.x ++;
            break;
        };

        case 2: {
            position.y ++;
            break;
        };

        case 3: {
            position.x --;
            break;
        };

    };

    // se não for o jogador
    if (!isPlayer) {

    let tileY = self.collisionLayer.data[position.y] ? self.collisionLayer.data[position.y] : 0,
        tileX = tileY[position.x] ? tileY[position.x] : 0,
        tilesXY = tileY ? self.database.overworld.tile.properties[tileX.index] : 0;

        // checa se colide com posição atual do jogador
        var collision = (position.x == playerPosition.x && position.y == playerPosition.y);

        // se não colidir, muda posição
        if (!collision && object.type !== 3) {

            // apaga posição atual no mapa
            delete self.mapObjectPosition[object.target._data.position.x + "|" + object.target._data.position.y];

            // cria nova posição
            self.mapObjectPosition[position.x + "|" + position.y] = object.name;

            // edita posição do objeto
            object.target._data.position.x = position.x;
            object.target._data.position.y = position.y;
            object.target._data.position.facing = object.direction;
        };

        console.log(tilesXY);

        if (tilesXY.wild)
            return 4;

        if (object.type == 1) // outro jogador
            return 1;

        // informa se colidiu ou não
        return collision ? 0 : 1;
    };

    //console.log(this.collisionLayer.data[position.y][position.x].index);

    // pega informação dos tiles para executar colisão
    var tileY = self.collisionLayer.data[position.y] ? self.collisionLayer.data[position.y] : 0,
        tileX = tileY[position.x] ? tileY[position.x] : 0,
        tilesXY = tileY ? self.database.overworld.tile.properties[tileX.index] : 0;

    // se for tile limite, bloqueio, ou existir algum objeto no lugar
    if (!tileY || !tileX || !tilesXY || tilesXY.block || self.mapObjectPosition[position.x + "|" + position.y])
        return 0;

    // muda posição do jogador
    self.player._data.position.x = position.x;
    self.player._data.position.y = position.y;

    // ** daqui pra baixo pode executar em assincronia

    // solicita mudar de mapa
    if (tilesXY.door)
        return 3;

    // solicita luta selvagem
    if (tilesXY.wild)
        return 4;

    self.checkPlayerPositionTamer(self.cache.json.get(self.getCurrentMapName("events")));

    // ok, pode andar
    return 1;
};

// mudar posição (no render)
Movement.prototype.changePosition = function (self, object, next) {

    switch(object.direction) {

        case 0: {
            self.tweens.add({
                targets: [object.target],
                ease: "Linear",
                duration: self.database.overworld.time.step,
                y: "-=" + (self.database.overworld.tile.size / 4),
                onComplete: () => next()
            });
            break;
        };

        case 1: {
            self.tweens.add({
                targets: [object.target],
                ease: "Linear",
                duration: self.database.overworld.time.step,
                x: "+=" + (self.database.overworld.tile.size / 4),
                onComplete: () => next()
            });
            break;
            //object.target.x += self.database.overworld.tile.size / 4;
        }
        break;

        case 2: {
            self.tweens.add({
                targets: [object.target],
                ease: "Linear",
                duration: self.database.overworld.time.step,
                y: "+=" + (self.database.overworld.tile.size / 4),
                onComplete: () => next()
            });
            //object.target.y += self.database.overworld.tile.size / 4;
            break;
        }
        break;

        case 3: {
            self.tweens.add({
                targets: [object.target],
                ease: "Linear",
                duration: self.database.overworld.time.step,
                x: "-=" + (self.database.overworld.tile.size / 4),
                onComplete: () => next()
            });
            //object.target.x -= self.database.overworld.tile.size / 4;
            break;
        };

    };
};

// mudar sprite de "passo". durante animação de andar
Movement.prototype.switchSpriteStep = function (self, object, flag, type) {

    // declarando sprite
    var sprite;

    // vendo se sprite é de step
    if (typeof(flag) == "number" && type == "walk") {

        flag = flag ? 0 : 1;

        switch (object.type) {
            case 0: {
                self.player._data.stepFlag = flag;
                break;
            };

            case 1:
            case 2:
            case 3:
            case 4:
            {
                object.target._data.stepFlag = flag;
                break;
            };

        };
    };

    // pegando sprite
    switch (object.type) {
        case 0: {
            sprite = self.database.characters[self.player._data.sprite].name;
            break;
        };
        case 1:
        case 2:
        case 3:
        case 4:
        {
            sprite = self.database.characters[object.target._data.sprite].name;
            break;
        };
    };

    // mudando frame

    object.target.setFrame(sprite + "_" + self.database.overworld.directions[object.direction] + "_" + type + flag);
};

// mudar facing
Movement.prototype.switchFacing = function (self, object, direction, callback, fps) {

    // frames por segundo default é 2

    fps = fps || 2;

    // se a direção for se virar ao jogador

    if (direction == "toplayer") {
        // pega qual lado jogar está posicionado
        switch(self.player._data.position.facing) {
            case 0: // cima
                direction = 2;
            break;
            case 2:  // baixo
                direction = 0;
            break;
            case 3: // esquerda
                direction = 1;
            break;
            case 1: // direita
                direction = 3;
            break;
        };
    };

    // mudando facing na memória
    object._data.position.facing = direction;
    // para animação (hack para caso esteja no mesmo lado)
    object.anims.stop();
    // executando animação idle para o lado escolhido
    object.play(self.database.characters[object._data.sprite].name + "_idle_" + self.database.overworld.directions[direction]);
    // callback
    if (typeof(callback) === "function")
        callback();
};