Пример #1
0
 //玩家退出房间
 public static bool UserOutRoom(this MatchRoom matchRoom, long userId)
 {
     if (matchRoom.RoomType == RoomType.Match)
     {
         return(true);//随机匹配房间无法退出 只能等待游戏结束 回复成功让玩家回到大厅
     }
     //如果正在游戏接发起投票解散房间
     if (matchRoom.IsGameBeing)
     {
         matchRoom.RommEnterVoteDissolve(userId);//开始投票
         return(false);
     }
     matchRoom.intData = -1;
     //如果是房卡 并且还没开始 就退出房间
     foreach (var player in matchRoom.PlayerInfoDic)
     {
         if (player.Value.User.UserId == userId)
         {
             matchRoom.intData = player.Key;
             matchRoom.PlayerInfoDic.Remove(player.Key);
             matchRoom.BroadcastActorMessage(new Actor_OtherOutRoom()
             {
                 UserId = userId
             });
             break;
         }
     }
     //如果是房主退出房间 直接移除房间
     if (matchRoom.intData == 0)
     {
         Game.Scene.GetComponent <MatchRoomComponent>().RemoveRoom(matchRoom.RoomId);
     }
     else if (matchRoom.intData == -1)
     {
         Log.Error("退出房间玩家不在房间中");
     }
     return(true);
 }
Пример #2
0
 /// <summary>
 /// 离开
 /// </summary>
 /// <param name="client"></param>
 private void Leave(ClientPeer client)
 {
     SingleExecute.Instance.Execute
     (
         delegate()
     {
         if (!userCache.IsOnLine(client))
         {
             return;
         }
         int userId = userCache.GetIdByClient(client);
         //用户 否 匹配
         if (matchCache.IsMatching(userId) == false)
         {
             return;
         }
         //正常操作
         MatchRoom room = matchCache.Leave(userId);
         //广播给房间内
         room.Brocast(OpCode.MATCH, MatchCode.LEAVE_BRO, userId, client);
     }
     );
 }
Пример #3
0
        /// <summary>
        /// 客户端聊天得请求处理
        /// </summary>
        /// <param name="client"></param>
        /// <param name="msg"></param>
        private void Chat(ClientPeer client, string msg)
        {
            SingleExecute.Instance.Execute(() =>
            {
                foreach (var matchCache in matchCaches)
                {
                    if (matchCache.IsMatching(client.Id))
                    {
                        MatchRoom room = matchCache.GetRoom(client.Id);
                        chatDto.Change(client.Id, client.UserName, msg);
                        room.Broadcast(OpCode.Chat, ChatCode.BRO, chatDto);
                    }
                }
                if (fightCache.IsFighting(client.Id) == false)
                {
                    return;
                }

                FightRoom fightRoom = fightCache.GetFightRoomByUserId(client.Id);
                chatDto.Change(client.Id, client.UserName, msg);
                fightRoom.Broadcast(OpCode.Chat, ChatCode.BRO, chatDto);
            });
        }
Пример #4
0
        /// <summary>
        /// 离开匹配队列
        /// </summary>
        /// <param name="clientPeer"></param>
        private void leave(ClientPeer clientPeer)
        {
            SingleExecute.Instance.processSingle(() =>
            {
                if (!UserCache.Instance.IsOnline(clientPeer))
                {
                    return;
                }

                int uid = UserCache.Instance.GetId(clientPeer);
                //用户不在匹配队列
                if (!MatchCache.Instance.IsMatching(uid))
                {
                    return;
                }

                UserModel userModel = UserCache.Instance.GetModelByClientPeer(clientPeer);
                MatchRoom room      = MatchCache.Instance.Leave(uid);
                Console.WriteLine("玩家:" + userModel.Name + "离开匹配房间:" + room.ID);
                //向房间内所有人广播有玩家离开
                room.Broadcast(OpCode.MATCH, MatchCode.LEAVE_BOD, uid);
            });
        }
Пример #5
0
        private void chatRequest(ClientPeer client, int chatType)
        {
            if (userCache.IsOnline(client) == false)
            {
                return;
            }
            int userId = userCache.GetId(client);
            //获取发送者的id userId
            //发送
            ChatDto dto = new ChatDto(userId, chatType);

            //广播给房间内的玩家
            if (matchCache.IsMatching(userId))
            {
                MatchRoom mRoom = matchCache.GetRoom(userId);
                mRoom.Brocast(OpCode.CHAT, ChatCode.SRES, dto);
            }
            if (fightCache.IsFighting(userId))
            {
                FightRoom fRoom = fightCache.GetRoomByUId(userId);
                fRoom.Brocast(OpCode.CHAT, ChatCode.SRES, dto, client);
            }
        }
Пример #6
0
        private void leave(ClientPeer client)
        {
            SingleExecute.Instance.Execute(
                delegate()
            {
                if (!userCache.IsOnline(client))
                {
                    return;
                }

                int userId = userCache.GetId(client);
                if (matchCache.IsMatching(userId) == false)
                {
                    Console.WriteLine("User is not matching!");
                    return;
                }
                MatchRoom room = matchCache.Leave(userId);
                //broadcast to all player ,someone leave
                room.Broadcast(OpCode.MATCH, MatchCode.LEAVE_BROADCAST, userId);

                Console.WriteLine("Some player leave!");
            });
        }
Пример #7
0
        /// <summary>
        /// 客户端发来的准备请求
        /// </summary>
        /// <param name="client"></param>
        /// <param name="roomType"></param>
        private void Ready(ClientPeer client, int roomType)
        {
            SingleExecute.Instance.Execute(() =>
            {
                if (matchCacheList[roomType].IsMatching(client.Id) == false)
                {
                    return;
                }
                MatchRoom room = matchCacheList[roomType].GetRoom(client.Id);
                room.Ready(client.Id);
                room.Broadcase(OpCode.Match, MatchCode.Read_BRO, client.Id);

                //全部都准备了,可以开始游戏了
                if (room.IsAllReady())
                {
                    startFight(room.clientList, roomType);
                    //通知房间内的所有玩家开始游戏了
                    room.Broadcase(OpCode.Match, MatchCode.StartGame_BRO, null);
                    //销毁房间
                    matchCacheList[roomType].DestroyRoom(room);
                }
            });
        }
Пример #8
0
        public int CreateRoom(AceNetFrameWork.ace.UserToken token, SocketModel mes)
        {
            string roomName = mes.getMessage <string>();

            MatchRoom matchRoom = new MatchRoom(token);
            int       playerID  = cache.getId(token);
            string    account   = cache.getAccount(token);
            int       roomID    = atomic.getAndAdd();

            matchRoom.HostID      = playerID;
            matchRoom.hostAccount = account;
            if (matchRoomMap.TryAdd(roomID, matchRoom))
            {
                userMatch.TryAdd(playerID, roomID);
            }
            else
            {
                //如果添加房间失败,则发送失败消息
                Console.WriteLine("无法添加房间");
                write(token, TypeProtocol.TYPE_GAMEHALL_CREQ, 0, GameHallProtocol.GAMEHALL_CREATEROOM_CREQ, 0);
                return(0);
            }
            RoomInfoDTO info = new RoomInfoDTO();

            info.roomID = roomID; info.roomName = roomName; info.roomState = "正在等待"; info.roomOwner = account;
            roomInfoList.Add(info);


            write(token, TypeProtocol.TYPE_GAMEHALL_CREQ, 0, GameHallProtocol.GAMEHALL_CREATEROOM_CREQ, info);

            cache.removeGameHallAccMap(token);//将用户移除出大厅列表 加入到房间列表中
            cache.addToRoomAccMap(token);

            UpdateRoomListToAll();

            return(1);
        }
        protected override void Run(Session session, C2M_GetReconnectionRoomInfo message, Action <M2C_GetReconnectionRoomInfo> reply)
        {
            M2C_GetReconnectionRoomInfo response = new M2C_GetReconnectionRoomInfo();

            try
            {
                MatchRoom matchRoom = MatchRoomComponent.Ins.GetRoomUserIdIn(message.UserId);
                if (matchRoom == null)
                {
                    response.IsGameBeing = false;
                    response.Message     = "房间已经结算";
                    reply(response);
                    return;
                }
                response.IsGameBeing = true;
                if (matchRoom.IsGameBeing)
                {
                    Actor_UserRequestReconnectionRoom m2SUserRequest = new Actor_UserRequestReconnectionRoom();
                    m2SUserRequest.UserId      = message.UserId;
                    m2SUserRequest.UserActorId = matchRoom.GetPlayerInfo(message.UserId).SessionActorId;
                    ActorHelp.SendeActor(matchRoom.GameServeRoomActorId, m2SUserRequest);
                    if (matchRoom.IsVoteDissolveIn)//如果正在投票解散中 补发一条投票结果消息
                    {
                        ActorHelp.SendeActor(m2SUserRequest.UserActorId, matchRoom.VoteDissolveResult);
                    }
                }
                else
                {
                    response.RoomInfos = RoomInfoFactory.Creator(matchRoom);
                }
                reply(response);
            }
            catch (Exception e)
            {
                ReplyError(response, e, reply);
            }
        }
Пример #10
0
        /// <summary>
        /// 用户准备
        /// </summary>
        /// <param name="client"></param>
        private void Ready(ClientPeer client)
        {
            SingleExecute.Instance.Execute(() => {
                if (!user.IsOnLine(client))
                {
                    //不在线
                    return;
                }

                int userId = user.GetId(client);
                if (!match.IsMatching(userId))
                {
                    return;//非法操作 不能准备
                }
                MatchRoom room = match.GetRoom(userId);
                room.Ready(userId);

                //广播消息  准备了 为什么要给自己发,确保服务器收到准备请求 回复消息后 将准备按钮隐藏
                room.Brocast(OpCode.MATCHROOM, MatchRoomCode.READY_BRO, userId);

                Console.WriteLine(string.Format("玩家 : {0}  在房间 :{1} 准备了", user.GetModelByClient(client).name, room.id));

                //是否所有玩家都准备了
                if (room.IsAllUserReady())
                {
                    Console.WriteLine(String.Format("房间 :{0} 开始了战斗。。。", room.id));
                    //开始战斗  调用FightHandler 的开始方法 委托
                    if (FightDelegate != null)
                    {
                        FightDelegate.Invoke(room.uidList);
                    }
                    //通知房间内的玩家 要进行战斗了 群发消息
                    room.Brocast(OpCode.MATCHROOM, MatchRoomCode.START_BRO, null);
                    match.Destroy(room);
                }
            });
        }
Пример #11
0
        /// <summary>
        /// 离开
        /// </summary>
        /// <param name="client"></param>
        private void leave(ClientPeer client)
        {
            SingleExecute.Instance.Execute(
                delegate()
            {
                if (!userCache.IsOnline(client))
                {
                    return;
                }
                int userId = userCache.GetId(client);
                //用户没有匹配 不能退出 非法操作
                if (matchCache.IsMatching(userId) == false)
                {
                    //client.Send(OpCode.MATCH, MatchCode.LEAVE_SRES, -1);
                    return;
                }
                //正常离开
                MatchRoom room = matchCache.Leave(userId);
                //广播给房间内所有人 有人离开了 参数:离开的用户id
                room.Brocast(OpCode.MATCH, MatchCode.LEAVE_BRO, userId);

                Console.WriteLine("有玩家离开匹配房间");
            });
        }
Пример #12
0
        /// <summary>
        /// 进入
        /// </summary>
        /// <param name="client"></param>
        private void enter(ClientPeer client)//, int id)
        {
            SingleExecute.Instance.Execute(
                delegate()
            {
                if (!userCache.IsOnline(client))
                {
                    return;
                }
                int userId = userCache.GetId(client);

                //if (userId != id)
                //    return;

                //如果用户已经在匹配房间等待了 那就无视
                if (matchCache.IsMatching(userId))
                {
                    client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, -1);    //重复加入
                    return;
                }
                //正常进入
                MatchRoom room = matchCache.Enter(userId, client);
                //广播给房间内除了当前客户端的其他用户,有新玩家计入了  参数:新进入的玩家的用户id
                #region 构造一个UserDto  Dto就是针对UI定义的 UI需要什么我们就加什么字段
                UserModel model = userCache.GetModelById(userId);
                UserDto userDto = new UserDto(model.Id, model.Name, model.Been, model.WinCount, model.LoseCount, model.RunCount, model.Lv, model.Exp);
                #endregion
                room.Brocast(OpCode.MATCH, MatchCode.ENTER_BRO, userDto, client);
                //返回给当前客户端 给他房间的数据模型
                MatchRoomDto dto = makeRoomDto(room);
                client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, dto);

                Console.WriteLine("有玩家进入匹配房间");
            }
                );
        }
Пример #13
0
 protected override async void Run(Session session, S2M_RoomDissolve message)
 {
     try
     {
         MatchRoomComponent matchRoomComponent = Game.Scene.GetComponent <MatchRoomComponent>();
         MatchRoom          matchRoom          = matchRoomComponent.GetRoom(message.RoomId);
         if (matchRoom != null)
         {
             if (matchRoom.RoomType == RoomType.Match)
             {
                 await matchRoom.DeductBeans();//扣除豆子
             }
             else if (message.CurrOfficNum <= 1 && message.CurrRoomStateType == RoomStateType.GameIn)
             {
             }
             else
             {
                 Session lobbySession = Game.Scene.GetComponent <NetInnerSessionComponent>().Get(AppType.Lobby);
                 M2S_UserFinishRoomCardGame m2SUserFinishRoom = new M2S_UserFinishRoomCardGame();
                 foreach (var player in matchRoom.PlayerInfoDic)
                 {
                     m2SUserFinishRoom.UserIds.Add(player.Value.User.UserId);
                 }
                 lobbySession.Send(m2SUserFinishRoom); //通知大厅服 这些玩家完成一局游戏
                 //通知大厅 服 玩家完成一局游戏
                 await matchRoom.DeductJewel();        //扣除钻石
             }
         }
         matchRoomComponent.RemoveRoom(message.RoomId);
     }
     catch (Exception e)
     {
         Log.Error(e);
         throw;
     }
 }
Пример #14
0
        //创建房卡匹房间
        public static MatchRoom Create(RepeatedField <int> roomConfigLists, long toyGameId, int roomId, int friendsCircleId, long userJewelNum, IResponse iResponse)
        {
            int  needJeweNumCount = 0;
            int  number           = 0;
            bool isAADeductJewel  = false;

            //效验房间配置正不正确 不正确的值会修改为默认值  会赋值 需要的钻石数 和房间配置人数
            if (!RoomConfigIntended.IntendedRoomConfigParameter(roomConfigLists, toyGameId, ref needJeweNumCount,
                                                                ref number, ref isAADeductJewel))
            {
                iResponse.Message = "房间配置表错误";
                return(null);
            }

            //如果是亲友圈房间亲友圈的 圈主钻石数要大于100
            if (friendsCircleId > 0 && userJewelNum < 100)
            {
                iResponse.Message = "亲友圈主人钻石不足100";
                return(null);
            }
            if (userJewelNum < needJeweNumCount)
            {
                iResponse.Message = "钻石不足";
                return(null);
            }
            MatchRoom       matchRoom  = ComponentFactory.Create <MatchRoom>();
            MatchRoomConfig roomConfig = MatchRoomConfigFactory.Create(number, roomId, toyGameId, roomConfigLists);

            matchRoom.RoomId           = roomId;
            matchRoom.FriendsCircleId  = friendsCircleId;
            matchRoom.RoomConfig       = roomConfig;
            matchRoom.RoomType         = RoomType.RoomCard;
            matchRoom.NeedJeweNumCount = needJeweNumCount;
            matchRoom.IsAADeductJewel  = isAADeductJewel;
            return(matchRoom);
        }
        protected override async void Run(Session session, G2M_JoinMatchRoom message, Action <M2G_JoinMatchRoom> reply)
        {
            M2G_JoinMatchRoom response = new M2G_JoinMatchRoom();

            try
            {
                MatchRoomComponent roomComponent = Game.Scene.GetComponent <MatchRoomComponent>();
                MatchRoom          matchroom     = roomComponent.Get(message.RoomId);

                Unit unit = matchroom.unitComponent.Get(message.UnitId);
                if (unit == null)
                {
                    if (message.UnitId > 0)
                    {
                        unit = EntityFactory.CreateWithId <Unit>(message.UnitId);
                    }
                    else
                    {
                        unit = EntityFactory.Create <Unit>();
                    }


                    unit.RoomID = matchroom.Id;
                    matchroom.unitComponent.Add(unit);
                }
                UnitGateComponent unitGateComponent = unit.GetComponent <UnitGateComponent>();
                if (unitGateComponent != null)
                {
                    Game.Scene.GetComponent <ActorProxyComponent>().Remove(unitGateComponent.GateSessionId);
                    unit.RemoveComponent <UnitGateComponent>();
                    ActorComponent actorComponent = unit.GetComponent <ActorComponent>();
                    await actorComponent.RemoveLocation();

                    unit.RemoveComponent <ActorComponent>();
                }

                unit.AddComponent <UnitGateComponent, long>(message.GateSessionId);
                await unit.AddComponent <ActorComponent, IEntityActorHandler>(new MapUnitEntityActorHandler()).AddLocation();

                //Game.Scene.GetComponent<UnitComponent>().Add(unit);

                Unit[] units = matchroom.unitComponent.GetAll();

                response.UnitIds = new long[units.Length];

                for (int i = 0; i < units.Length; i++)
                {
                    response.UnitIds[i] = units[i].Id;
                }
                Response_RankList retRankList      = new Response_RankList();
                Actor_CreateUnits actorCreateUnits = new Actor_CreateUnits();
                int tmpScore = 100;
                foreach (Unit u in units)
                {
                    actorCreateUnits.Units.Add(new UnitInfo()
                    {
                        UnitId = u.Id, X = (int)(u.Position.X * 1000), Z = (int)(u.Position.Z * 1000)
                    });
                    retRankList.Units.Add(new RankInfo()
                    {
                        Id = u.Id, name = "张三", score = tmpScore
                    });
                    tmpScore -= 5;
                }
                Log.Debug($"{MongoHelper.ToJson(actorCreateUnits)}");
                MessageHelper.Broadcast(actorCreateUnits, units);
                MessageHelper.Broadcast(retRankList, units);
                if (matchroom.Frame > 0)
                {
                    response.AgoFrameMessage       = matchroom.cacheFrameMessage;
                    response.AgoFrameMessage.Frame = matchroom.Frame;
                }

                reply(response);
            }
            catch (Exception e)
            {
                ReplyError(response, e, reply);
            }
        }
Пример #16
0
    public void StartPreparingForPlay()
    {
        //		Debug.Log(PlayerPrefs.GetString("GameType"));
        if(PlayerPrefs.GetString("GameType","Single") == "Network") {
            Network.Disconnect();
        }

        this.matchRoom = GameObject.FindObjectOfType(typeof(MatchRoom)) as MatchRoom;

        this.playingRoomIndex = this.matchRoom.GetComponent<Room>().roomIndex;
        this.playingPlayerNumber = this.matchRoom.transform.GetChildCount();
        this.playingMapID = this.matchRoom.matchMap;
        this.playingMatchType = this.matchRoom.matchType;
        this.playingGUPID = this.playerInfo.GUPID;
        this.playingPlayerID = this.playerInfo.playerID;
        this.playingPlayerCarID = this.playerInfo.GetComponent<CarInsanityPlayer>().selectedCar.ID;
        this.playingCarID = this.playerInfo.GetComponent<CarInsanityPlayer>().selectedCar.carID;
        this.playingPlayerName = this.playerInfo.playerName;
        this.playingIsAI = Convert.ToInt32(this.playerInfo.isAI);

        if(this.playerInfo.GUPID == this.matchRoom.GetComponent<Room>().creator.GUPID) {
            this.playingIsCreator = 1;
        }else{
            this.playingIsCreator = 0;
        }

        StartCoroutine(LoadLevelWithProgress(((Definition.eSceneID)this.playingMapID).ToString()));

        StartCoroutine(CountingElapsedTime());

        //Debug.Log("StartPreparingForPlay");
    }
Пример #17
0
    public void AutoMatchStart(int matchFilterMap, int matchFilterMaxPlayerNumber)
    {
        if(PlayerPrefs.GetString("GameType", "Single") == "Network")
        {
            networkView.RPC("SendToGameLobby_AutoMatch", RPCMode.Server,  this.playerInfo.GUPID, matchFilterMap, matchFilterMaxPlayerNumber);
        }
        else
        {
            matchRoom = CreateMatchRoom(0, "Single", 4, matchFilterMap, "Single", this.playerInfo);

            lobbyController.EnteredMatchRoom();

            JoinMatchRoom(0, "Single", matchFilterMap, "Single", 4, 0, "player", 0, "player", 0);

        //			string carList = PlayerPrefs.GetString("CarList", "0:0:1:POLICE_CAR, 0:0:3:AMBULANCE, 0:0:2:LORRY_TRUCK, 0:0:4:FIRE_FIGHTING_TRUCK, 0:0:5:GARBAGE_TRUCK");
            string carList = PlayerPrefs.GetString("OwnedCarList", "0:0:1:POLICE_CAR:0, 0:0:3:AMBULANCE:0, 0:0:2:LORRY_TRUCK:0, 0:0:4:FIRE_FIGHTING_TRUCK:0, 0:0:5:GARBAGE_TRUCK:0");
            string[] carListArray = carList.Split(',');

            allCarInsanityCarInfo = new List<CarInsanityCarInfo>();

            foreach(string carInfo in carListArray) {

                if(carInfo != ""){
                    string[] carInfoArray = carInfo.Split(':');

                    CarInsanityCarInfo c = new CarInsanityCarInfo();
                    c.ID = Convert.ToInt32(carInfoArray[0]); //ID
                    c.playerID = Convert.ToInt32(carInfoArray[1]); //Player_ID
                    c.carID = Convert.ToInt32(carInfoArray[2]); //Car_ID
                    c.name = carInfoArray[3]; //name
                    c.isTalentOpened = Convert.ToBoolean(Convert.ToInt32(carInfoArray[4])); //isTalentOpened

                    allCarInsanityCarInfo.Add(c);
                }
            }
            for(int i = 1; i < 4; i++)
            {
                JoinMatchRoom(0, "Single", matchFilterMap, "Single", 4, i, "AI" + i.ToString(), 0, "player", 1);

                this.matchRoom.GetCarInsanityPlayer(i).selectedCar = allCarInsanityCarInfo[UnityEngine.Random.Range(0, allCarInsanityCarInfo.Count)];
            }
        }
    }
Пример #18
0
    public MatchRoom CreateMatchRoom(int roomIndex, string roomName, int maxPlayerNumber, int matchMap, string matchType, GameUserPlayer creator)
    {
        matchRoom = GameObject.Instantiate(matchRoomPrefab, Vector3.zero, Quaternion.identity) as MatchRoom;
        matchRoom.matchMap = matchMap;
        matchRoom.matchType = matchType;
        matchRoom.GetComponent<Room>().roomIndex = roomIndex;
        matchRoom.GetComponent<Room>().roomName = roomName;
        matchRoom.GetComponent<Room>().maxPlayerNumber = maxPlayerNumber;
        matchRoom.GetComponent<Room>().creator = creator;

        matchRoom.name = matchRoom.GetComponent<Room>().roomIndex.ToString();
        matchRoom.transform.parent = gameObject.transform;

        return matchRoom;
    }
 //添加亲友圈房间房间
 public static void AddFriendsCircleRoom(this MatchRoomComponent matchRoomComponent, MatchRoom matchRoom)
 {
     if (matchRoom.FriendsCircleId != 0)
     {
         if (matchRoomComponent.FriendsCircleInMatchRoomDic.ContainsKey(matchRoom.FriendsCircleId))
         {
             matchRoomComponent.FriendsCircleInMatchRoomDic[matchRoom.FriendsCircleId].Add(matchRoom);
         }
         else
         {
             matchRoomComponent.FriendsCircleInMatchRoomDic[matchRoom.FriendsCircleId] = new List <MatchRoom>()
             {
                 matchRoom
             };
         }
     }
 }
 //亲友房间结束
 public static void DestroyFriendsCircleRoom(this MatchRoomComponent matchRoomComponent, MatchRoom matchRoom)
 {
     if (matchRoom.FriendsCircleId != 0)
     {
         if (matchRoomComponent.FriendsCircleInMatchRoomDic.ContainsKey(matchRoom.FriendsCircleId))
         {
             if (matchRoomComponent.FriendsCircleInMatchRoomDic[matchRoom.FriendsCircleId].Contains(matchRoom))
             {
                 matchRoomComponent.FriendsCircleInMatchRoomDic[matchRoom.FriendsCircleId].Remove(matchRoom);
             }
         }
     }
 }
Пример #21
0
    public void JoinMatchRoom(int roomIndex, string roomName, int matchMap, string matchType, int maxPlayerNumber, int joinerGUPID, string joinerName, int creatorGUPID, string creatorName, int isAI)
    {
        //lobby sends data of all player that in the match

        GameUserPlayer joiner = GameObject.Instantiate(playerPrefab, Vector3.zero, Quaternion.identity) as GameUserPlayer;
        joiner.GUPID = joinerGUPID;
        joiner.playerName = joinerName;
        joiner.isAI = Convert.ToBoolean(isAI);

        Transform roomTransform = transform.Find(roomIndex.ToString());

        if(roomTransform == null) {

        //			Debug.Log ("matchRoom == null");
            GameUserPlayer creator = GameObject.Instantiate(playerPrefab, Vector3.zero, Quaternion.identity) as GameUserPlayer;
            joiner.GUPID = creatorGUPID;
            joiner.playerName = creatorName;
            joiner.isAI = false;

            matchRoom = CreateMatchRoom(roomIndex, roomName, maxPlayerNumber, matchMap, matchType, creator);

        }

        if(!this.matchRoom.GetComponent<Room>().IsPlayerInRoom(joinerGUPID)) {

            this.matchRoom.PlayerJoin(joiner);
            joiner.transform.parent = matchRoom.transform;

            if(this.matchRoom.IsFull()) {

                StartCoroutine("StartCountDown");
                if(PlayerPrefs.GetString("GameType", "Single") == "Network")
                {
                    //if i m a creator, random choose a car for AI
                    if(this.matchRoom.GetComponent<Room>().IsCreator(this.playerInfo.GUPID)) {
                        foreach(GameUserPlayer u in this.matchRoom.GetComponent<Room>().playersInRoom) {
                            if(u.isAI) {

                                int randomCarForAI = UnityEngine.Random.Range(1, carAvailableKeyList.Count+1);
                                networkView.RPC("SendToGameLobby_CarSelect", RPCMode.Server, this.matchRoom.GetComponent<Room>().roomIndex, u.GUPID, randomCarForAI, 0);
                            }
                        }
                    }
                }
            }

        }else{
        //			Debug.Log("Player "+joinerName+" is in the room");
        }
    }
Пример #22
0
    public void ReceiveByClientPortal_CreateMatchRoom(int gupid, int roomIndex, string roomName, int maxPlayerNumber, int gameMap, string matchType, int p)
    {
        Definition.RPCProcessState resultState = (Definition.RPCProcessState)p;
        if(resultState == Definition.RPCProcessState.SUCCESS) {
            if(this.playerInfo.GUPID == gupid) {

                matchRoom = CreateMatchRoom(roomIndex, roomName, maxPlayerNumber, gameMap, matchType, this.playerInfo);

                lobbyController.EnteredMatchRoom();

            }else{
        //				this.errorMsg = "FAIL. You are not the correct member.";
        //				Debug.Log(errorMsg);
                lobbySceneViewer.CreateMatchErrorSceneSetting();
            }
        }else if(resultState == Definition.RPCProcessState.UNAVAILABLE){

        //			this.errorMsg = "UNAVAILABLE";
        //			Debug.Log(errorMsg);
            lobbySceneViewer.CreateMatchErrorSceneSetting();
        }else if(resultState == Definition.RPCProcessState.PLAYERNOTEXIST){

        //			this.errorMsg = "PLAYERNOTEXIST";
        //			Debug.Log(errorMsg);
            lobbySceneViewer.CreateMatchErrorSceneSetting();
        }else{
        //			Debug.Log(p.ToString());
            lobbySceneViewer.CreateMatchErrorSceneSetting();
        }
    }
Пример #23
0
 //游戏通知匹配服开始游戏了
 public static void GameServeStartGame(this MatchRoom matchRoom, long serveRoomActorId)
 {
     matchRoom.IsGameBeing          = true;//状态改为在游戏中
     matchRoom.GameServeRoomActorId = serveRoomActorId;
 }
Пример #24
0
 //检测可不可以开始游戏
 public static bool DetetionMayStartGame(this MatchRoom matchRoom)
 {
     return(matchRoom.PlayerInfoDic.Count == matchRoom.RoomConfig.GameNumber);
 }
Пример #25
0
 public static void GameServerStartGame(this MatchRoom matchRoom, long serverRoomAId)
 {
     matchRoom.IsInGame             = true;
     matchRoom.GameServeRoomActorId = serverRoomAId;
 }