CardServer/GameManager.ts

import { ALL_PLAYER_NUM } from "./GameDefine";
import { Player } from "./Player";

export class GameManager
{
    mRound:number = 0;
    mGameFightPlayer:Map<string, Player>= new Map<string, Player>;
    mAlivePlayerCount:number = ALL_PLAYER_NUM;
    mCharacterNames:string[]= ["飞鸟仓介", "雾岛林汐", "飞鸟千寻", "小林琉璃", "小林莲夜"]

    clearGameRoundPlayer()
    {
        this.mGameFightPlayer.clear();
    }

    isGameRoundPrepared():boolean
    {
        if(this.mGameFightPlayer.size != this.mAlivePlayerCount)
        {
            return false;
        }
        return true;
    }

    //返回值：是否所有人准备完毕
    setGameRoundInfo(aPlayerID:string, aPlayer:Player):boolean 
    {
        if(aPlayer.mHp <= 0)
        {
            return false;
        }
        this.mGameFightPlayer.set(aPlayerID, aPlayer);
        let result = this.isGameRoundPrepared();
        if(result)
        {
            this.calcuteGameFightResult();
        }
        return result;
    }

    claculatePlayerHp(aAttack:Player, aDefender:Player)
    {
        let realDefender = Math.floor(aDefender.mDefener * (1 - 0.1 * aAttack.mAgile));
        if(aAttack.mAttack > realDefender)
        {
            aDefender.mHp -= aAttack.mAttack - realDefender;
        }
    }

    claculateRanking(aPlayers:Map<string, Player>)
    {
        let sortPlayers:Player[] = [];
        for(const player of aPlayers.values())
        {
            if(player.mHp<=0)
            {
                sortPlayers.push(player);
                this.mAlivePlayerCount--;
            }
        }
        if(sortPlayers.length > 0)
        {
            sortPlayers.sort((a,b)=>a.mAgile - b.mAgile);
            let playerNum = aPlayers.size;
            for(let i=0; i<sortPlayers.length;++i)
            {
                sortPlayers[i].mRank = playerNum - i;
                if(sortPlayers[i].mCharacterName != "")
                {
                    continue;
                }
                let characterName = this.mCharacterNames.pop() ?? "";
                sortPlayers[i].mCharacterName = characterName;
                if(characterName == "飞鸟千寻")
                {
                    let player = aPlayers.get(sortPlayers[i].mCurrentEnemy);
                    if(player)
                    {
                        player.mCharacterName = "高桥林佑";
                    }
                }
            }
        }
        //计算最后一个存活玩家的排名
        if(this.mAlivePlayerCount == 1)
        {
            for(const player of aPlayers.values())
            {
                if(player.mHp > 0)
                {
                    player.mRank = 1;
                    if(this.mCharacterNames.length > 0)
                    {
                        player.mCharacterName = this.mCharacterNames.pop() ?? "";
                    }
                    return;
                }
            }
        }
    }

    calcuteGameFightResult()
    {
        let temp = new Map<string, Player>(this.mGameFightPlayer);
        let restRound:[Player,Player] | null = null;
        while (temp.size > 0)
        {
            const iterator = temp.keys();
            const playerID = iterator.next().value ?? "";
            let player = temp.get(playerID);
            if(!player)
            {
                return;
            }
            if(player.mIsResting)
            {
                let enemy = this.mGameFightPlayer.get(player.mCurrentEnemy);
                if(!enemy)
                {
                    return;
                }
                restRound = [player, enemy],
                temp.delete(playerID);
                continue;
            }
            else
            {
                let enemy = temp.get(player.mCurrentEnemy);
                if(!enemy)
                {
                    return;
                }
                if(player.mAgile >= enemy.mAgile)//palyer 敏捷高
                {
                    this.claculatePlayerHp(player, enemy);
                    if(enemy.mHp > 0)
                    {
                        this.claculatePlayerHp(enemy, player);
                    }
                }
                else//enemy敏捷高
                {
                    this.claculatePlayerHp(enemy, player);
                    if(player.mHp > 0)
                    {
                        this.claculatePlayerHp(player, enemy);
                    }
                }
                temp.delete(playerID);
                temp.delete(player.mCurrentEnemy);
                continue;
            }
        }
        if(restRound != null)
        {
            let restPlayer = restRound[0];
            let enemy = restRound[1];
            if(enemy.mHp > 0)
            {
                this.claculatePlayerHp(enemy, restPlayer);
            }
        }
        this.claculateRanking(this.mGameFightPlayer);
    }
};