public static async Task OnPlayerMovePrototype(PacketHandlerContext c)
        {
            var request   = new MSG_MOVE_GENERIC(c.Packet, c.Client.Build);
            var character = c.GetCharacter();

            // Always trust the client (for now..)
            character.Position.X           = request.MapX;
            character.Position.Y           = request.MapY;
            character.Position.Z           = request.MapZ;
            character.Position.Orientation = request.MapO;

            foreach (var client in c.World.Connections)
            {
                if (!client.IsInWorld)
                {
                    continue;
                }
                if (client.CharacterId == c.Client.CharacterId)
                {
                    continue;
                }

                // Put that in a queue and dont await it?
                await client.SendPacket(new MovementUpdate(character, request, c.Opcode, client.Build));
            }
        }
示例#2
0
    public static Task OnZoneUpdate(PacketHandlerContext c)
    {
        var request = new CMSG_ZONEUPDATE(c.Packet);

        c.Client.Log($"{c.Client.Player.Name} entered {request.NewZone}");
        c.GetCharacter().Position.Zone = request.NewZone;
        return(Task.CompletedTask);
    }
        public static async Task GroupInvite(PacketHandlerContext c)
        {
            var request   = new CMSG_GROUP_INVITE(c.Packet);
            var recipient = c.GetCharacter(request.Membername);

            if (recipient is null)
            {
                c.Client.Log($"Could not find player {request.Membername}", LogLevel.Warning);
                return; // TODO Send response to sender
            }

            var recipientClient = c.World.Connections.SingleOrDefault(c => c.CharacterId == recipient.Id);

            if (recipientClient is null)
            {
                // This should only rarely happen -> critical
                c.Client.Log($"Could not find WorldClient of player {request.Membername}", LogLevel.Critical);
                return; // TODO Send response to sender
            }

            await recipientClient.SendPacket(new SMSG_GROUP_INVITE(c.GetCharacter().Name));
        }
示例#4
0
        public static async Task OnMessageChat(PacketHandlerContext c)
        {
            var request = new CMSG_MESSAGECHAT(c.Packet);

            // debugging stuff :D
            if (request.Message.StartsWith(".spawn"))
            {
                var spawnId  = int.Parse(request.Message.Split(" ")[1]);
                var creature = new Creature {
                    Model = spawnId, Position = c.GetCharacter().Position.Copy()
                };
                await c.World.SpawnCreature(creature);
            }
        }
示例#5
0
    public static async Task OnMessageChat(PacketHandlerContext c)
    {
        var request = new CMSG_MESSAGECHAT(c.Packet);

        // debugging stuff :D
        if (request.Message == ".update")
        {
            if (c.IsVanilla())
            {
                await c.Client.SendPacket(SMSG_UPDATE_OBJECT_VANILLA.UpdateValues(c.World.Creatures));
            }
            return;
        }
        if (request.Message.StartsWith(".spawn"))
        {
            var spawnId  = int.Parse(request.Message.Split(" ")[1]);
            var creature = new Creature {
                Model = spawnId, Position = c.GetCharacter().Position.Copy()
            };
            await c.World.SpawnCreature(creature);
        }
    }
示例#6
0
    public static async Task OnPlayerLogin(PacketHandlerContext c)
    {
        var request   = new CMSG_PLAYER_LOGIN(c.Packet);
        var character = c.GetCharacter(request.CharacterID);
        var account   = c.AccountService.GetAccount(c.Client.Identifier);

        // Login with a deleted character or a character from another account.
        // TODO: Split for different log messages.
        if (character is null || !account.Characters.Contains(character.Id))
        {
            c.Client.Log(
                $"{account.Identifier} tried to login with a deleted character or a character from another account.",
                LogLevel.Warning);
            return;
        }

        c.Client.Log($"Player logged in with char {character.Name}");

        if (c.IsTBC())
        {
            await c.SendPacket <MSG_SET_DUNGEON_DIFFICULTY>();
        }

        await c.Client.SendPacket(new SMSG_LOGIN_VERIFY_WORLD(character));

        await c.SendPacket <SMSG_ACCOUNT_DATA_TIMES>();

        if (c.IsTBC())
        {
            await c.SendPacket <SMSG_FEATURE_SYSTEM_STATUS>();
        }

        await c.Client.SendPacket(new SMSG_EXPECTED_SPAM_RECORDS(Enumerable.Empty <string>()));

        if (c.IsVanilla())
        {
            await c.Client.SendPacket(new SMSG_MESSAGECHAT(character.Id, MessageOfTheDay));
        }
        else if (c.IsTBC())
        {
            await c.Client.SendPacket(new SMSG_MOTD(MessageOfTheDay));
        }

        // await args.Client.SendPacket(new SMSG_NAME_QUERY_RESPONSE(character, args.Client.Build));
        // if (GUILD) -> SMSG_GUILD_EVENT

        if (character.Stats.Life == 0)
        {
            await c.SendPacket <SMSG_CORPSE_RECLAIM_DELAY>();
        }

        await c.SendPacket <SMSG_SET_REST_START>();

        await c.Client.SendPacket(new SMSG_BINDPOINTUPDATE(character));

        await c.SendPacket <SMSG_TUTORIAL_FLAGS>();

        if (c.IsTBC())
        {
            await c.SendPacket <SMSG_INSTANCE_DIFFICULTY>();
        }

        await c.Client.SendPacket(new SMSG_INITIAL_SPELLS(character.Spells));

        // SMSG_SEND_UNLEARN_SPELLS
        await c.Client.SendPacket(new SMSG_ACTION_BUTTONS(character.ActionBar));

        await c.Client.SendPacket(new SMSG_INITIALIZE_FACTIONS(ClientBuild.Vanilla)); // BUG??

        await c.SendPacket <SMSG_LOGIN_SETTIMESPEED>();

        // await args.Client.SendPacket(new SMSG_TRIGGER_CINEMATIC(CinematicID.NightElf));

        c.Client.CharacterId = character.Id;
        await c.Client.SendPacket(SMSG_UPDATE_OBJECT.CreateOwnPlayerObject(character, c.Client.Build, out var player));

        c.Client.Player = player;

        // TODO: Implement for TBC
        if (c.IsVanilla())
        {
            // Initially spawn all creatures
            foreach (var unit in c.World.Creatures)
            {
                // TODO: Add range check
                await c.Client.SendPacket(SMSG_UPDATE_OBJECT_VANILLA.CreateUnit(unit));
            }
        }

        await c.World.SpawnPlayer(character, c.Client.Build);

        // if (GROUP) -> SMSG_GROUP_LIST
        // if Vanilla
        //     SMSG_FRIEND_LIST
        //     SMSG_IGNORE_LIST
        // if TBC
        //     SMSG_CONTACT_LIST

        if (c.IsTBC())
        {
            await c.SendPacket <SMSG_TIME_SYNC_REQ>();
        }

        // SMSG_ITEM_ENCHANT_TIME_UPDATE
        // SMSG_ITEM_TIME_UPDATE
        // SMSG_FRIEND_STATUS
    }