C# GameClient.Send方法代码示例

        public static void OnCharacterCreate(GameClient client, ClientHeroCreatePacket packet)
        {
            Logger.Instance.Info("Attempting to create hero with name {0}", packet.Name);
            bool heroExists;

            using (var context = new GameDatabaseContext())
            {
                // We try to load a hero with a similar name to see if they exist
                heroExists = context.Characters.Any(x => x.Name.ToUpper() == packet.Name.ToUpper());
            }

            if (heroExists)
            {
                client.Send(new ServerHeroCreateResponsePacket(HeroStatus.Invalid));
                return;
            }

            // Create a hero and attach it if it dosen't exist yet

            var hero = new UserHero(client.Account, 0, 0, 0, packet.Name);

            // Save our hero into the database
            using (var context = new GameDatabaseContext())
            {
                context.Accounts.Attach(client.Account);
                context.Entry(client.Account).Collection(a => a.Heroes).Load();
                client.Account.Heroes.Add(hero);
                context.SaveChanges();
            }

            client.Send(new ServerHeroCreateResponsePacket(HeroStatus.OK));

            SendHeroList(client);
        }

 public static void Finish(GameClient Client)
 {
     NpcDialog* Packet = PacketHelper.NpcPacket();
     Packet->OptionType = NpcOptionType.Finish;
     Client.Send(Packet, Packet->Size);
     Memory.Free(Packet);
 }

 public static void Text(GameClient Client, string Text)
 {
     NpcDialog* Packet = PacketHelper.NpcPacket(Text);
     Packet->OptionType = NpcOptionType.Dialogue;
     Client.Send(Packet, Packet->Size);
     Memory.Free(Packet);
 }

 public static void Option(GameClient Client, byte OptionID, string Text)
 {
     NpcDialog* Packet = PacketHelper.NpcPacket(Text);
     Packet->OptionType = NpcOptionType.Option;
     Packet->OptionID = OptionID;
     Client.Send(Packet, Packet->Size);
     Memory.Free(Packet);
 }

 public static void Avatar(GameClient Client, ushort ID)
 {
     NpcDialog* Packet = PacketHelper.NpcPacket();
     Packet->OptionType = NpcOptionType.Avatar;
     Packet->Extra = ID;
     Client.Send(Packet, Packet->Size);
     Memory.Free(Packet);
 }

        public static void OnStorageDropRequest(GameClient client, ClientDropStorageRequestPacket packet)
        {
            var hero = client.HeroEntity;

            for (int i = 0; i < packet.Amount; i++)
                hero.Backpack.RemoveSingleAt(packet.SlotId);

            var outboundPacket = new ServerSendHeroStoragePacket(hero.Backpack, StorageType.Inventory);
            client.Send(outboundPacket);
        }

        public static void OnCharacterSelect(GameClient client, ClientHeroSelectPacket packet)
        {
            // Get the hero the user wanted
            var hero = client.Account.Heroes.FirstOrDefault(x => x.Id == packet.HeroId);

            if (hero == null)
            {
                var response = new ServerHeroSelectResponsePacket(HeroStatus.Invalid);
                client.Send(response);
            }
            else
            {
                client.SelectedHero = hero; //TODO: remove and use gameobject hero

                var response = new ServerHeroSelectResponsePacket(HeroStatus.OK);
                client.Send(response);

                var zone = ZoneManager.Current.FindZone(hero.ZoneName);

                zone.OnClientEnter(client, hero);
            }
        }

        public static void OnLoginRequest(GameClient client, ClientLoginRequestPacket packet)
        {
            Logger.Instance.Info("LoginHandler.OnLoginRequest", client, packet);

            UserAccount account;

            bool loginSuccessful = AuthenticationProvider.Authenticate(packet.Username, packet.Password, out account);

            if (!loginSuccessful)
            {
                client.Send(new ServerLoginResponsePacket(LoginStatus.InvalidCredentials));
                return;
            }

            if (account.IsOnline)
            {
                client.Send(new ServerLoginResponsePacket(LoginStatus.AlreadyLoggedIn));
                return;
            }

            client.Account = account;

            using (var context = new GameDatabaseContext())
            {
                context.Accounts.Attach(account);

                account.IsOnline = true;

                context.SaveChanges();

                // Load heroes
                context.Entry(account).Collection(a => a.Heroes).Load();
            }

            client.Send(new ServerLoginResponsePacket(LoginStatus.OK));

            HeroSelectionHandler.SendHeroList(client);
        }

        public static void OnPlayerDialogLinkSelection(GameClient client, ClientDialogLinkSelectionPacket packet)
        {
            var player = client.HeroEntity;

            if (player == null)
                return;

            // You have to be near the NPC to actually interact with it
            var interactable = GetNearestInteractable(player);

            if(interactable != null)
                player.Zone.GetGameSystem<DialogService>().AdvanceDialog(player, interactable, packet.LinkId);
            else
                client.Send(new ServerSendGameMessagePacket(GameMessage.InteractableTooFar));
        }

        public static void OnStorageSlotMoveRequest(GameClient client, ClientStorageMoveSlotPacket packet)
        {
            var hero = client.HeroEntity;

            bool moveSuccessful = false;

            switch (packet.StorageType)
            {
                case StorageType.Inventory:
                    moveSuccessful = hero.Backpack.MoveTo(packet.SourceSlot, packet.DestSlot);
                    break;
            }

            // Send a full inventory update to the client
            var outboundPacket = new ServerSendHeroStoragePacket(hero.Backpack, packet.StorageType);
            client.Send(outboundPacket);
        }

        public static void OnPlayerAcceptQuest(GameClient client, ClientAcceptQuestPacket packet)
        {
            var player = client.HeroEntity;
            var result = new ServerQuestAcceptResultPacket(false);

            // We need to query the surrounding NPCs to see if they can give us the quest we need
            var quest = FindQuestInZoneOrReturnNull(player.Zone, packet.QuestId);

            if (quest != null)
            {
                // Give the player the quest if it's at all possible
                if (QuestManager.Instance.CanPlayerGetQuest(quest, player))
                {
                    QuestManager.Instance.GivePlayerQuest(quest, player);
                    result.Succeeded = true;
                }
            }

            // Notify the client
            client.Send(result);
        }

        private void InternalProcess(GameClient Client, byte[] Packet)
        {
            fixed (byte* pPacket = Packet)
            {
                ushort *Size = (ushort*)(pPacket + 0);
                ushort* Type = (ushort*)(pPacket + 2);

                if (*Size != Packet.Length)
                {
                    SizeMismatch(Client, *Size, Packet);
                    return;
                }

                Kernel.HexDump(Packet, "Client -> Server");

                IPacketProcessor processor = null;
                switch (*Type)
                {
                    case 0x3E9: processor = new CreateCharacterProcessor(Database); break;
                    case 0x3EC: processor = new ChatProcessor(Database, CommandProcessor, NpcScriptEngine); break;
                    case 0x3ED: processor = new MovementProcessor(Database); break;
                    case 0x3F1: processor = new ItemUsageProcessor(Database); break;
                    case 0x3F2: processor = new GeneralDataProcessor(Database); break;
                    case 0x3FE: processor = new AttackProcessor(Database); break;
                    case 0x41C: processor = new LoginTransferProcessor(Database); break;
                    case 0x7EF:
                    case 0x7F0:
                        processor = new NpcProcessor(Database, NpcScriptEngine);
                        break;
                    default:
                        Client.Send(Packet);
                        break;
                }

                if (processor != null)
                {
                    processor.Execute(Client, pPacket);
                }
            }
        }

        public static void OnCharacterSelect(GameClient client, ClientHeroSelectPacket packet)
        {
            // Ensure this is a valid action
            bool actionCanBePerformed = client.Account.IsOnline && client.HeroEntity == null;

            if (!actionCanBePerformed)
                return;

            // Get the hero the user wanted
            UserHero hero = client.Account.Heroes.FirstOrDefault();

            if (hero == null)
            {
                var response = new ServerHeroSelectResponsePacket(HeroStatus.Invalid);
                client.Send(response);
            }
            else
            {

                using (var context = new GameDatabaseContext())
                {
                    context.Characters.Attach(hero);
                    context.Entry(hero).Collection(a => a.Skills).Load();
                    context.Entry(hero).Collection(a => a.Inventory).Load();
                    context.Entry(hero).Collection(a => a.QuestInfo).Load();
                    context.Entry(hero).Collection(a => a.Flags).Load();

                    // Load up our set of requirements from the table
                    foreach (var x in hero.QuestInfo)
                        context.Entry(x).Collection(a => a.RequirementProgress).Load();

                    context.Entry(hero).Collection(a => a.Equipment).Load();
                }

                // Create an object and assign it the world if everything is okay
                var heroObject = GameObjectFactory.CreateHero(hero, client);
                client.HeroEntity = heroObject;

                var zone = ZoneManager.Instance.FindZone(hero.ZoneId);

                if (zone != null)
                {
                    // Create a response and alert the client that their selection is okay
                    var response = new ServerHeroSelectResponsePacket(HeroStatus.OK);
                    client.Send(response);

                    // Here, we should queue the player for login

                    Logger.Instance.Info("{0} has entered the game.", hero.Name);
                    zone.QueueLogin(heroObject);

                    // Add to global manager
                    ChatManager.Current.Global.Join(client);

                }
                else
                {
                    var response = new ServerHeroSelectResponsePacket(HeroStatus.Unavailable);
                    client.Send(response);

                    Logger.Instance.Error("{0} attempted to enter the game but could not be loaded.", hero.Name);
                }

            }
        }

 public void Join(GameClient client)
 {
     client.Send(new ServerJoinChannelPacket(Id, Type, null));
     Clients.Add(client);
 }

        public static void SendHeroList(GameClient client)
        {
            var list = new List<HeroInfo>();

            foreach (UserHero hero in client.Account.Heroes)
            {
                var info = new HeroInfo();
                info.HeroId = hero.UserHeroId;
                info.Name = hero.Name;
                list.Add(info);
            }

            client.Send(new ServerHeroListPacket(list));
        }