MV.js

var async = require("async"),
    _ = require("underscore");

var Species = require("./species.js"),
    Bag = require("./bag.js");

var Player = function (socket, auth, db, scServer) {
    this.socket = socket;
    this.auth = auth;
    this.db = db;
    this.scServer = scServer;
};

// quando jogador conecta
Player.prototype.connect = function () {

    async.parallel({
        // pegar posições do mapa
        map: (next) => {
            this.db.mysql.query(
                "SELECT `pos_x`, `pos_y`, `pos_facing`, `map` FROM `map_position` WHERE `uid` = '" + this.auth.uid + "'",
                function (err, results, fields) {
                    next(err, results[0]);
                }
            );
        },
        // pegar monstros do player
        monsters: (next) => {
            new Species(this.socket, this.auth, this.db)
                .getMonstersInPocket(next);
        },
        // pegar itens do player
        items: (next) => {
            new Bag(this.socket, this.auth, this.db)
                .getItems(next);
        },
        // pegar flags do mapa
        flags: (next) => {
            this.db.mysql.query(
                "SELECT `flag_id`, `value` FROM `flags` WHERE `uid` = '" + this.auth.uid + "' AND `type` = 'm'",
                function (err, results, fields) {
                    next(err, results);
                }
            );
        },
        // o que jogador está fazendo atualmente
        current: (next) => {
            this.db.mysql.query(
                "SELECT `battle_type`, `waiting_wild_battle` FROM `current_doing` WHERE `uid` = '" + this.auth.uid + "'",
                function (err, results, fields) {
                    next(err, results[0]);
                }
            )
        },
    }, (err, data) => {
        // preparar informações pro client
        this.prepareInitialInfoToClient(
            data
        );
    });
};

// quando jogador desconecta
Player.prototype.disconnect = function () {
    console.log(`Jogador ID ${this.auth.uid} desconectou.`);
};

// ping-pong
Player.prototype.pong = function () {
    this.socket.emit("0");
};

// prepara informação para client iniciar o jogo
Player.prototype.prepareInitialInfoToClient = function (data) {
    /*console.log(
        "map, flags, current",
        data.map,
        data.flags,
        data.current
    );*/

    //console.log("flagsss", data.flags);

    // pegando flag do mapa que está atualmente
    var flag = _.findWhere(data.flags, {
        flag_id: String(data.map.map)
    });

    // transformando string em número
    data.current.battle_type = parseInt(data.current.battle_type);

    // caso esteja batalhando
    if (data.current.battle_type > 0) {

        // vendo se é batalha selvagem ou de domador
        switch (data.current.battle_type) {
            // caso seja contra monstro selvagem
            case 1: {
                // enviar batalha
                this.sendWildBattle(data);
                break;
            };
            // caso seja contra domador (cpu)
            case 2: {
                break;
            };
        };

        return;
    };
    // se estiver esperando uma luta selvagem
    if (data.current.waiting_wild_battle > 0) {
        this.sendWaitWildBattle(data, flag);
        return;
    };

    this.socket.emit("99", {
        "state": 0,
        "param": {
            "monsters": data.monsters,
            "position": {
                "x": data.map.pos_x,
                "y": data.map.pos_y,
                "facing": data.map.pos_facing,
            },
            "items": data.items,
            "sprite": 1,
            "map": data.map.map,
            "flag": flag.value,
            "battle": false
        }
    });
};

// enviar informações de batalha com o monstro selvagem para o client
Player.prototype.sendWildBattle = function (data) {


    async.auto({
        battle: next => {
            this.db.mysql.query(
                "SELECT * FROM `battle` WHERE `uid` = '" + this.auth.uid + "'",
                (err, results, fields) => next(err, results[0])
            );
        },
        // pegar infos do monstro selvagem
        wild: next => {
            this.db.mysql.query(
                "SELECT * FROM `monsters` WHERE `wild` = '1' AND `uid` = '" + this.auth.uid + "' AND `enabled` = '1'",
                (err, results, fields) => next(err, results[0])
            );
        },
        buff_nerf: ["battle", (_data, next) => {
            this.db.mysql.query(
                "SELECT * FROM `battle_buffs_nerfs` WHERE `battle_id` = '" + _data.battle.id + "'",
                (err, results) => {
                    results = results || [];
                    next(err, results);
                }
            );
        }]
    }, (err, battle_data) => {
        // seta buff e nerf
        battle_data.battle.buff_nerf = battle_data.buff_nerf;
        // manda infos da batalha pro client
        this.socket.emit("99", {
            state: 1,
            param: {
                playerMonsters: data.monsters,
                battleInfo: battle_data.battle,
                wild: battle_data.wild,
                items: data.items
            }
        });

        // seta que jogador já viu a apresentação
        this.db.mysql.query("UPDATE `battle` SET `seen_presentation` = '1' WHERE `uid` = '" + this.auth.uid + "'");

    });
};

// enviar informações básicas + monstro selvagem que está esperando
Player.prototype.sendWaitWildBattle = function (data, flag) {

    async.waterfall([
        (next) => {
            this.db.mysql.query(
                "SELECT * FROM `monsters` WHERE `wild` = '1' AND `uid` = '" + this.auth.uid + "' AND `enabled` = '1'",
                next
            )
        },
        (results, fields) => {

            this.socket.emit("99", {
                state: 0,
                param: {
                    monsters: data.monsters,
                    position: {
                        x: data.map.pos_x,
                        y: data.map.pos_y,
                        facing: data.map.pos_facing,
                    },
                    items: data.items,
                    sprite: 1,
                    map: data.map.map,
                    flag: flag.value,
                    wild: {
                        id: results[0].monsterpedia_id,
                        level: results[0].level
                    },
                    battle: false
                }
            });
        }
    ])
};

// pegar infos do jogador
Player.prototype.getData = function () {

    async.parallel({
        // pegar dados do mapa
        map: (next) => {
            this.db.mysql.query(
                "SELECT `pos_x`, `pos_y`, `pos_facing`, `map` FROM `map_position` WHERE `uid` = '" + this.auth.uid + "'",
                function (err, results, fields) {
                    next(err, results[0]);
                }
            )
        },
        // pegar flags do mapa
        flags: (next) => {
            this.db.mysql.query(
                "SELECT `flag_id`, `value` FROM `flags` WHERE `uid` = '" + this.auth.uid + "' AND `type` = 'm'",
                function(err, results, fields) {
                    next(err, results);
                }
            );
        }
    }, (err, data) => {

        var flag = _.findWhere(data.flags, {
            flag_id: String(data.map.map)
        });

        this.socket.emit("69", {
            player: {
                sprite: 1,
                facing: data.map.pos_facing,
                x: data.map.pos_x,
                y: data.map.pos_y
            },
            map: data.map.map,
            flag: flag.value,
            needToReload: true
        });
    })
};

Player.prototype.getItemsMonster = function (input) {

    var input = input || {};

    if ("monsters" in input) {
        new Species(this.socket, this.auth, this.db)
            .getMonstersInPocket((err, data) => {
                this.socket.emit("66", {
                    type: 1,
                    data
                });
            });
    };
    if ("items" in input) {
        new Bag(this.socket, this.auth, this.db)
            .getItems((err, data) => {
                this.socket.emit("66", {
                    type: 2,
                    data
                });
            });
    };
};


module.exports = Player;