コード例 #1
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
    public bool notifyPlayerJoin(Character player)
    {
        if (player == null)
        {
            return(false);
        }
        int guid = player.getCharacterData().mGUID;

        if (mPlayerIDList.ContainsKey(guid))
        {
            return(false);
        }
        // 添加到查找列表中
        mPlayerIDList.Add(guid, player);
        // 在位置列表中找到一个空的位置,然后放入玩家
        List <PLAYER_POSITION> posList = new List <PLAYER_POSITION>(mPlayerPositionList.Keys);
        int posCount = posList.Count;

        for (int i = 0; i < posCount; ++i)
        {
            PLAYER_POSITION pos = posList[i];
            if (mPlayerPositionList[pos] == null)
            {
                mPlayerPositionList[pos] = player;
                player.getCharacterData().mPosition = pos;
                return(true);
            }
        }
        return(false);
    }
コード例 #2
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
 //-----------------------------------------------------------------------------------------------------------
 // 事件通知
 public void notifyPlayState(MAHJONG_PLAY_STATE state)
 {
     mPlayState = state;
     // 进入等待流程时,就是开始新一局的麻将游戏,需要重置麻将系统的数据
     if (mPlayState == MAHJONG_PLAY_STATE.MPS_WAITING)
     {
         mPlayerIDList.Clear();
         List <PLAYER_POSITION> posList = new List <PLAYER_POSITION>(mPlayerPositionList.Keys);
         int posCount = posList.Count;
         for (int i = 0; i < posCount; ++i)
         {
             mPlayerPositionList[posList[i]] = null;
         }
         mMahjongPool.Clear();
         int diceCount = mDice.Length;
         for (int i = 0; i < diceCount; ++i)
         {
             mDice[i] = 0;
         }
         mBankerPos    = PLAYER_POSITION.PP_MAX;
         mCurAssignPos = PLAYER_POSITION.PP_MAX;
         mCurInterval  = 0.0f;
     }
     // 开始掷骰子时,需要计算出掷骰子的结果
     else if (mPlayState == MAHJONG_PLAY_STATE.MPS_DICE)
     {
         generateDiceRet(ref mDice);
     }
     // 开始拿牌时,需要重置麻将池
     else if (mPlayState == MAHJONG_PLAY_STATE.MPS_GET_START)
     {
         resetMahjongPool();
         // 判断当前谁是庄家
         foreach (var item in mPlayerPositionList)
         {
             if (item.Value.getCharacterData().mBanker)
             {
                 mBankerPos    = item.Key;
                 mCurAssignPos = mBankerPos;
                 break;
             }
         }
         if (mBankerPos == PLAYER_POSITION.PP_MAX)
         {
             UnityUtility.logError("not find banker!");
         }
     }
     else if (mPlayState == MAHJONG_PLAY_STATE.MPS_NORMAL_GAMING)
     {
         mWaitList.Clear();
     }
     else if (mPlayState == MAHJONG_PLAY_STATE.MPS_WAIT_FOR_ACTION)
     {
         ;
     }
     else if (mPlayState == MAHJONG_PLAY_STATE.MPS_ENDING)
     {
         ;
     }
 }
コード例 #3
0
 public PlayerMahjong(ScriptMahjongHandIn script, PLAYER_POSITION position)
 {
     mScript          = script;
     mPosition        = position;
     mHandInMahjong   = new HandInMahjong(mScript, mPosition);
     mShowMahjong     = new ShowMahjong(mScript, CommonDefine.mDropMahjongPreName[(int)mPosition]);
     mPengGangMahjong = new PengGangMahjong(mScript, CommonDefine.mDropMahjongPreName[(int)mPosition]);
 }
コード例 #4
0
ファイル: Player.cs プロジェクト: naka0405/ALEVEL-Examples
        PLAYER_POSITION position;       // позиция, тип игры игрока

        public Player()
        {
            this.Name     = "Василий";
            this.Surname  = "Пупкин";
            this.Age      = 23;
            this.skill    = 25;
            this.health   = 100;
            this.position = PLAYER_POSITION.BENCHWARMER;
        }
コード例 #5
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
 public void notifyPlayerDrop(Character player, MAHJONG mah)
 {
     // 正常游戏过程中,玩家打了一张牌后,判断其他玩家是否有碰或者杠,该下家摸牌
     if (mPlayState == MAHJONG_PLAY_STATE.MPS_NORMAL_GAMING)
     {
         // 判断其他玩家是否可以碰或者杠
         bool hasAction = false;
         foreach (var item in mPlayerIDList)
         {
             if (item.Value != player)
             {
                 List <MahjongAction> checkActionList = new List <MahjongAction>();
                 CharacterData        data            = item.Value.getCharacterData();
                 // 是否可胡
                 if (GameUtility.canHu(data.mHandIn, mah))
                 {
                     List <HU_TYPE> huList = GameUtility.generateHuType(data.mHandIn, mah, data.mPengGangList, false, false);
                     checkActionList.Add(new MahjongAction(ACTION_TYPE.AT_HU, item.Value, player, mah, huList));
                 }
                 // 是否可杠
                 if (GameUtility.canGang(data.mHandIn, mah))
                 {
                     checkActionList.Add(new MahjongAction(ACTION_TYPE.AT_GANG, item.Value, player, mah));
                 }
                 // 是否可碰
                 if (GameUtility.canPeng(data.mHandIn, mah))
                 {
                     checkActionList.Add(new MahjongAction(ACTION_TYPE.AT_PENG, item.Value, player, mah));
                 }
                 if (checkActionList.Count > 0)
                 {
                     hasAction = true;
                     // 添加pass操作
                     checkActionList.Add(new MahjongAction(ACTION_TYPE.AT_PASS, item.Value, player, mah));
                     askPlayerAction(item.Value, player, mah, checkActionList);
                 }
             }
         }
         // 没有人需要这张牌,则该下家摸牌
         if (!hasAction)
         {
             if (mMahjongPool.Count > 0)
             {
                 PLAYER_POSITION     nextPosition = (PLAYER_POSITION)(((int)(player.getCharacterData().mPosition) + 1) % (int)PLAYER_POSITION.PP_MAX);
                 Character           nextPlayer   = getCharacterByPosition(nextPosition);
                 CommandCharacterGet cmdGet       = mCommandSystem.newCmd <CommandCharacterGet>();
                 cmdGet.mMahjong = requestGet();
                 mCommandSystem.pushCommand(cmdGet, nextPlayer);
             }
             // 牌已经摸完了,则本局为平局
             else
             {
                 //End;
             }
         }
     }
 }
コード例 #6
0
ファイル: Player.cs プロジェクト: naka0405/ALEVEL-Examples
 public Player(string name, string Surname, byte Age,
               byte Skill, PLAYER_POSITION Position, Team Team)
     : base(name, Surname)
 {
     this.skill    = Skill;
     this.team     = Team;
     this.health   = 100;                     // значение здоровья по умолчанию
     this.position = Position;
     this.Age      = Age;
 }
コード例 #7
0
ファイル: GameUtility.cs プロジェクト: isoundy000/Mahjong-3
    // 服务器中的位置转换为客户端的位置
    public static PLAYER_POSITION serverPositionToClientPosition(PLAYER_POSITION serverPosition, PLAYER_POSITION myselfSererPosition)
    {
        int interval = serverPosition - myselfSererPosition;

        if (interval < 0)
        {
            interval += GameDefine.MAX_PLAYER_COUNT;
        }
        return((PLAYER_POSITION)(interval));
    }
コード例 #8
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
    public void update(float elapsedTime)
    {
        // 开始拿牌时,需要由麻将系统给玩家分发牌
        if (mPlayState == MAHJONG_PLAY_STATE.MPS_GET_START)
        {
            mCurInterval -= elapsedTime;
            // 从庄家开始发牌
            if (mCurInterval <= 0.0f)
            {
                mCurInterval = GameDefine.ASSIGN_MAHJONG_INTERVAL;
                Character curPlayer = mPlayerPositionList[mCurAssignPos];
                // 给玩家发牌
                CommandCharacterGetStart cmd = mCommandSystem.newCmd <CommandCharacterGetStart>();
                cmd.mMahjong = requestGet();
                mCommandSystem.pushCommand(cmd, curPlayer);

                bool isDone            = false;
                int  palyerHandInCount = curPlayer.getCharacterData().mHandIn.Count;
                // 如果是庄家,需要拿够14张牌
                if (mCurAssignPos == mBankerPos)
                {
                    isDone = (palyerHandInCount == GameDefine.MAX_HAND_IN_COUNT);
                }
                // 不是庄家则拿13张牌
                else
                {
                    isDone = (palyerHandInCount == GameDefine.MAX_HAND_IN_COUNT - 1);
                }
                // 牌拿完时需要重新排列
                if (isDone)
                {
                    CommandCharacterReorderMahjong cmdReorder = mCommandSystem.newCmd <CommandCharacterReorderMahjong>();
                    mCommandSystem.pushCommand(cmdReorder, curPlayer);

                    // 如果是庄家拿完了牌,则进入正常游戏流程
                    if (mCurAssignPos == mBankerPos)
                    {
                        CommandMahjongSceneNotifyStartDone cmdStartDone = mCommandSystem.newCmd <CommandMahjongSceneNotifyStartDone>();
                        mCommandSystem.pushCommand(cmdStartDone, mGameSceneManager.getCurScene());

                        // 通知玩家打出一张牌
                        CommandCharacterAskDrop cmdAskDrop = mCommandSystem.newCmd <CommandCharacterAskDrop>();
                        mCommandSystem.pushCommand(cmdAskDrop, curPlayer);
                        return;
                    }
                }
                mCurAssignPos = (PLAYER_POSITION)(((int)mCurAssignPos + 1) % (int)PLAYER_POSITION.PP_MAX);
            }
        }
    }
コード例 #9
0
    //--------------------------------------------------------------------------------------------------------------------------------------
    protected void refreshDropMahjong(PLAYER_POSITION pos, List <MAHJONG> droppedMahjong)
    {
        int droppedCount   = droppedMahjong.Count;
        int showCount      = MathUtility.getMin(mMaxDropCount, droppedCount);
        int showStartIndex = droppedCount - showCount;

        for (int i = 0; i < mMaxDropCount; ++i)
        {
            LayoutTools.ACTIVE_WINDOW(mDropList[(int)pos][i], i < showCount);
            if (i < showCount)
            {
                mDropList[(int)pos][i].setSpriteName(GameDefine.mDropMahjongPreName[(int)pos] + GameDefine.MAHJONG_NAME[(int)droppedMahjong[showStartIndex + i]]);
            }
        }
    }
コード例 #10
0
    // pos是玩家的位置
    public void notifyDropMahjong(PLAYER_POSITION pos, List <MAHJONG> droppedMahjong, MAHJONG mahjong)
    {
        int preCount = droppedMahjong.Count - 1;

        if (preCount < mDropList[(int)pos].Count)
        {
            string mahjongSpriteName = GameDefine.mDropMahjongPreName[(int)pos] + GameDefine.MAHJONG_NAME[(int)mahjong];
            mDropList[(int)pos][preCount].setSpriteName(mahjongSpriteName);
            LayoutTools.ACTIVE_WINDOW(mDropList[(int)pos][preCount]);
        }
        else
        {
            refreshDropMahjong(pos, droppedMahjong);
        }
    }
コード例 #11
0
ファイル: PlayerMahjong.cs プロジェクト: huai707/Mahjong
 public PlayerMahjong(ScriptMahjongHandIn script, PLAYER_POSITION position)
 {
     mScript   = script;
     mPosition = position;
     if (mPosition == PLAYER_POSITION.PP_MYSELF)
     {
         mHandInMahjong = new HandInMahjongMyself(mScript, mPosition);
     }
     else
     {
         mHandInMahjong = new HandInMahjongOther(mScript, mPosition);
     }
     mShowMahjong     = new ShowHuMahjong(mScript, GameDefine.mDropMahjongPreName[(int)mPosition]);
     mPengGangMahjong = new PengGangMahjong(mScript, GameDefine.mDropMahjongPreName[(int)mPosition]);
     mHuaMahjong      = new HuaMahjong(mScript, GameDefine.mDropMahjongPreName[(int)mPosition]);
 }
コード例 #12
0
 public HandInMahjong(ScriptMahjongHandIn script, PLAYER_POSITION position)
 {
     mScript               = script;
     mPosition             = position;
     mCanDrop              = false;
     mHandInMahjong        = new List <HandInMahjongInfo>();
     mHandInPosition       = new List <Vector3>();
     mHandInTargetPosition = new List <Vector3>();
     for (int i = 0; i < GameDefine.MAX_HAND_IN_COUNT; ++i)
     {
         HandInMahjongInfo info = new HandInMahjongInfo();
         info.mState   = HANDIN_STATE.HS_MAX;
         info.mMahjong = MAHJONG.M_MAX;
         mHandInMahjong.Add(info);
     }
 }
コード例 #13
0
ファイル: MahjongSystem.cs プロジェクト: huai707/Mahjong
 public override void update(float elapsedTime)
 {
     // 开始拿牌时,需要由麻将系统给玩家分发牌
     if (mPlayState == MAHJONG_PLAY_STATE.MPS_GET_START)
     {
         mCurInterval -= elapsedTime;
         // 从庄家开始发牌
         if (mCurInterval <= 0.0f)
         {
             mCurInterval += GameDefine.ASSIGN_MAHJONG_INTERVAL;
             // 给玩家发牌
             CommandCharacterGetStart cmd = newCmd(out cmd);
             cmd.mMahjong = mHandInList[(int)mCurAssignPos][0];
             pushCommand(cmd, mPlayerPositionList[(int)mCurAssignPos]);
             mHandInList[(int)mCurAssignPos].RemoveAt(0);
             // 如果到房主的牌发完了,则退出发牌
             if (mCurAssignPos == mBankerPos && mHandInList[(int)mCurAssignPos].Count == 0)
             {
                 mPlayState = MAHJONG_PLAY_STATE.MPS_NORMAL_GAMING;
                 // 牌拿完时需要重新排列,发放花牌
                 int playerCount = mPlayerPositionList.Count;
                 for (int i = 0; i < playerCount; ++i)
                 {
                     int huaCount = mHuaList[i].Count;
                     for (int j = 0; j < huaCount; ++j)
                     {
                         CommandCharacterGetHua cmdHua = newCmd(out cmdHua);
                         cmdHua.mMah = mHuaList[i][j];
                         pushCommand(cmdHua, mPlayerPositionList[i]);
                     }
                 }
                 // 通知服务器开局麻将已经拿完了
                 mSocketManager.sendMessage <CSGetStartMahjongDone>();
                 return;
             }
             else
             {
                 mCurAssignPos = (PLAYER_POSITION)(((int)mCurAssignPos + 1) % (int)PLAYER_POSITION.PP_MAX);
             }
         }
     }
 }
コード例 #14
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
    public bool notifyPlayerQuit(Character player)
    {
        if (player == null)
        {
            return(false);
        }
        CharacterData data = player.getCharacterData();

        if (!mPlayerIDList.ContainsKey(data.mGUID))
        {
            return(false);
        }
        mPlayerIDList.Remove(data.mGUID);
        PLAYER_POSITION position = data.mPosition;

        if (mPlayerPositionList[position] != player)
        {
            return(false);
        }
        mPlayerPositionList[position] = null;
        return(true);
    }
コード例 #15
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
    // 玩家请求确认操作
    public void playerConfirmAction(Character player, ACTION_TYPE type)
    {
        if (!mWaitList.ContainsKey(player))
        {
            UnityUtility.logError("player has no action : name : " + player.getName() + ", action : " + type);
        }
        MahjongAction        action     = null;
        List <MahjongAction> actionList = mWaitList[player].mActionList;
        int actionCount = actionList.Count;

        for (int i = 0; i < actionCount; ++i)
        {
            if (actionList[i].mType == type)
            {
                action = actionList[i];
                break;
            }
        }
        if (action == null)
        {
            return;
        }
        mWaitList[player].mConfirmedAction = action;
        // 胡牌的优先级最高,如果有玩家选择胡牌,则忽略其他玩家的操作
        if (action.mType == ACTION_TYPE.AT_HU)
        {
            // 游戏状态设置为正常游戏
            notifyPlayState(MAHJONG_PLAY_STATE.MPS_NORMAL_GAMING);
            CommandCharacterHu cmd = mCommandSystem.newCmd <CommandCharacterHu>();
            mCommandSystem.pushCommand(cmd, player);

            // 有玩家胡牌后则结束游戏
            //End;
        }
        else
        {
            bool          allConfirm          = true;
            Character     highestActionPlayer = null;
            MahjongAction highestAction       = null;
            foreach (var wait in mWaitList)
            {
                if (wait.Value.mConfirmedAction == null)
                {
                    allConfirm = false;
                    break;
                }
                if (highestAction == null || highestAction.mType > wait.Value.mConfirmedAction.mType)
                {
                    highestAction       = wait.Value.mConfirmedAction;
                    highestActionPlayer = wait.Value.mPlayer;
                }
            }
            // 如果全部玩家都已经确认操作了,允许优先级最高的操作进行
            if (allConfirm)
            {
                // 先获得信息,因为在设置状态时会将列表清空
                WaitActionInfo info = mWaitList[highestActionPlayer];
                // 游戏状态设置为正常游戏
                notifyPlayState(MAHJONG_PLAY_STATE.MPS_NORMAL_GAMING);
                if (highestAction.mType == ACTION_TYPE.AT_GANG)
                {
                    // 自己摸的牌开杠
                    if (info.mDroppedPlayer == info.mPlayer)
                    {
                        ;
                    }
                    // 别人打出牌开杠
                    else
                    {
                        ;
                    }
                    CommandCharacterGang cmd = mCommandSystem.newCmd <CommandCharacterGang>();
                    cmd.mDroppedPlayer = info.mDroppedPlayer;
                    cmd.mMahjong       = info.mMahjong;
                    mCommandSystem.pushCommand(cmd, info.mPlayer);

                    // 还有牌,玩家杠了一张牌以后需要再摸一张
                    if (mMahjongPool.Count > 0)
                    {
                        CommandCharacterGet cmdGet = mCommandSystem.newCmd <CommandCharacterGet>();
                        cmdGet.mMahjong = requestGet();
                        mCommandSystem.pushCommand(cmdGet, info.mPlayer);
                    }
                    // 没有牌了则平局
                    else
                    {
                        //End;
                    }
                }
                else if (highestAction.mType == ACTION_TYPE.AT_PENG)
                {
                    CommandCharacterPeng cmd = mCommandSystem.newCmd <CommandCharacterPeng>();
                    cmd.mDroppedPlayer = info.mDroppedPlayer;
                    cmd.mMahjong       = info.mMahjong;
                    mCommandSystem.pushCommand(cmd, info.mPlayer);

                    CommandCharacterAskDrop cmdAskDrop = mCommandSystem.newCmd <CommandCharacterAskDrop>();
                    mCommandSystem.pushCommand(cmdAskDrop, info.mPlayer);
                }
                else if (highestAction.mType == ACTION_TYPE.AT_PASS)
                {
                    // 如果是自己摸了一张牌,选择了pass,则需要自己打一张牌出来
                    if (info.mDroppedPlayer == info.mPlayer)
                    {
                        CommandCharacterAskDrop cmd = mCommandSystem.newCmd <CommandCharacterAskDrop>();
                        mCommandSystem.pushCommand(cmd, info.mPlayer);
                    }
                    else
                    {
                        // 还有牌则通知下一家摸牌
                        if (mMahjongPool.Count > 0)
                        {
                            PLAYER_POSITION     nextPosition = (PLAYER_POSITION)(((int)(info.mDroppedPlayer.getCharacterData().mPosition) + 1) % (int)PLAYER_POSITION.PP_MAX);
                            CommandCharacterGet cmdGet       = mCommandSystem.newCmd <CommandCharacterGet>();
                            cmdGet.mMahjong = requestGet();
                            mCommandSystem.pushCommand(cmdGet, getCharacterByPosition(nextPosition));
                        }
                        // 没有牌了则平局
                        else
                        {
                            //End;
                        }
                    }
                }
            }
        }
    }
コード例 #16
0
 public void notifyGetHua(PLAYER_POSITION pos, List <MAHJONG> huaList)
 {
     mPlayerMahjong[(int)pos].notifyGetHua(huaList);
 }
コード例 #17
0
 public void notifyAbleToPengOrGang(PLAYER_POSITION pos, MAHJONG mah)
 {
     mPlayerMahjong[(int)pos].notifyAbleToPengOrGang(mah);
 }
コード例 #18
0
 // 摸牌
 public void notifyGetMahjong(PLAYER_POSITION pos, MAHJONG mah)
 {
     mPlayerMahjong[(int)pos].notifyGet(mah);
 }
コード例 #19
0
ファイル: MahjongSystem.cs プロジェクト: quyixia/Mahjong
 public Character getCharacterByPosition(PLAYER_POSITION pos)
 {
     return(mPlayerPositionList[pos]);
 }
コード例 #20
0
ファイル: MahjongSystem.cs プロジェクト: huai707/Mahjong
 public void notifyGetStartMahjong()
 {
     mPlayState    = MAHJONG_PLAY_STATE.MPS_GET_START;
     mCurAssignPos = mBankerPos;
 }
コード例 #21
0
ファイル: MahjongSystem.cs プロジェクト: huai707/Mahjong
 public void setBankerPos(int bankerPos)
 {
     // 计算出服务器中庄家在本地的方位
     mBankerPos = (PLAYER_POSITION)bankerPos;
 }
コード例 #22
0
 // 打牌
 public void notifyDropMahjong(PLAYER_POSITION pos, MAHJONG mah, int index)
 {
     mPlayerMahjong[(int)pos].notifyDrop(mah, index);
 }
コード例 #23
0
    public void notifyTakeDroppedMahjong(PLAYER_POSITION pos, int index)
    {
        int maxIndex = MathUtility.getMin(mMaxDropCount - 1, index);

        LayoutTools.ACTIVE_WINDOW(mDropList[(int)pos][maxIndex], false);
    }
コード例 #24
0
 public void notifyEnd(PLAYER_POSITION pos, List <MAHJONG> handIn)
 {
     mPlayerMahjong[(int)pos].notifyEnd(handIn);
 }
コード例 #25
0
 public HandInMahjongMyself(ScriptMahjongHandIn script, PLAYER_POSITION position)
     : base(script, position)
 {
 }
コード例 #26
0
 // 碰牌或者杠牌
 public void notifyPengOrGang(PLAYER_POSITION pos, List <PengGangInfo> infoList)
 {
     mPlayerMahjong[(int)pos].notifyPengOrGang(infoList);
 }