C# Packet.WriteStringBuffer方法代码示例

        public void Join(Player plr)
        {
            plr.Room = this;
            if (ServerType == EServerType.Game)
            {
                plr.ResetScore();
                plr.State = EPlayerState.Lobby;
            }
            _players.TryAdd(plr.Session.Guid, plr);

            if (ServerType != EServerType.Game) return;

            var ack = new Packet(EGamePacket.SEnterRoomSuccessAck);
            ack.Write(ID);
            ack.Write(MatchKey);
            ack.Write((uint)State);
            ack.Write((uint)TimeState);
            ack.Write(TimeLimit);

            var ts = DateTime.Now - StartTime;
            if(State == EGameRuleState.Waiting || State == EGameRuleState.Result)
                ack.Write((uint)0);
            else
                ack.Write((uint)ts.TotalMilliseconds); // time passed
            ack.Write(ScoreLimit);
            ack.Write(IsFriendly);
            ack.Write(IsBalanced);
            ack.Write(MinLevel);
            ack.Write(MaxLevel);
            ack.Write(EquipLimit);
            ack.Write(IsNoIntrusion);
            plr.Session.Send(ack);

            // Generate unique slot id!
            var slotID = 2;
            while (FindPlayerInSlot(slotID) != null)
                slotID++;
            plr.SlotID = (byte)slotID;

            ack = new Packet(EGamePacket.SIdsInfoAck);
            ack.Write(plr.SlotID);
            ack.Write(TunnelID);
            ack.Write((uint)0);
            plr.Session.Send(ack);

            ack = new Packet(EGamePacket.SPlayerEnteredAck);
            ack.Write((byte)0x00);
            ack.Write((byte)_players.Count);

            foreach (var player in _players.Values)
            {
                ack.Write(player.PrivateIP); // private ip
                ack.Write(player.PrivatePort); // private port
                ack.Write(player.PublicIP); // public ip
                ack.Write(player.PublicPort); // public port
                ack.Write(player.NATUnk);
                ack.Write(player.ConnectionType); // connection type | 6 relay
                ack.Write(player.AccountID);
                ack.Write(player.SlotID);
                ack.Write((uint)0);
                ack.Write((byte)0x01);
                ack.WriteStringBuffer(player.Nickname, 31);
            }
            Broadcast(ack);
        }

        public void Leave(Player plr, byte leaveType = 0)
        {
            Packet ack;
            if (ServerType == EServerType.Game)
            {
                ack = new Packet(EGamePacket.SRoomPlayerLeave);
                ack.Write(plr.AccountID);
                ack.WriteStringBuffer(plr.Nickname, 31);
                ack.Write(leaveType); // leave reason | 1 = kick
                Broadcast(ack);

                ack = new Packet(EGamePacket.SPlayerLeaveAck);
                ack.Write(plr.AccountID);
                ack.Write(plr.SlotID);
                Broadcast(ack);
            }

            Player tmp;
            if (!_players.TryRemove(plr.Session.Guid, out tmp)) return;
            plr.IsReady = false;
            plr.State = EPlayerState.Lobby;
            plr.SlotID = 0;
            plr.Room = null;
            plr.Team = ETeam.Neutral;
            plr.GameMode = EPlayerGameMode.Normal;
            plr.ResetScore();

            if (_players.Count == 0)
            {
                Room roomTEMP;
                RoomCollection.TryRemove(TunnelID, out roomTEMP);

                if (Channel == null || ServerType != EServerType.Game) return;
                ack = new Packet(EGamePacket.SDisposeRoomAck);
                ack.Write(ID);
                Channel.Broadcast(ack);
                return;
            }

            if (ServerType != EServerType.Game) return;
            if (MasterID == plr.AccountID) // master left, we need a new one
            {
                MasterID = _players.First().Value.AccountID;
                ack = new Packet(EGamePacket.SRoomChangeRefereeAck);
                ack.Write(MasterID);
                Broadcast(ack);

                ack = new Packet(EGamePacket.SRoomChangeMasterAck);
                ack.Write(MasterID);
                Broadcast(ack);
            }

            if (State == EGameRuleState.Playing && ( (CountInTeam(ETeam.Alpha) == 0 || CountInTeam(ETeam.Beta) == 0) 
                || (CountInTeamPlaying(ETeam.Alpha) == 0 || CountInTeamPlaying(ETeam.Beta) == 0) ))
                BeginResult();
        }

        private void HandleRemoveDeny(TcpSession session, Packet p)
        {
            var accID = p.ReadUInt64();
            var nickname = p.ReadCStringBuffer(31);
            //_logger.Debug("-C_REMOVE_DENY_REQ- ID: {0} Nickname: {1}", accID, nickname);

            Player plr;
            if (!_players.TryGetValue(session.Guid, out plr))
            {
                session.StopListening();
                return;
            }

            var ack = new Packet(EChatPacket.SRemoveDenyAck);
            if (plr.DenyList.ContainsKey(accID))
            {
                plr.DenyList.Remove(accID);
                GameDatabase.Instance.RemoveDeny(plr.AccountID, accID);
                ack.Write((byte)EDenyResult.OK);
            }
            else
            {
                ack.Write((byte)EDenyResult.Failed2);
            }

            ack.Write(accID);
            ack.WriteStringBuffer(nickname, 31);
            session.Send(ack);

            SendDenyList(plr);
        }

 private static void HandleLoginRequest(TcpSession session, Packet p)
 {
     var serverList = AuthDatabase.Instance.GetServerList();
     var ack = new Packet(EAuthPacket.SServerlistAck);
     ack.Write((byte)serverList.Count);
     foreach (var server in serverList)
     {
         ack.Write(server.ID);
         ack.Write(server.Type);
         ack.WriteStringBuffer(server.Name, 40);
         ack.Write(server.PlayersOnline);
         ack.Write(server.PlayerLimit);
         ack.Write(server.IP.GetAddressBytes());
         ack.Write(server.Port);
     }
     session.Send(ack);
 }

        private void HandleAddFriend(TcpSession session, Packet p)
        {
            var accID = p.ReadUInt64();
            var nickname = p.ReadCStringBuffer(31);
            //_logger.Debug("-C_ADD_FRIEND_REQ- ID: {0} Nickname: {1}", accID, nickname);

            Player plr;
            if (!_players.TryGetValue(session.Guid, out plr))
            {
                session.StopListening();
                return;
            }

            var ack = new Packet(EChatPacket.SAddFriendAck);
            ack.Write(accID);

            var plrToRequest = _players.GetPlayerByID(accID);
            if (plrToRequest == null)
            {
                ack.Write((byte)EAddFriendResult.DoenstExist);
            }
            else
            {
                var friend = plr.FriendList.FirstOrDefault(f => f.ID == accID);
                if (friend == null)
                {
                    plr.FriendList.Add(new Friend() { ID = accID, Nickname = nickname, Accepted = false });
                    GameDatabase.Instance.AddFriend(plr.AccountID, accID, nickname);

                    SendBRSFriendNotify(plr, plrToRequest, EFriendNotify.Request);

                    ack.Write((byte)EAddFriendResult.MadeRequest);
                }
                else
                {
                    if (friend.Accepted)
                        ack.Write((byte)EAddFriendResult.AlreadyInList);
                    else
                        ack.Write((byte)EAddFriendResult.AlreadyRequested);
                }
            }

            ack.WriteStringBuffer(nickname, 31);
            session.Send(ack);
        }

        private void HandleChannelListRequest(TcpSession session, Packet p)
        {
            //_logger.Debug("-C_CHANLIST_REQ-");

            var ack = new Packet(EChatPacket.SChannelListAck);
            ack.Write((uint)_channels.Count);
            foreach (var chan in _channels.Values)
            {
                ack.Write((byte)chan.ID); // unk
                ack.Write((uint)chan.ID); // id??
                ack.WriteStringBuffer(chan.Name, 21, Encoding.ASCII);
            }
            session.Send(ack);
        }

 private static void SendDenyList(Player plr)
 {
     var ack = new Packet(EChatPacket.SDenyListAck);
     ack.Write((uint)plr.DenyList.Count);
     foreach (var entry in plr.DenyList)
     {
         ack.Write(entry.Key);
         ack.WriteStringBuffer(entry.Value, 31);
     }
     plr.Session.Send(ack);
 }

//.........这里部分代码省略.........

                for (var j = 0; j < 3; j++)
                {
                    for (var n = 0; n < 3; n++)
                    {
                        ack.Write((byte)n);
                        ack.Write(character.Weapons[n]);
                    }

                    ack.Write((byte)0);
                    ack.Write(character.Skill);
                }

                for (var j = 0; j < 7; j++)
                {
                    ack.Write((byte)j);
                    ack.Write(character.Clothes[j]);
                }

                session.Send(ack);
            }

            #endregion

            #region Inventory

            ack = new Packet(EGamePacket.SInventoryAck);
            ack.Write((uint)player.Inventory.Count);
            foreach (var item in player.Inventory)
            {
                ack.Write(item.ID);
                ack.Write(item.Category);
                ack.Write(item.SubCategory);
                ack.Write(item.ItemID);
                ack.Write(item.ProductID);
                ack.Write(item.EffectID);
                ack.Write(item.SellPrice);
                ack.Write(item.PurchaseTime);
                ack.Write(item.ExpireTime);
                ack.Write(item.Energy);
                ack.Write(item.TimeLeft);
            }
            session.Send(ack);

            #endregion

            ack = new Packet(EGamePacket.SResultAck);
            ack.Write((uint)0x27);
            session.Send(ack);

            #region Account info

            ack = new Packet(EGamePacket.SBeginAccountInfoAck);
            ack.Write((byte)0x00);
            ack.Write((byte)player.Level);
            ack.Write((uint)(player.CalculateTotalEXP() + player.EXP));
            ack.Write((uint)0); // points??
            ack.Write((uint)(player.TutorialCompleted ? 3 : 0));
            ack.WriteStringBuffer(player.Nickname, 31);
            ack.Write((uint)0); // unk

            // dm stuff
            ack.Write(player.DMStats.Won); // wins?
            ack.Write(player.DMStats.Lost); // loses??
            ack.Write((uint)player.DMStats.CalculateWinRate() >> 1);
            ack.Write((uint)0);
            ack.Write((uint)0);
            ack.Write((uint)0);
            ack.Write((uint)0);
            ack.Write((uint)0);
            ack.Write((uint)0);

            // td score stuff
            ack.Write(player.TDStats.CalculateWinRate()); // wins??
            ack.Write(0); // loses?
            ack.Write(player.TDStats.TotalTouchdowns);
            ack.Write(20 * player.TDStats.TotalMatches);
            ack.Write(player.TDStats.TotalTouchdownAssists);
            ack.Write(player.TDStats.TotalKills);
            ack.Write(player.TDStats.TotalKillAssists);
            ack.Write(player.TDStats.TotalOffense);
            ack.Write(player.TDStats.TotalOffenseAssists);
            ack.Write(player.TDStats.TotalDefense);
            ack.Write(player.TDStats.TotalDefenseAssists);
            ack.Write(player.TDStats.TotalRecovery);

            ack.Write((uint)0); // Total / x / 2 ???
            ack.Write((uint)0); // unk, nothing happens
            ack.Write((uint)0); // super increase for total score??
            ack.Write((uint)0); // total score goes to 0??
            ack.Write((uint)0); // unk, nothing happens
            ack.Write((uint)0); // unk, nothing happens
            session.Send(ack);

            #endregion

            ack = new Packet(EGamePacket.SResultAck);
            ack.Write((uint)0x11);
            session.Send(ack);
        }

 private void SendRoomList(TcpSession session)
 {
     var ack = new Packet(EGamePacket.SRoomListAck);
     ack.Write((ushort)Rooms.Count);
     foreach (var room in Rooms.Values)
     {
         ack.Write(room.ID);
         ack.Write(room.GetConnectingCount()); //connecting people count
         ack.Write((byte)room.Players.Count);
         ack.Write((byte)room.State);
         ack.Write(room.GetPing()); // ping
         ack.Write(room.MatchKey);
         ack.WriteStringBuffer(room.Name, 31);
         ack.Write(room.PublicType); // has pw
         ack.Write(room.TimeLimit);
         ack.Write(room.ScoreLimit);
         ack.Write(room.IsFriendly);
         ack.Write(room.IsBalanced);
         ack.Write(room.MinLevel);
         ack.Write(room.MaxLevel);
         ack.Write(room.EquipLimit);
         ack.Write(room.IsNoIntrusion);
     }
     session.Send(ack);
 }

        private void HandlePlayerEntered(TcpSession session, Packet p)
        {
            //_logger.Debug("-SC_PLAYER_ENTERED-");

            Player player;
            if (!Players.TryGetValue(session.Guid, out player))
            {
                session.StopListening();
                return;
            }

            var room = player.Room;
            if (room == null)
                return;

            var ack = new Packet(EGamePacket.SRoomChangeRefereeAck);
            ack.Write(room.MasterID);
            session.Send(ack);

            ack = new Packet(EGamePacket.SRoomChangeMasterAck);
            ack.Write(room.MasterID);
            session.Send(ack);

            var numAlpha = room.CountInTeam(ETeam.Alpha);
            var numBeta = room.CountInTeam(ETeam.Beta);

            if (numAlpha < numBeta)
                player.Team = ETeam.Alpha;
            else if (numAlpha > numBeta)
                player.Team = ETeam.Beta;
            else
                player.Team = ETeam.Alpha;

            ack = new Packet(EGamePacket.SCRoomPlayerEnter);
            ack.Write(player.AccountID);
            ack.Write((byte)player.Team);
            ack.Write((byte)player.GameMode); // 1 normal, 2 specate
            ack.Write((uint)player.CalculateTotalEXP()); // exp
            ack.WriteStringBuffer(player.Nickname, 31);
            room.Broadcast(ack);

            room.BroadcastBriefing();
        }

        private void HandleCreateRoom(TcpSession session, Packet p)
        {
            Player player;
            if (!Players.TryGetValue(session.Guid, out player))
            {
                session.StopListening();
                return;
            }
            if (player.Channel == null || player.PublicIP == 0)
                return;

            var room = new Room(Rooms);
            var roomID = Rooms.CreateRoomID(player.Channel.ID);
            var tunnelID = Rooms.CreateTunnelID();

            room.MasterID = player.AccountID;
            room.ID = roomID;
            room.TunnelID = tunnelID;
            room.Channel = player.Channel;
            room.Name = p.ReadCStringBuffer(31);
            room.MatchKey = p.ReadBytes(4);
            room.TimeLimit = p.ReadByte();
            room.TimeLimit *= 60 * 1000;
            room.ScoreLimit = p.ReadByte();
            room.Unk = p.ReadInt32();
            room.Password = p.ReadUInt32();
            room.IsFriendly = p.ReadBoolean();
            room.IsBalanced = p.ReadBoolean();
            room.MinLevel = p.ReadByte();
            room.MaxLevel = p.ReadByte();
            room.EquipLimit = p.ReadByte();
            room.IsNoIntrusion = p.ReadBoolean();
            room.State = EGameRuleState.Waiting;

            var cont = _pluginManager.OnCreateRoom(player, room);
            Packet ack;
            //_logger.Debug("-CCreateRoom- MapID: {0} Mode: {1}", room.MapID, (int)room.GameRule);

            if (!GameDatabase.Instance.IsValidMapID(room.MapID))
            {
                Logger.Error("-CCreateRoom HAX- NOT ALLOWED MapID: {0} Mode: {1}", room.MapID, (int)room.GameRule);
                ack = new Packet(EGamePacket.SResultAck);
                ack.Write((uint)EServerResult.FailedToRequestTask);
                session.Send(ack);
                return;
            }

            if (room.GameRule != EGameRule.Touchdown && room.GameRule != EGameRule.Deathmatch && room.GameRule != EGameRule.Survival && cont)
            {
                ack = new Packet(EGamePacket.SResultAck);
                ack.Write((uint)EServerResult.FailedToRequestTask);
                session.Send(ack);
                return;
            }
            Rooms.TryAdd(tunnelID, room);


            ack = new Packet(EGamePacket.SDeployRoomAck);
            ack.Write(room.ID);
            ack.Write(room.MatchKey);
            ack.Write((byte)room.State);
            ack.Write(room.GetPing()); 
            ack.WriteStringBuffer(room.Name, 31);
            ack.Write(room.PublicType);
            ack.Write(room.TimeLimit);
            ack.Write(room.ScoreLimit);
            ack.Write(room.IsFriendly);
            ack.Write(room.IsBalanced);
            ack.Write(room.MinLevel);
            ack.Write(room.MaxLevel);
            ack.Write(room.EquipLimit);
            ack.Write(room.IsNoIntrusion);

            player.Channel.Broadcast(ack);

            room.Join(player);
        }