CardServer/RoomManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RoomManager = void 0;
const Player_1 = require("./Player");
const MatchMaker_1 = require("./MatchMaker");
const GameDefine_1 = require("./GameDefine");
const GameManager_1 = require("./GameManager");
const GetLocalTime_1 = require("./GetLocalTime");
;
class Room {
    constructor() {
        this.mPlayers = new Map;
        this.mStatus = 0; //0：房间开启；1：所有人准备，进入fight；2：fight结束
        this.mMatchMaker = (0, MatchMaker_1.createMatchmaker)(this.mPlayers);
        this.mGameManager = new GameManager_1.GameManager();
        this.mCreatedTime = (0, GetLocalTime_1.getLocalTime)();
    }
    isRoomPrepared() {
        if (this.mPlayers.size != GameDefine_1.ALL_PLAYER_NUM) {
            return false;
        }
        for (const value of this.mPlayers.values()) {
            if (value.mPrepared == false) {
                return false;
            }
        }
        return true;
    }
    setRoomPrepared() {
        this.generatePairings();
        this.mStatus = 1;
    }
    generatePairings() {
        let tempPlayers = new Map;
        for (const key of this.mPlayers.keys()) {
            if (this.mPlayers.get(key).mHp > 0) {
                tempPlayers.set(key, this.mPlayers.get(key));
            }
        }
        this.mMatchMaker.updatePlayers(tempPlayers);
        let result = this.mMatchMaker.generatePairings();
        for (let i = 0; i < result.length; ++i) {
            let player = this.mPlayers.get(result[i].playerId);
            if (player) {
                player.mCurrentEnemy = result[i].opponentId;
                player.mIsResting = result[i].isResting;
            }
        }
        return result;
    }
    getGameInfos() {
        let gameInfo = [];
        for (const player of this.mPlayers.values()) {
            gameInfo.push({ playerId: player.mPlayerName,
                opponentId: player.mCurrentEnemy,
                socketID: player.mSocketId,
                rank: player.mRank,
                character: player.mCharacterName,
                hp: player.mHp });
        }
        return gameInfo;
    }
    getGameRoundInfos() {
        let gameInfo = [];
        for (const player of this.mGameManager.mGameFightPlayer.values()) {
            gameInfo.push({ playerId: player.mPlayerName,
                opponentId: player.mCurrentEnemy,
                socketID: player.mSocketId,
                rank: player.mRank,
                character: player.mCharacterName,
                hp: player.mHp });
        }
        return gameInfo;
    }
    getGameInfo(aPlayerID) {
        let player = this.mPlayers.get(aPlayerID);
        if (player) {
            return { playerId: player.mPlayerName, opponentId: player.mCurrentEnemy, socketID: player.mSocketId, rank: player.mRank, character: player.mCharacterName, hp: player.mHp };
        }
        return null;
    }
    setGameFight(aPlayerID, aAttack, aDefender) {
        let player = this.mPlayers.get(aPlayerID);
        if (!player) {
            return false;
        }
        player.mAttack = aAttack;
        player.mDefener = aDefender;
        return this.mGameManager.setGameRoundInfo(aPlayerID, player);
    }
}
class RoomManager {
    constructor() {
        this.mRooms = new Map;
    }
    static getInstance() {
        if (this.mInstance == null) {
            this.mInstance = new RoomManager();
        }
        return this.mInstance;
    }
    join(aRoomID, aName, aSocket) {
        if (!this.mRooms.has(aRoomID)) {
            return [false, "No room Id", null, null];
        }
        let room = this.mRooms.get(aRoomID);
        if (room.mPlayers.has(aName)) {
            let player = room.mPlayers.get(aName);
            player.setPlayerSocketId(aSocket.id);
            aSocket.join(aRoomID);
            return [true, "", room.mStatus, player];
        }
        if (room.mPlayers.size < GameDefine_1.ALL_PLAYER_NUM) {
            let player = new Player_1.Player(aName, aSocket.id);
            aSocket.join(aRoomID);
            room.mPlayers.set(aName, player);
            return [true, "", 0, null];
        }
        return [false, "room full", null, null];
    }
    setPlayerInfo(roomId, playerId, strength, stamina, agile, cards) {
        let room = this.mRooms.get(roomId);
        if (!room) {
            return false;
        }
        let player = room.mPlayers.get(playerId);
        if (!player) {
            return false;
        }
        player.setPlayerInfo(strength, stamina, agile, cards);
        if (room.isRoomPrepared() == true) {
            room.setRoomPrepared();
            return true;
        }
        return false;
    }
    createRoom(aRoomID) {
        this.mRooms.set(aRoomID, new Room());
    }
    getPlayersByRoomID(aRoomID) {
        let room = this.mRooms.get(aRoomID);
        let result = [];
        if (room === null || room === void 0 ? void 0 : room.mPlayers) {
            for (const value of room.mPlayers.values()) {
                result.push({ playerName: value.mPlayerName, playerPrepared: value.mPrepared });
            }
        }
        return result;
    }
    getGameInfos(aRoomID) {
        let room = this.mRooms.get(aRoomID);
        if (room) {
            return room.getGameInfos();
        }
        return [];
    }
    getGameInfo(aRoomID, aPlayerID) {
        let room = this.mRooms.get(aRoomID);
        if (room) {
            return room.getGameInfo(aPlayerID);
        }
        return null;
    }
    getGameRoundInfos(aRoomID, aPlayerID) {
        let room = this.mRooms.get(aRoomID);
        if (room) {
            return room.getGameRoundInfos();
        }
        return [];
    }
    //返回值是否所有人都准备完毕
    setGameFight(aRoomID, aPlayerID, aAttack, aDefender) {
        let room = this.mRooms.get(aRoomID);
        if (!room) {
            return false;
        }
        let result = room.setGameFight(aPlayerID, aAttack, aDefender);
        if (result) {
            room.generatePairings();
        }
        return result;
    }
    clearGameRoundPlayer(aRoomID) {
        let room = this.mRooms.get(aRoomID);
        if (!room) {
            return;
        }
        room.mGameManager.clearGameRoundPlayer();
    }
    isRoomExist(aRoomID) {
        return this.mRooms.has(aRoomID);
    }
}
exports.RoomManager = RoomManager;