Exemplo n.º 1
0
 public void SetPoker(NN_POKER poker)
 {
     if (poker.hasIndex())
     {
         this.index = poker.index;
     }
     if (poker.hasColor())
     {
         this.color = poker.color;
     }
     if (poker.hasSize())
     {
         this.size = poker.size;
     }
     if (poker.hasPokerStatus())
     {
         this.status = poker.pokerStatus;
     }
 }
Exemplo n.º 2
0
        /// <summary>
        /// 向服务器申请 翻开一张
        /// </summary>
        /// <param name="seat"></param>
        public void NeedOpenPoker(object[] obj)
        {
            Debug.Log("点击了牌");
            if (RoomNiuNiuProxy.Instance.CurrentRoom.roomStatus != NN_ENUM_ROOM_STATUS.LOOKPOCKER && RoomNiuNiuProxy.Instance.PlayerSeat.Pour <= 0)
            {
                Debug.Log("不是看牌阶段,无法翻开这张牌");
                return;
            }
            NN_ROOM_DRAW_GET proto       = new NN_ROOM_DRAW_GET();
            List <NN_POKER>  prPokerList = proto.getNnPokerList();

            NiuNiu.Seat PlayerSeat = RoomNiuNiuProxy.Instance.PlayerSeat;
            for (int i = 0; i < obj.Length; i++)
            {
                int itemIndex = (int)obj[i];
                if (itemIndex > 0 && itemIndex <= ROOM_POKERLIST_COUNT)
                {
                    Debug.Log("牌状态:" + PlayerSeat.PokerList[itemIndex].status);

                    if (PlayerSeat.PokerList[itemIndex].status == 0)
                    {
                        NN_POKER nn_poker = new NN_POKER();
                        nn_poker.index       = PlayerSeat.PokerList[itemIndex].index;
                        nn_poker.color       = PlayerSeat.PokerList[itemIndex].color;
                        nn_poker.size        = PlayerSeat.PokerList[itemIndex].size;
                        nn_poker.pokerStatus = (NN_ENUM_POKER_STATUS)PlayerSeat.PokerList[itemIndex].status;
                        proto.addNnPoker(nn_poker);
                        Debug.Log("要开的牌index是" + nn_poker.index);
                    }
                }
            }

            Debug.Log("发送的翻牌长度" + proto.getNnPokerList().Count);
            if (prPokerList.Count <= 0)
            {
                Debug.Log("没有要开的牌");
                return;
            }

            NetWorkSocket.Instance.Send(proto.encode(), NN_ROOM_DRAW.CODE, GameCtrl.Instance.SocketHandle);
        }
Exemplo n.º 3
0
    /// <summary>
    /// 打开搓牌界面
    /// </summary>
    private void OpenRubPokerWindow()
    {
        if (m_UIRubPokerView != null)
        {
            return;
        }


        UIViewUtil.Instance.LoadWindowAsync(UIWindowType.RubPoker_NiuNiu, (GameObject go) =>
        {
            m_UIRubPokerView = go.GetComponent <UIRubPokerView_NiuNiu>();
            m_UIRubPokerView.SetUI(RoomNiuNiuProxy.Instance.PlayerSeat, () => {
                UIRubPokerViewClose();

                if (RoomNiuNiuProxy.Instance.CurrentRoom.roomStatus != NN_ENUM_ROOM_STATUS.LOOKPOCKER && RoomNiuNiuProxy.Instance.PlayerSeat.Pour <= 0)
                {
                    return;
                }

                //向服务器申请 翻开这张
                object[] obj = new object[] { 4 };
                NiuNiuEventDispatcher.Instance.Dispatch("NeedOpenPokerNiuNiu", obj);
                //模拟开牌
                Poker pokerLocal   = RoomNiuNiuProxy.Instance.PlayerSeat.PokerList[RoomNiuNiuProxy.Instance.PlayerSeat.PokerList.Count - 1];
                NN_ROOM_DRAW proto = new NN_ROOM_DRAW();
                proto.pos          = RoomNiuNiuProxy.Instance.PlayerSeat.Pos;
                NN_POKER poker     = new NN_POKER();
                poker.index        = pokerLocal.index;
                poker.size         = pokerLocal.size;
                poker.color        = pokerLocal.color;
                poker.pokerStatus  = pokerLocal.status;
                proto.addNnPoker(poker);
                RoomNiuNiuProxy.Instance.OpenAPoker(proto);

                //TransferData data = new TransferData();
                //data.SetValue<NiuNiu.Seat>("Seat", RoomNiuNiuProxy.Instance.PlayerSeat);
                //SendNotification("SetShowPokersUI", data);//设置某玩家手牌
            });
        }
                                            );
    }
Exemplo n.º 4
0
        /// <summary>
        /// 初始化房间信息  构建房间
        /// </summary>
        /// <param name="proto"></param>
        public void InitCurrentRoom(NN_ROOM_CREATE proto)
        {
            BankerSeat = null;

            CurrentRoom = new NiuNiu.Room();

            //收到数据存到模型基类                                 <------------------------------<保存配置>----------------------------------------
            CurrentRoom.Config.Clear();

            for (int i = 0; i < proto.nn_room.settingIdCount(); ++i)
            {
                cfg_settingEntity settingEntity = cfg_settingDBModel.Instance.Get(proto.nn_room.getSettingId(i));

                if (settingEntity != null)
                {
                    CurrentRoom.Config.Add(settingEntity);
                }
            }

            //获得当前游戏模式
            for (int i = 0; i < CurrentRoom.Config.Count; i++)
            {
                if (CurrentRoom.Config[i].tags.Equals("mode"))
                {
                    CurrentRoom.roomModel = (Room.RoomModel)CurrentRoom.Config[i].value;
                    Debug.Log("服务器发送的房间 庄模式为为:" + CurrentRoom.Config[i].value);
//#if IS_GUGENG
//                    if (CurrentRoom.roomModel == Room.RoomModel.EveryTime || CurrentRoom.roomModel == Room.RoomModel.WinnerByBanker)
//                        CurrentRoom.roomModel = Room.RoomModel.AutoBanker;
//#endif
                }
            }
            for (int i = 0; i < CurrentRoom.Config.Count; i++)
            {
                if (CurrentRoom.Config[i].tags.Equals("roomMode"))
                {
                    CurrentRoom.superModel = (Room.SuperModel)CurrentRoom.Config[i].value;
                    Debug.Log("服务器发送的房间 普通高级场模式为为:" + CurrentRoom.Config[i].value);
                }
            }



            Debug.Log("房间ID为:" + proto.nn_room.roomId);
            Debug.Log("服务器发送的房间座位长度为:" + proto.nn_room.getNnSeatList().Count);
            CurrentRoom.roomId = proto.nn_room.roomId;

            CurrentRoom.roomStatus  = proto.nn_room.nn_room_status;
            CurrentRoom.currentLoop = proto.nn_room.loop;
            CurrentRoom.maxLoop     = proto.nn_room.maxLoop;



            CurrentRoom.SeatCount = proto.nn_room.getNnSeatList().Count;

            //CurrentRoom.SeatCount = proto.nn_room.nnSeatCount;//----------------------------------《座位长度《-----------------------------------------
            CurrentRoom.SeatList = new List <NiuNiu.Seat>();

            for (int i = 0; i < CurrentRoom.SeatCount /*proto.nn_room.getNnSeatList().Count*/; ++i)
            {
                NN_SEAT     nn_seat = proto.nn_room.getNnSeat(i);
                NiuNiu.Seat seat    = new NiuNiu.Seat();
                //NiuNiu.Seat seat = new NiuNiu.Seat(proto.nn_room.seatList[i]);


                //房主
                seat.IsHomeowners = nn_seat.IsHomeowners;//----------------------------------《房主《-----------------------------------------

                //是否同意解散
                if (nn_seat.hasDissolve())
                {
                    seat.Dissolve = nn_seat.dissolve;
                }

                //庄
                seat.IsBanker = nn_seat.isBanker;
                //玩家ID
                seat.PlayerId = nn_seat.playerId;
                //pos
                seat.Pos = nn_seat.pos;
                //昵称
                seat.Nickname = nn_seat.nickname;
                //头像
                seat.Avatar = nn_seat.avatar;
                //性别
                seat.Gender = nn_seat.gender;
                //是否准备
                seat.IsReady = nn_seat.ready;

                //已有金币
                seat.Gold = nn_seat.gold;
                //本局收益
                seat.Earnings = nn_seat.nn_earnings;
                //是否是胜利者
                seat.Winner = nn_seat.isWiner;
                //下注
                seat.Pour = nn_seat.pour;

                //纬度
                if (nn_seat.hasLatitude())
                {
                    seat.Latitude = nn_seat.latitude;
                }

                //经度
                if (nn_seat.hasLongitude())
                {
                    seat.Longitude = nn_seat.longitude;
                }


                //手牌类型
                if (nn_seat.hasNnPokerType())
                {
                    if (nn_seat.nn_pokerType != 0)
                    {
                        seat.PockeType = (int)nn_seat.nn_pokerType;
                    }
                }

                seat.PokerList = new List <Poker>();
                //具体手牌
                //if (nn_seat.getNnPokerList() != null && nn_seat.getNnPokerList().Count > 0)
                //{
                for (int j = 0; j < 5; j++)//nn_seat.nnPokerCount()
                {
                    NN_POKER protoPoker = null;
                    if (nn_seat.nnPokerCount() > j)
                    {
                        protoPoker = nn_seat.getNnPoker(j);
                    }

                    NiuNiu.Poker poker = new NiuNiu.Poker();
                    if (protoPoker != null && protoPoker.hasIndex() && protoPoker.index != 0)
                    {
                        //seat.PokerList[j].SetPoker(nn_seat.PokerList[j]);

                        poker.color  = protoPoker.color;
                        poker.index  = protoPoker.index;
                        poker.size   = protoPoker.size;
                        poker.status = protoPoker.pokerStatus;
                    }
                    seat.PokerList.Add(poker);
                }

                //}

                if (seat.IsBanker)
                {
                    BankerSeat = seat;               //庄座位
                }
                if (proto.nn_room.pos == seat.Pos)
                {
                    CurrentRoom.RobBankerSeat = seat;                               //获得当前抢庄座位
                }
                CurrentRoom.SeatList.Add(seat);
            }



            if (proto.nn_room.hasUnixtime())
            {
                CurrentRoom.serverTime = proto.nn_room.unixtime;//(时间戳)
            }


            CalculateSeatIndex(CurrentRoom);

            playerSeatIndex = PlayerSeat.Pos;
            PeopleCounting();

            if (CurrentRoom.roomModel == Room.RoomModel.robBanker && BankerSeat != null)
            {
                PlayerSeat.isAlreadyHOG = -1;
            }

            if (CurrentRoom.roomStatus == NN_ENUM_ROOM_STATUS.DISSOLVE)
            {
                //计算当前同意解散人数
                ADHEnterRoom(proto.nn_room.getNnSeatList());
            }
        }