Esempio n. 1
0
        void ProcessCmdType(MahjongOpCode opCode, MahjongMachineCmd cmd)
        {
            switch (opCode)
            {
            case MahjongOpCode.SwapPaiGroup:
            {
                MahjongSwapPaiCmd      swapPaiCmd;
                MahjongSwapPaiGroupCmd swapPaiGroupCmd = (MahjongSwapPaiGroupCmd)cmd;

                for (int j = 0; j < 4; j++)
                {
                    swapPaiCmd = (MahjongSwapPaiCmd)CreateCmd(MahjongOpCode.SwapPai);
                    swapPaiGroupCmd.cmdSeats[j] = swapPaiCmd;
                }
            }
            break;

            case MahjongOpCode.FaPai:
            {
                FaPaiCmd faPaiCmd = (FaPaiCmd)cmd;
                faPaiCmd.mjHandSelfPaiFaceValueList.Clear();
                faPaiCmd.selfHuaList.Clear();
                faPaiCmd.selfBuPaiList.Clear();
            }
            break;
            }
        }
        public void AppendCmdToDelayCmdList(MahjongMachineCmd cmd)
        {
            var cmdNode = CreateCmdNode(cmd);

            cmd.delayExecuteTime += Time.time;
            delayOpCmdList.AddLast(cmdNode);
        }
Esempio n. 3
0
        public void ReleaseCmd(MahjongMachineCmd cmd)
        {
            if (cmd == null)
            {
                return;
            }

            cmd.isFree = true;
            cmd.ClearChildCmdList();
        }
Esempio n. 4
0
        MahjongMachineCmd NewCmd(MahjongOpCode opCode)
        {
            MahjongMachineCmd cmd = null;

            switch (opCode)
            {
            case MahjongOpCode.PlayEffectAudio: cmd = new PlayEffectAudioOpCmd(); break;

            case MahjongOpCode.XiPai: cmd = new XiPaiCmd(); break;

            case MahjongOpCode.FaPai: cmd = new FaPaiCmd(); break;

            case MahjongOpCode.TurnNextPlayer: cmd = new TurnNextPlayerOpCmd(); break;

            case MahjongOpCode.ReqSelectSwapPai: cmd = new ReqSelectSwapPaiOpCmd(); break;

            case MahjongOpCode.ReqSelectQueMen: cmd = new ReqSelectQueMenOpCmd(); break;

            case MahjongOpCode.ReqSelectDaPai: cmd = new ReqSelectDaPaiOpCmd(); break;

            case MahjongOpCode.ReqSelectPCGTHPai: cmd = new ReqSelectPCGTHPaiOpCmd(); break;

            case MahjongOpCode.ShowSwapPaiHint: cmd = new ShowSwapPaiHintCmd(); break;

            case MahjongOpCode.HideSwapPaiUI: cmd = new MahjongMachineCmd(); cmd.opCode = MahjongOpCode.HideSwapPaiUI; break;

            case MahjongOpCode.QiDongDiceMachine: cmd = new QiDongDiceMachineCmd(); break;

            case MahjongOpCode.SwapPaiGroup: cmd = new MahjongSwapPaiGroupCmd(); break;

            case MahjongOpCode.SwapPai: cmd = new MahjongSwapPaiCmd(); break;

            case MahjongOpCode.QueMen: cmd = new QueMenCmd(); break;

            case MahjongOpCode.MoPai: cmd = new MahjongMoPaiOpCmd(); break;

            case MahjongOpCode.DaPai: cmd = new MahjongDaPaiOpCmd(); break;

            case MahjongOpCode.ChaPai: cmd = new MahjongChaPaiOpCmd(); break;

            case MahjongOpCode.SortPai: cmd = new MahjongPaiOpCmd(); cmd.opCode = MahjongOpCode.SortPai; break;

            case MahjongOpCode.BuHuaPai: cmd = new MahjongBuHuaPaiOpCmd(); break;

            case MahjongOpCode.HuPai: cmd = new MahjongHuPaiOpCmd(); break;

            case MahjongOpCode.PengChiGangPai: cmd = new MahjongPcgPaiOpCmd(); break;

            case MahjongOpCode.TuiDaoPai: cmd = new MahjongTuiDaoPaiOpCmd(); break;

            case MahjongOpCode.ShowScore: cmd = new ShowScoreCmd(); break;
            }

            return(cmd);
        }
        public void Update()
        {
            if (blockCmdCount > 0)
            {
                return;
            }

            if (curtOpCmd != null)
            {
                switch (curtOpCmd.opCode)
                {
                case MahjongOpCode.TurnNextPlayer:
                {
                    if (CanTurnNextPlayer((TurnNextPlayerOpCmd)curtOpCmd))
                    {
                        CmdOp(null, curtOpCmd);
                        curtOpCmd = null;
                    }
                    else
                    {
                        return;
                    }
                }
                break;
                }
            }

            bool isBlock = false;

            for (LinkedListNode <MahjongMachineCmd> opCmdNode = mjOpCmdList.First; opCmdNode != null; opCmdNode = mjOpCmdList.First)
            {
                mjOpCmdList.RemoveFirst();

                if (opCmdNode.Value.delayExecuteTime > 0)
                {
                    AppendCmdToDelayCmdList(opCmdNode);
                    continue;
                }

                isBlock = opCmdNode.Value.isBlock;

                if (ProcessCmdNode(opCmdNode) == false)
                {
                    return;
                }

                if (isBlock == true)
                {
                    break;
                }
            }

            UpdateDelayExecuteOpCmd();
        }
        public void Reset()
        {
            curtOpCmd     = null;
            blockCmdCount = 0;

            mjOpCmdList.Clear();
            delayOpCmdList.Clear();

            for (int i = 0; i < playerActionOpCmdLists.Length; i++)
            {
                playerActionOpCmdLists[i].Clear();
            }
        }
Esempio n. 7
0
        public LinkedListNode <MahjongMachineCmd> CreateCmdNode(MahjongMachineCmd cmd)
        {
            for (int i = 0; i < cmdNodeList.Count; ++i)
            {
                int temI = (cmdNodeListIdx + i) % cmdNodeList.Count;
                if (isCmdNodeListFree[temI])
                {
                    cmdNodeListIdx          = (temI + 1) % cmdNodeList.Count;
                    isCmdNodeListFree[temI] = false;
                    cmdNodeList[temI].Value = cmd;
                    return(cmdNodeList[temI]);
                }
            }

            LinkedListNode <MahjongMachineCmd> node = new LinkedListNode <MahjongMachineCmd>(cmd);

            cmdNodeList.Add(node);
            isCmdNodeListFree.Add(false);
            return(node);
        }
Esempio n. 8
0
        void SelectSwapPaiEnd(int[] handPaiIdxs, int[] moPaiIdxs)
        {
            MahjongMachineCmd cmdx = CmdPool.Instance.CreateCmd(MahjongOpCode.HideSwapPaiUI);

            mjOpCmdList.Append(cmdx);

            ShowSwapPaiHintCmd showCmd = (ShowSwapPaiHintCmd)CmdPool.Instance.CreateCmd(MahjongOpCode.ShowSwapPaiHint);

            showCmd.isBlock          = false;
            showCmd.swapPaiDirection = SwapPaiDirection.OPPOSITE;
            mjOpCmdList.Append(showCmd);

            MahjongSwapPaiGroupCmd cmd = (MahjongSwapPaiGroupCmd)CmdPool.Instance.CreateCmd(MahjongOpCode.SwapPaiGroup);

            cmd.SwapHandPaiIdx   = handPaiIdxs;
            cmd.SwapMoPaiIdx     = moPaiIdxs;
            cmd.SwapDirection    = SwapPaiDirection.OPPOSITE;
            cmd.TakeMjFaceValues = new MahjongFaceValue[] { MahjongFaceValue.MJ_TIAO_3, MahjongFaceValue.MJ_WANG_4, MahjongFaceValue.MJ_WANG_9 };
            cmd.delayExecuteTime = 1f;
            showCmd.Append(mjOpCmdList.CreateCmdNode(cmd));
        }
Esempio n. 9
0
        public MahjongMachineCmd CreateCmd(MahjongOpCode opCode)
        {
            List <MahjongMachineCmd> cmdList = cmdLists[(int)opCode];

            for (int i = 0; i < cmdList.Count; ++i)
            {
                int temI = (cmdListIdx[(int)opCode] + i) % cmdList.Count;
                if (cmdList[temI].isFree)
                {
                    ProcessCmdType(opCode, cmdList[temI]);
                    cmdListIdx[(int)opCode] = (temI + 1) % cmdList.Count;
                    cmdList[temI].isFree    = false;
                    return(cmdList[temI]);
                }
            }

            MahjongMachineCmd cmd = NewCmd(opCode);

            ProcessCmdType(opCode, cmd);
            cmd.isFree = false;
            cmdList.Add(cmd);
            return(cmd);
        }
Esempio n. 10
0
        public void Append(MahjongMachineCmd mjOpCmd)
        {
            var node = CreateCmdNode(mjOpCmd);

            mjOpCmdList.AddLast(node);
        }
Esempio n. 11
0
        bool ProcessCmdNode(LinkedListNode <MahjongMachineCmd> opCmdNode)
        {
            curtOpCmd = opCmdNode.Value;

            switch (curtOpCmd.opCode)
            {
            case MahjongOpCode.TurnNextPlayer:
            {
                if (CanTurnNextPlayer((TurnNextPlayerOpCmd)curtOpCmd))
                {
                    CmdOp(null, curtOpCmd);
                    curtOpCmd = null;
                }
                else
                {
                    return(false);
                }
            }
            break;

            case MahjongOpCode.ReqSelectSwapPai:
            case MahjongOpCode.ReqSelectDaPai:
            case MahjongOpCode.ReqSelectPCGTHPai:
            case MahjongOpCode.ReqSelectQueMen:
            {
                playerActionOpCmdLists[0].AddLast(opCmdNode);
                curtOpCmd = null;

                if (playerActionOpCmdLists[0].Count == 1)
                {
                    CmdOp(playerActionOpCmdLists[0].First);
                }
            }
            break;

            case MahjongOpCode.MoPai:
            case MahjongOpCode.DaPai:
            case MahjongOpCode.ChaPai:
            case MahjongOpCode.SortPai:
            case MahjongOpCode.BuHuaPai:
            case MahjongOpCode.HuPai:
            case MahjongOpCode.PengChiGangPai:
            case MahjongOpCode.TuiDaoPai:
            {
                MahjongPaiOpCmd cmd = (MahjongPaiOpCmd)curtOpCmd;
                playerActionOpCmdLists[cmd.seatIdx].AddLast(opCmdNode);
                curtOpCmd = null;

                if (playerActionOpCmdLists[cmd.seatIdx].Count == 1)
                {
                    CmdOp(playerActionOpCmdLists[cmd.seatIdx].First);
                }
            }
            break;


            case MahjongOpCode.QiDongDiceMachine:
            {
                QiDongDiceMachineCmd cmd = (QiDongDiceMachineCmd)curtOpCmd;
                playerActionOpCmdLists[cmd.seatIdx].AddLast(opCmdNode);
                curtOpCmd = null;

                if (playerActionOpCmdLists[cmd.seatIdx].Count == 1)
                {
                    CmdOp(playerActionOpCmdLists[cmd.seatIdx].First);
                }
            }
            break;

            case MahjongOpCode.PlayEffectAudio:
            case MahjongOpCode.XiPai:
            case MahjongOpCode.FaPai:
            case MahjongOpCode.ShowScore:
            case MahjongOpCode.ShowSwapPaiHint:
            case MahjongOpCode.HideSwapPaiUI:
            {
                CmdOp(opCmdNode);
                curtOpCmd = null;
            }
            break;

            case MahjongOpCode.SwapPai:
            {
                MahjongSwapPaiCmd cmd = (MahjongSwapPaiCmd)curtOpCmd;
                playerActionOpCmdLists[cmd.fromSeatIdx].AddLast(opCmdNode);
                curtOpCmd = null;

                if (playerActionOpCmdLists[cmd.fromSeatIdx].Count == 1)
                {
                    CmdOp(playerActionOpCmdLists[cmd.fromSeatIdx].First);
                }
            }
            break;

            case MahjongOpCode.QueMen:
            {
                CmdOp(opCmdNode);
                curtOpCmd = null;
            }
            break;


            case MahjongOpCode.SwapPaiGroup:
            {
                MahjongSwapPaiGroupCmd cmd = (MahjongSwapPaiGroupCmd)curtOpCmd;
                curtOpCmd = null;

                for (int i = 0; i < 4; i++)
                {
                    cmd.cmdSeats[i].isBlock     = cmd.isBlock;
                    cmd.cmdSeats[i].swapMjCount = cmd.SwapMjCount;
                    playerActionOpCmdLists[i].AddLast(CreateCmdNode(cmd.cmdSeats[i]));

                    if (playerActionOpCmdLists[i].Count == 1)
                    {
                        CmdOp(playerActionOpCmdLists[i].First);
                    }
                }

                ReleaseCmd(cmd);
                ReleaseCmdNode(opCmdNode);
            }
            break;
            }

            return(true);
        }
Esempio n. 12
0
 public LinkedListNode <MahjongMachineCmd> CreateCmdNode(MahjongMachineCmd mjOpCmd)
 {
     return(CmdPool.Instance.CreateCmdNode(mjOpCmd));
 }
Esempio n. 13
0
 public void ReleaseCmd(MahjongMachineCmd cmd)
 {
     CmdPool.Instance.ReleaseCmd(cmd);
 }
Esempio n. 14
0
        void CmdOp(LinkedListNode <MahjongMachineCmd> opCmdNode, MahjongMachineCmd mjOpCmd = null)
        {
            if (opCmdNode == null && mjOpCmd == null)
            {
                return;
            }

            MahjongMachineCmd opCmd = mjOpCmd;

            if (opCmdNode != null)
            {
                opCmd = opCmdNode.Value;

                if (opCmd.isBlock)
                {
                    blockCmdCount++;
                }
            }

            if (opCmd.delayOpCmdLinkedList != null && opCmd.delayOpCmdLinkedList.Count > 0)
            {
                for (LinkedListNode <MahjongMachineCmd> node = opCmd.delayOpCmdLinkedList.First; node != null; node = opCmd.delayOpCmdLinkedList.First)
                {
                    opCmd.delayOpCmdLinkedList.RemoveFirst();
                    AppendCmdToDelayCmdList(node);
                }

                opCmd.delayOpCmdLinkedList.Clear();
            }

            switch (opCmd.opCode)
            {
            case MahjongOpCode.PlayEffectAudio:
            {
                PlayEffectAudioOpCmd cmd = (PlayEffectAudioOpCmd)opCmd;
                mjMachine.PlayEffectAudio(cmd.audioIdx, cmd.numIdx);
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;

            case MahjongOpCode.XiPai:
            {
                XiPaiCmd cmd = (XiPaiCmd)opCmd;
                mjMachine.XiPai(cmd.dealerSeatIdx, cmd.fengWei, opCmdNode);
            }
            break;


            case MahjongOpCode.FaPai:
            {
                FaPaiCmd cmd = (FaPaiCmd)opCmd;
                mjMachine.FaPai(cmd.startPaiIdx, cmd.mjHandSelfPaiFaceValueList, cmd.selfHuaList, cmd.selfBuPaiList, opCmdNode);
            }
            break;

            case MahjongOpCode.TurnNextPlayer:
            {
                TurnNextPlayerOpCmd cmd = (TurnNextPlayerOpCmd)opCmd;

                FengWei fw = mjMachine.GetSeatFengWei(cmd.turnToPlayerSeatIdx);
                mjMachine.diceMachine.OnFengWei(fw);
                mjMachine.diceMachine.SetLimitTime(cmd.time);
                mjMachine.diceMachine.StartTime();
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;

            case MahjongOpCode.ShowScore:
            {
                ShowScoreCmd cmd = (ShowScoreCmd)opCmd;
                mjMachine.uiScore.Show(cmd.seatScores);
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;

            case MahjongOpCode.HideSwapPaiUI:
            {
                mjMachine.uiSelectSwapHandPai.CompleteSwapPaiSelected();
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;

            case MahjongOpCode.QueMen:
            {
                QueMenCmd cmd = (QueMenCmd)opCmd;
                mjMachine.uiSelectQueMen.AppendPlayQueMenForSeatToList(cmd.seatIdx, cmd.queMenHuaSe);
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;


            case MahjongOpCode.ReqSelectSwapPai:
            {
                mjMachine.SelectSwapPai(opCmdNode);
            }
            break;

            case MahjongOpCode.ReqSelectQueMen:
            {
                ReqSelectQueMenOpCmd cmd = (ReqSelectQueMenOpCmd)opCmd;
                mjMachine.SelectQueMen(cmd.defaultQueMenHuaSe, opCmdNode);
            }
            break;

            case MahjongOpCode.ReqSelectDaPai:
            {
                ReqSelectDaPaiOpCmd cmd = (ReqSelectDaPaiOpCmd)opCmd;

                mjMachine.SelectDaPai(
                    cmd.huPaiInHandPaiIdxs, cmd.huPaiInfosInHandPai,
                    cmd.huPaiInMoPaiIdxs, cmd.huPaiInfosInMoPai, opCmdNode);
            }
            break;

            case MahjongOpCode.ReqSelectPCGTHPai:
            {
                ReqSelectPCGTHPaiOpCmd cmd = (ReqSelectPCGTHPaiOpCmd)opCmd;

                mjMachine.SelectPCGTHPai(cmd.pcgthBtnTypes,
                                         cmd.chiPaiMjValueList, cmd.tingPaiInHandPaiIdxs,
                                         cmd.tingPaiInfosInHandPai, cmd.tingPaiInMoPaiIdxs, cmd.tingPaiInfosInMoPai, opCmdNode);
            }
            break;

            case MahjongOpCode.QiDongDiceMachine:
            {
                QiDongDiceMachineCmd cmd = (QiDongDiceMachineCmd)opCmd;
                mjMachine.QiDongDiceMachine(cmd.seatIdx, cmd.dice1Point, cmd.dice2Point, opCmdNode);
            }
            break;

            case MahjongOpCode.ShowSwapPaiHint:
            {
                ShowSwapPaiHintCmd cmd = (ShowSwapPaiHintCmd)opCmd;
                mjMachine.ShowSwapPaiHint(cmd.swapPaiDirection);
                RemoveCommonActionOpCmd(opCmdNode);
            }
            break;

            case MahjongOpCode.SwapPai:
            {
                MahjongSwapPaiCmd cmd = (MahjongSwapPaiCmd)opCmd;
                mjMachine.SwapPai(
                    cmd.fromSeatIdx, cmd.toSeatIdx, cmd.swapMjCount,
                    cmd.toSeatHandPaiIdx,
                    cmd.mjFaceValues, cmd.fromSeatHandPaiIdx,
                    cmd.mjMoPaiFaceValues, cmd.fromSeatMoPaiIdx,
                    cmd.isShowBack, cmd.swapDir, opCmdNode);
            }
            break;



            case MahjongOpCode.MoPai:
            {
                MahjongMoPaiOpCmd cmd = (MahjongMoPaiOpCmd)opCmd;
                mjMachine.MoPai(cmd.seatIdx, cmd.mjFaceValue, opCmdNode);
            }
            break;

            case MahjongOpCode.DaPai:
            {
                MahjongDaPaiOpCmd cmd = (MahjongDaPaiOpCmd)opCmd;
                ActionCombineNum  actionCombineNum = mjMachine.GetRandomHandDaPaiActionNumForNextDeskMjPos(cmd.seatIdx);
                mjMachine.DaPai(cmd.seatIdx, cmd.handStyle, cmd.paiIdx, cmd.paiType, cmd.mjFaceValue, cmd.isJiaoTing, actionCombineNum, opCmdNode);
            }
            break;

            case MahjongOpCode.ChaPai:
            {
                MahjongChaPaiOpCmd cmd = (MahjongChaPaiOpCmd)opCmd;
                mjMachine.ChaPai(cmd.seatIdx, cmd.handStyle, cmd.orgPaiIdx, cmd.dstHandPaiIdx, cmd.orgPaiType, cmd.adjustDirection, opCmdNode);
            }
            break;

            case MahjongOpCode.SortPai:
            {
                MahjongPaiOpCmd cmd = (MahjongPaiOpCmd)opCmd;
                mjMachine.SortPai(cmd.seatIdx, SortPaiType.LEFT, opCmdNode);
            }
            break;

            case MahjongOpCode.BuHuaPai:
            {
                MahjongBuHuaPaiOpCmd cmd = (MahjongBuHuaPaiOpCmd)opCmd;
                mjMachine.BuHua(cmd.seatIdx, cmd.handStyle, cmd.buHuaPaiFaceValue, ActionCombineNum.HuPai, opCmdNode);
            }
            break;

            case MahjongOpCode.HuPai:
            {
                MahjongHuPaiOpCmd cmd = (MahjongHuPaiOpCmd)opCmd;
                mjMachine.HuPai(cmd.seatIdx, cmd.handStyle, cmd.huTargetSeatIdx, cmd.huTargetMjIdx, cmd.huPaiFaceValue, ActionCombineNum.HuPai, opCmdNode);
            }
            break;

            case MahjongOpCode.PengChiGangPai:
            {
                MahjongPcgPaiOpCmd cmd = (MahjongPcgPaiOpCmd)opCmd;
                mjMachine.PengChiGangPai(
                    cmd.seatIdx, cmd.handStyle, cmd.isMoveHand, cmd.moveHandDist,
                    cmd.faceValues, cmd.pcgType, cmd.pcgTargetSeatIdx, cmd.pcgTargetMjIdx, cmd.fengRainEffectEtcType,
                    ActionCombineNum.PengPai, opCmdNode);
            }
            break;

            case MahjongOpCode.TuiDaoPai:
            {
                MahjongTuiDaoPaiOpCmd cmd = (MahjongTuiDaoPaiOpCmd)opCmd;
                mjMachine.TuiDaoPai(cmd.seatIdx, cmd.handStyle, cmd.handPaiValueList, ActionCombineNum.TuiDaoPai, opCmdNode);
            }
            break;
            }
        }