public static void HandleTextEmote(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
if (!chr.CanMove || !chr.CanInteract) return;
var emote = (TextEmote)packet.ReadUInt32();
packet.SkipBytes(4);
var targetId = packet.ReadEntityId();
var target = chr.Map.GetObject(targetId) as INamed;
if (target != null)
{
SendTextEmote(chr, emote, target);
}
EmoteType animation;
EmoteDBC.EmoteRelationReader.Entries.TryGetValue((int)emote, out animation);
switch (animation)
{
//The client seems to handle these on its own.
case EmoteType.StateSleep:
case EmoteType.StateSit:
case EmoteType.StateKneel:
case EmoteType.StateDance:
chr.EmoteState = animation;
break;
default:
chr.Emote(animation);
break;
}
//todo: Achievement and scripting hooks/events.
}
public static void HandleCancel(IRealmClient client, RealmPacketIn packet)
{
if (client.ActiveCharacter.Duel != null)
{
client.ActiveCharacter.Duel.Finish(DuelWin.Knockout, client.ActiveCharacter);
}
}
public static void AddIgnoreRequest(IRealmClient client, RealmPacketIn packet)
{
string relCharacterName = packet.ReadCString();
RelationMgr.Instance.AddRelation(client.ActiveCharacter, relCharacterName,
string.Empty, CharacterRelationType.Ignored);
}
public static void Accept(IRealmClient client, RealmPacketIn packet)
{
var invitee = client.ActiveCharacter;
var listInviters = RelationMgr.Instance.GetPassiveRelations(invitee.EntityId.Low,
CharacterRelationType.GuildInvite);
var invite = listInviters.FirstOrDefault();
if (invite == null)
return;
Character inviter = World.GetCharacter(invite.CharacterId);
if (inviter == null)
return;
//Removes the guild invite relation between the inviter and invitee
RelationMgr.Instance.RemoveRelation(invite);
var guildMember = inviter.GuildMember;
if (guildMember == null)
return;
var guild = guildMember.Guild;
//Add the invitee to the guild
guild.AddMember(invitee);
}
public static void HandleCreateTicketPacket(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
if (chr.Ticket == null)
{
var map = (MapId)packet.ReadUInt32();
var x = packet.ReadFloat();
var y = packet.ReadFloat();
var z = packet.ReadFloat();
var msg = packet.ReadCString();
var type = (TicketType)packet.ReadUInt32(); // prev. unk0
var unk1 = packet.ReadByte(); // unk1, 1
var unk2 = packet.ReadUInt32(); // unk2, 0
var unk3 = packet.ReadUInt32(); // unk3, 0
var ticket = new Ticket(chr, msg, type);
TicketMgr.Instance.AddTicket(ticket);
chr.Ticket = ticket;
SendCreateResponse(client, TicketInfoResponse.Saved);
}
else
{
SendCreateResponse(client, TicketInfoResponse.Fail);
}
}
public static void HandleRemoveGlyph(IRealmClient client, RealmPacketIn packet)
{
var slot = packet.ReadUInt32();
var chr = client.ActiveCharacter;
chr.RemoveGlyph((byte)slot);
SendTalentGroupList(chr.Talents);
}
public static void HandleJoin(IRealmClient client, RealmPacketIn packet)
{
var roles = packet.ReadUInt32();
packet.SkipBytes(2);
var dungeonsCount = packet.ReadByte();
if (dungeonsCount == 0)
return;
for (byte i = 0; i < dungeonsCount; ++i)
{
// dungeons id/type
var packedDungeon = packet.ReadUInt32();
var id = packedDungeon & 0x00FFFFFF;
var type = packedDungeon & 0xFF000000;
}
byte counter2 = packet.ReadByte();
packet.SkipBytes(counter2); // lua: GetLFGInfoLocal
string comment = packet.ReadCString();
//SendLfgJoinResult();
//SendLfgUpdate();
}
public static void HandleGossipSelectOption(IRealmClient client, RealmPacketIn packet)
{
var targetEntityId = packet.ReadEntityId();
var unknown = packet.ReadUInt32(); // usually Zero, sometimes in the thousands for quest givers, Same as the first int sent in SMSG_GOSSIP_MESSAGE
var selectedOption = packet.ReadUInt32();
string extra = string.Empty;
if (packet.Position < packet.Length)
{
extra = packet.ReadCString();
}
var chr = client.ActiveCharacter;
var worldObject = chr.Region.GetObject(targetEntityId);
if (worldObject == null)
return;
var conversation = chr.GossipConversation;
if (conversation == null || conversation.Speaker != worldObject)
return;
conversation.HandleSelectedItem(selectedOption, extra);
}
public static void NameQueryRequest(IRealmClient client, RealmPacketIn packet)
{
var id = packet.ReadEntityId();
ILivingEntity entity = client.ActiveCharacter;
if (entity.EntityId.Low != id.Low)
{
entity = World.GetNamedEntity(id.Low) as ILivingEntity;
}
if (entity != null)
{
SendNameQueryReply(client, entity);
}
else
{
RealmServer.IOQueue.AddMessage(new Message(() =>
{
var record = CharacterRecord.LoadRecordByEntityId(id.Low);
if (record == null)
{
s_log.Warn("{0} queried name of non-existing Character: " + id, client);
}
else
{
SendNameQueryReply(client, record);
}
}));
}
}
public static void HandleGossipHello(IRealmClient client, RealmPacketIn packet)
{
var targetEntityId = packet.ReadEntityId();
var chr = client.ActiveCharacter;
var target = chr.Region.GetObject(targetEntityId) as Unit;
if (target == null)
return;
if (chr.GossipConversation != null)
{
chr.GossipConversation = null;
}
var menu = target.GossipMenu;
if (menu == null)
return;
if (target is NPC)
{
if (!((NPC)target).CanInteractWith(chr))
{
return;
}
}
else if (!chr.Role.IsStaff)
{
return;
}
chr.OnInteract(target);
var conversation = new GossipConversation(menu, chr, target, menu.KeepOpen);
client.ActiveCharacter.GossipConversation = conversation;
conversation.DisplayCurrentMenu();
}
public static void HandleInstanceReset(IRealmClient client, RealmPacketIn packet)
{
if (client.ActiveCharacter != null && client.ActiveCharacter.HasInstanceCollection)
{
client.ActiveCharacter.Instances.TryResetInstances();
}
}
public static void RemoveFriendRequest(IRealmClient client, RealmPacketIn packet)
{
var relCharId = packet.ReadEntityId();
RelationMgr.Instance.RemoveRelation(client.ActiveCharacter.EntityId.Low, relCharId.Low,
CharacterRelationType.Friend);
}
public static void GroupInviteRequest(IRealmClient client, RealmPacketIn packet)
{
var inviteeName = packet.ReadCString();
var inviter = client.ActiveCharacter;
var group = inviter.Group;
Character invitee;
if (Group.CheckInvite(inviter, out invitee, inviteeName) == GroupResult.NoError)
{
var listInvitees = Singleton<RelationMgr>.Instance.GetRelations(inviter.EntityId.Low,
CharacterRelationType.GroupInvite);
if (group == null || listInvitees.Count < group.InvitesLeft)
{
BaseRelation inviteRelation = RelationMgr.CreateRelation(inviter.EntityId.Low,
invitee.EntityId.Low, CharacterRelationType.GroupInvite);
Singleton<RelationMgr>.Instance.AddRelation(inviteRelation);
// Target has been invited
Group.SendResult(inviter.Client, GroupResult.NoError, inviteeName);
SendGroupInvite(invitee.Client, inviter.Name);
}
}
}
public static void WhoListRequest(IRealmClient client, RealmPacketIn packet)
{
var search = new WhoSearch {
MaxResultCount = WhoList.MaxResultCount,
Faction = client.ActiveCharacter.Faction.Group,
MinLevel = (byte)packet.ReadUInt32(),
MaxLevel = (byte)packet.ReadUInt32(),
Name = packet.ReadCString(),
GuildName = packet.ReadCString(),
RaceMask = (RaceMask2)packet.ReadUInt32(),
ClassMask = (ClassMask2)packet.ReadUInt32()
};
uint zoneCount = packet.ReadUInt32();
if (zoneCount > 0 && zoneCount <= 10)
{
for (int i = 0; i < zoneCount; i++)
search.Zones.Add((ZoneId)packet.ReadUInt32());
}
uint nameCount = packet.ReadUInt32();
if (nameCount > 0 && nameCount <= 10)
{
for (int i = 0; i < nameCount; i++)
search.Names.Add(packet.ReadCString().ToLower());
}
//Performs the search and retrieves matching characters
var characters = search.RetrieveMatchedCharacters();
//Send the character list to the client
SendWhoList(client, characters);
}
public static void HandleDungeonDifficulty(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
if (chr.Map.IsInstance)
{
// Cannot change difficulty while in instance
return;
}
var difficultyIndex = packet.ReadUInt32();
var group = chr.Group;
if (group != null)
{
if (group.Leader.Character != chr)
{
// Only leader can change difficulty
return;
}
}
var instances = chr.Instances;
if (instances.TryResetInstances())
{
if (group != null)
{
group.DungeonDifficulty = difficultyIndex;
}
else
{
chr.DungeonDifficulty = (DungeonDifficulty)difficultyIndex;
}
}
}
public static void GroupAccept(IRealmClient client, RealmPacketIn packet)
{
var invitee = client.ActiveCharacter;
var listInviters = Singleton<RelationMgr>.Instance.GetPassiveRelations(invitee.EntityId.Low,
CharacterRelationType.GroupInvite);
var invite = listInviters.FirstOrDefault();
//Check if we got invited
if (invite == null)
return;
//Removes the group invite relation between the inviter and invitee
RelationMgr.Instance.RemoveRelation(invite);
var inviter = World.GetCharacter(invite.CharacterId);
if (inviter == null)
return;
//If the inviter isnt in a group already we create a new one
var inviterGroup = inviter.Group ?? new PartyGroup(inviter);
//Add the invitee to the group
inviterGroup.AddMember(invitee, true);
}
public static void HandleStopWatchingFaction(IRealmClient client, RealmPacketIn packet)
{
var reputationIndex = (FactionReputationIndex)packet.ReadInt32();
bool isInactive = packet.ReadBoolean();
client.ActiveCharacter.Reputations.SetInactive(reputationIndex, isInactive);
}
public static void HandleLoot(IRealmClient client, RealmPacketIn packet)
{
var objId = packet.ReadEntityId();
var chr = client.ActiveCharacter;
var looter = chr.LooterEntry;
var looted = chr.Region.GetObject(objId);
if (looted != null)
{
looter.Release(); // make sure that the Character is not still looting something else
var loot = looted.Loot;
if (loot == null)
{
SendLootFail(chr, looted);
// TODO: Kneel and unkneel?
}
else if (looter.MayLoot(loot))
{
// we are either already a looter or become a new one
chr.CancelAllActions();
looter.Loot = loot;
SendLootResponse(chr, loot);
}
else
{
SendLootFail(chr, looted);
}
}
}
public static void HandleAction(IRealmClient client, RealmPacketIn packet)
{
var entityId = packet.ReadEntityId();
var chr = client.ActiveCharacter;
var pet = chr.Map.GetObject(entityId) as NPC;
if (pet != null && pet == chr.ActivePet && pet.IsAlive)
{
var record = pet.PetRecord;
if (record != null)
{
var data = (PetActionEntry)packet.ReadUInt32();
switch (data.Type)
{
case PetActionType.SetMode:
// mode
pet.SetPetAttackMode(data.AttackMode);
break;
case PetActionType.SetAction:
// action
var targetAction = data.Action;
pet.SetPetAction(targetAction);
break;
default:
// spell cast
var target = chr.Map.GetObject(packet.ReadEntityId());
pet.CastPetSpell(data.SpellId, target);
break;
}
}
}
}
public static void HandleQuestPOIQuery(IRealmClient client, RealmPacketIn packet)
{
uint count = packet.ReadUInt32();
var questIds = new List<uint>();
for (var i = 0; i < count; i++)
questIds.Add(packet.ReadUInt32());
SendQuestPOIResponse(client, count, questIds);
}
public static void HandleAuctionHello(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
var auctioneerId = packet.ReadEntityId();
var auctioneer = chr.Map.GetObject(auctioneerId) as NPC;
AuctionMgr.Instance.AuctionHello(chr, auctioneer);
}
public static void HandleReportLagTicket(IRealmClient client, RealmPacketIn packet)
{
var type = (TicketReportLagType)packet.ReadUInt32();
var unk0 = packet.ReadUInt32(); // Seems to be always 0
var posX = packet.ReadFloat();
var posY = packet.ReadFloat();
var posZ = packet.ReadFloat();
}
public static void AddFriendRequest(IRealmClient client, RealmPacketIn packet)
{
string relCharacterName = packet.ReadCString();
string note = packet.ReadCString();
RelationMgr.Instance.AddRelation(client.ActiveCharacter, relCharacterName, note,
CharacterRelationType.Friend);
}
public static void HandleDeleteEquipmentSet(IRealmClient client, RealmPacketIn packet)
{
var setGuid = packet.ReadPackedEntityId();
var chr = client.ActiveCharacter;
chr.Inventory.DeleteEquipmentSet(setGuid);
}
public static void HandleAttackStop(IRealmClient client, RealmPacketIn packet)
{
if (client.ActiveCharacter.AutorepeatSpell == null)
{
// ignore when using ranged
client.ActiveCharacter.IsFighting = false;
}
}
public static void SetRelationNoteRequest(IRealmClient client, RealmPacketIn packet)
{
EntityId characterId = packet.ReadEntityId();
string note = packet.ReadCString();
RelationMgr.Instance.SetRelationNote(client.ActiveCharacter.EntityId.Low, characterId.Low,
note, CharacterRelationType.Friend);
}
public static void HandleAccept(IRealmClient client, RealmPacketIn packet)
{
// var flagId = packet.ReadEntityId();
if (client.ActiveCharacter.Duel != null)
{
client.ActiveCharacter.Duel.Accept(client.ActiveCharacter);
}
}
public static void HandleProposeTrade(IRealmClient client, RealmPacketIn packet)
{
var targetGuid = packet.ReadEntityId();
var targetChr = World.GetCharacter(targetGuid.Low);
if (TradeInfo.CheckRequirements(client.ActiveCharacter, targetChr))
TradeInfo.Propose(client.ActiveCharacter, targetChr);
}
public static void HandleRequestVehicleExit(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
var vehicle = chr.Vehicle;
if (vehicle != null)
{
chr.VehicleSeat.ClearSeat();
}
}
public static void HandleSystemStatusPacket(IRealmClient client, RealmPacketIn packet)
{
using (var repPacket = new RealmPacketOut(RealmServerOpCode.SMSG_GMTICKET_SYSTEMSTATUS, 4))
{
// TODO: Add indicator to Account for whether person may use ticket system
repPacket.Write(1);
client.Send(repPacket);
}
}
public static void GetOnMountRequest(IRealmClient client, RealmPacketIn packet)
{
int key = packet.ReadInt32();
if (client.ActiveCharacter.OwnedMounts.ContainsKey(key))
{
client.ActiveCharacter.MountId = key;
}
else
{
Asda2MountHandler.SendCharacterOnMountStatusChangedResponse(client.ActiveCharacter,
Asda2MountHandler.UseMountStatus.Fail);
client.ActiveCharacter.YouAreFuckingCheater("Trying to use not owned Mount.", 30);
}
}
public static void HandleWorldTeleport(IRealmClient client, RealmPacketIn packet)
{
uint time = packet.ReadUInt32();
MapId mapId = (MapId)packet.ReadUInt32();
var pos = packet.ReadVector3();
float orientation = packet.ReadFloat(); // in client specified as degrees
var map = World.GetNonInstancedMap(mapId);
if (map != null)
{
client.ActiveCharacter.TeleportTo(map, ref pos);
}
}
public static void HandleBattlemasterHello(IRealmClient client, RealmPacketIn packet)
{
var bmId = packet.ReadEntityId();
var chr = client.ActiveCharacter;
var bm = chr.Map.GetObject(bmId) as NPC;
if (bm != null &&
bm.NPCFlags.HasFlag(NPCFlags.BattleMaster)
// && bm.CanInteractWith(chr)
)
{
bm.TalkToBattlemaster(chr);
}
}
private static void ReadButton(NPC pet, RealmPacketIn packet)
{
var index = packet.ReadUInt32();
var newAction = (PetActionEntry)packet.ReadUInt32();
var record = pet.PermanentPetRecord;
if (index > record.ActionButtons.Length)
{
return;
}
// TODO: Interpret spell settings (auto-cast etc)
record.ActionButtons[index] = newAction;
}
public static void PopItemFromTradeRequest(IRealmClient client, RealmPacketIn packet)
{
packet.Position += 4;
byte inv = packet.ReadByte();
short cell = packet.ReadInt16();
if (client.ActiveCharacter.Asda2TradeWindow == null)
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to poping items from trade while not trading", 0);
}
else
{
client.ActiveCharacter.Asda2TradeWindow.PopItem(client.ActiveCharacter, inv, cell);
}
}
public static void HandleAuctionListBidderItems(IRealmClient client, RealmPacketIn packet)
{
Character activeCharacter = client.ActiveCharacter;
EntityId id = packet.ReadEntityId();
uint num1 = packet.ReadUInt32();
int num2 = 0;
while (num2 < num1)
{
++num2;
}
NPC auctioneer = activeCharacter.Map.GetObject(id) as NPC;
Singleton <AuctionMgr> .Instance.AuctionListBidderItems(activeCharacter, auctioneer);
}
public static void HandleAuctionSellItem(IRealmClient client, RealmPacketIn packet)
{
Character activeCharacter = client.ActiveCharacter;
EntityId id = packet.ReadEntityId();
int num = (int)packet.ReadUInt32();
EntityId itemId = packet.ReadEntityId();
uint stackSize = packet.ReadUInt32();
uint bid = packet.ReadUInt32();
uint buyout = packet.ReadUInt32();
uint time = packet.ReadUInt32();
NPC auctioneer = activeCharacter.Map.GetObject(id) as NPC;
Singleton <AuctionMgr> .Instance.AuctionSellItem(activeCharacter, auctioneer, itemId, bid, buyout, time,
stackSize);
}
public static void HandleSplitItem(IRealmClient client, RealmPacketIn packet)
{
var inv = client.ActiveCharacter.Inventory;
if (inv.CheckInteract() == InventoryError.OK)
{
var srcBagSlot = (InventorySlot)packet.ReadByte();
var srcSlot = packet.ReadByte();
var destBagSlot = (InventorySlot)packet.ReadByte();
var destSlot = packet.ReadByte();
var amount = packet.ReadByte();
inv.Split(srcBagSlot, srcSlot, destBagSlot, destSlot, amount);
}
}
public static void HandleSetTradeItem(IRealmClient client, RealmPacketIn packet)
{
var trade = client.ActiveCharacter.TradeWindow;
if (trade == null)
{
return;
}
var tradeSlot = packet.ReadByte();
var bag = packet.ReadByte();
var slot = packet.ReadByte();
trade.SetTradeItem(tradeSlot, bag, slot, false);
}
[PacketHandler(RealmServerOpCode.DeleteMailMessage)]//6626
public static void DeleteMailMessageRequest(IRealmClient client, RealmPacketIn packet)
{
var messageId = packet.ReadInt32();//default : 379808Len : 4
if (client.ActiveCharacter.MailMessages.ContainsKey(messageId))
{
var msg = client.ActiveCharacter.MailMessages[messageId];
if (msg != null)
{
client.ActiveCharacter.MailMessages.Remove(messageId);
msg.DeleteLater();
}
}
SendMailMessageDeletedResponse(client, messageId);
}
public static void GetCharecterInfoRequest(IRealmClient client, RealmPacketIn packet)
{
packet.Position -= 4;
Character characterBySessionId = World.GetCharacterBySessionId(packet.ReadUInt16());
if (characterBySessionId == null)
{
client.ActiveCharacter.SendInfoMsg("Character not founded.");
}
else
{
SendCharacterFullInfoResponse(client, characterBySessionId);
SendCharacterRegularEquipmentInfoResponse(client, characterBySessionId);
}
}
//[ClientPacketHandler((RealmServerOpCode.CMSG_AUCTION_SELL_ITEM)]
public static void HandleAuctionSellItem(IRealmClient client, RealmPacketIn packet)
{
var chr = client.ActiveCharacter;
var auctioneerId = packet.ReadEntityId();
var unknown = packet.ReadUInt32();
var itemId = packet.ReadEntityId();
var stackSize = packet.ReadUInt32();
var bid = packet.ReadUInt32();
var buyout = packet.ReadUInt32();
var time = packet.ReadUInt32();
var auctioneer = chr.Map.GetObject(auctioneerId) as NPC;
AuctionMgr.Instance.AuctionSellItem(chr, auctioneer, itemId, bid, buyout, time, stackSize);
}
public static void HandleLearnTalent(IRealmClient client, RealmPacketIn packet)
{
var talentId = (TalentId)packet.ReadUInt32();
var rank = packet.ReadInt32(); // zero-based Rank-mask
var talents = client.ActiveCharacter.Talents;
if (talents.Learn(talentId, rank) == null)
{
return;
}
// send new talent group list
SendTalentGroupList(talents);
}
//[ClientPacketHandler((RealmServerOpCode.CMSG_GAMEOBJECT_QUERY)]
public static void HandleGOQuery(IRealmClient client, RealmPacketIn packet)
{
var entryId = packet.ReadUInt32();
//EntityId goId = packet.ReadEntityId();
if (Loaded)
{
var entry = GetEntry(entryId);
if (entry != null)
{
SendGameObjectInfo(client, entry);
}
}
}
/// <summary>Handles an incoming channel join request</summary>
/// <param name="client">the client the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
public static void HandleJoinChannel(IRealmClient client, RealmPacketIn packet)
{
uint channelId = packet.ReadUInt32();
int num1 = packet.ReadByte();
int num2 = packet.ReadByte();
string name = packet.ReadCString();
string password = packet.ReadCString();
ChatChannelGroup group = ChatChannelGroup.GetGroup(client.ActiveCharacter.Faction.Group);
if (group == null || string.IsNullOrEmpty(name))
{
return;
}
group.GetChannel(name, channelId, true).TryJoin(client.ActiveCharacter, password, false);
}
/// <summary>Handles a request of unmuting a channel member</summary>
/// <param name="client">the client the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
public static void HandleUnMuteRequest(IRealmClient client, RealmPacketIn packet)
{
string channelName = packet.ReadCString();
string targetName = packet.ReadCString();
ChannelMember userMember;
ChannelMember targetMember;
ChatChannel chatChannel = ChatChannel.EnsurePresence(client.ActiveCharacter, channelName,
targetName, out userMember, out targetMember);
if (chatChannel == null)
{
return;
}
chatChannel.SetMuted(userMember, targetMember, false);
}
public static void HandleTaxiStatusQuery(IRealmClient client, RealmPacketIn packet)
{
var vendorId = packet.ReadEntityId();
var chr = client.ActiveCharacter;
var vendor = chr.Map.GetObject(vendorId) as NPC;
if (vendor == null)
{
return;
}
var isActive = chr.GodMode || chr.TaxiNodes.IsActive(vendor.VendorTaxiNode);
SendTaxiNodeStatus(client, vendor.VendorTaxiNode, vendorId, isActive);
}
public static void PrivateShopChatReqRequest(IRealmClient client, RealmPacketIn packet)
{
packet.Position += 22;
string str = packet.ReadAsciiString(client.Locale);
if (client.ActiveCharacter.PrivateShop == null)
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to chat to private shop while not exist shop.", 2);
}
else
{
Locale locale = Asda2EncodingHelper.MinimumAvailableLocale(client.Locale, str);
client.ActiveCharacter.PrivateShop.SendMessage(str, client.ActiveCharacter, locale);
}
}
public static void AtackCharacterRequest(IRealmClient client, RealmPacketIn packet)
{
Character characterBySessionId = World.GetCharacterBySessionId(packet.ReadUInt16());
if (characterBySessionId == null || characterBySessionId == client.ActiveCharacter ||
!client.ActiveCharacter.CanHarm(characterBySessionId))
{
StartAtackResponse(client.ActiveCharacter, characterBySessionId, 0);
}
else
{
client.ActiveCharacter.IsFighting = true;
Asda2SpellHandler.SendSetAtackStateGuiResponse(client.ActiveCharacter);
}
}
/// <summary>Handles an incoming owner set request</summary>
/// <param name="client">the client the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
public static void HandleOwnerChange(IRealmClient client, RealmPacketIn packet)
{
string channelName = packet.ReadCString();
string targetName = packet.ReadCString();
ChannelMember userMember;
ChannelMember targetMember;
ChatChannel chatChannel = ChatChannel.EnsurePresence((IUser)client.ActiveCharacter, channelName,
targetName, out userMember, out targetMember);
if (chatChannel == null)
{
return;
}
chatChannel.MakeOwner(userMember, targetMember);
}
[PacketHandler(RealmServerOpCode.ResurectPet)]//6108
public static void ResurectPetRequest(IRealmClient client, RealmPacketIn packet)
{
var petGuid = packet.ReadInt32(); //default : 68412Len : 4
var invNum = packet.ReadByte(); //default : 2Len : 1
var slot = packet.ReadInt16(); //default : 59Len : 2
if (!client.ActiveCharacter.OwnedPets.ContainsKey(petGuid))
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to resurect not existing pet", 20);
return;
}
var item = client.ActiveCharacter.Asda2Inventory.GetRegularItem(slot);
if (item == null)
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to resurect pet with not existint resurect item.", 10);
return;
}
var pet = client.ActiveCharacter.OwnedPets[petGuid];
if (item.Category == Asda2ItemCategory.PetFoodMeat || item.Category == Asda2ItemCategory.PetFoodVegetable || item.Category == Asda2ItemCategory.PetFoodOil)
{
if (client.ActiveCharacter.Asda2Pet != null)
{
client.ActiveCharacter.Asda2Pet.Feed(item.Template.ValueOnUse / 2);
item.ModAmount(-1);
SendPetResurectedResponse(client, pet, item);
}
else
{
client.ActiveCharacter.SendInfoMsg("You must summon pet to feed.");
}
return;
}
if (item.Category != Asda2ItemCategory.PetResurect)
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to resurect pet with not a resurect item.", 50);
return;
}
if (pet.HungerPrc != 0)
{
client.ActiveCharacter.YouAreFuckingCheater("Trying to resurect alive pet.", 50);
return;
}
pet.HungerPrc = 5;
item.ModAmount(-1);
SendPetResurectedResponse(client, pet, item);
}
public static void HandlePetitionOffer(IRealmClient client, RealmPacketIn packet)
{
var unk = packet.ReadUInt32();
var petitionId = packet.ReadEntityId();
var playerId = packet.ReadEntityId();
var player = World.GetCharacter(playerId.Low);
var petition = PetitionRecord.LoadRecordByItemId(petitionId.Low);
var namePlayer = player.Name;
if (player.Faction != client.ActiveCharacter.Faction)
{
if (petition.Type == PetitionType.Guild)
{
GuildHandler.SendResult(client, GuildCommandId.CREATE, client.ActiveCharacter.Name, GuildResult.NOT_ALLIED);
}
else
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.INVITE, ArenaTeamResult.NOT_ALLIED);
}
return;
}
if (petition.Type == PetitionType.Guild)
{
if (player.IsInGuild)
{
GuildHandler.SendResult(client, GuildCommandId.INVITE, namePlayer, GuildResult.ALREADY_IN_GUILD_S);
return;
}
}
else
{
if (player.ArenaTeamMember[(uint)ArenaMgr.GetSlotByType((uint)petition.Type)] != null)
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, string.Empty, namePlayer, ArenaTeamResult.ALREADY_IN_ARENA_TEAM_S);
return;
}
else if (player.Level < 80)
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, string.Empty, namePlayer, ArenaTeamResult.TARGET_TOO_LOW);
return;
}
}
SendPetitionSignatures(player.Client, client.ActiveCharacter.Inventory.GetItem(petitionId) as PetitionCharter);
}
/// <summary>Handles an incoming player login request.</summary>
/// <param name="client">the Session the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
public static void PlayerLoginRequest(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null || client.ActiveCharacter != null)
{
return;
}
uint charLowId = packet.ReadEntityId().Low;
try
{
Character chr = World.GetCharacter(charLowId);
if (chr != null)
{
if (!chr.IsLoggingOut)
{
LoginHandler.log.Error(WCell_RealmServer.CharacterAlreadyConnected, (object)charLowId,
(object)client.Account.Name);
LoginHandler.SendCharacterLoginFail((IPacketReceiver)client,
LoginErrorCode.CHAR_LOGIN_DUPLICATE_CHARACTER);
}
else
{
chr.Map.AddMessage((IMessage) new Message((Action)(() =>
{
if (!chr.IsInContext)
{
ServerApp <WCell.RealmServer.RealmServer> .IOQueue.AddMessage(
(IMessage) new Message((Action)(() =>
LoginHandler.LoginCharacter(client, charLowId))));
}
else
{
chr.ReconnectCharacter(client);
}
})));
}
}
else
{
LoginHandler.LoginCharacter(client, charLowId);
}
}
catch (Exception ex)
{
LoginHandler.log.Error((object)ex);
LoginHandler.SendCharacterLoginFail((IPacketReceiver)client, LoginErrorCode.CHAR_LOGIN_FAILED);
}
}
[PacketHandler(RealmServerOpCode.ReciveFishingBookReward)]//6182
public static void ReciveFishingBookRewardRequest(IRealmClient client, RealmPacketIn packet)
{
var bookNum = (byte)packet.ReadInt32();//default : 0Len : 4
var rewardItemId = packet.ReadInt32();
if (!client.ActiveCharacter.RegisteredFishingBooks.ContainsKey(bookNum))
{
client.ActiveCharacter.YouAreFuckingCheater(
"Tryes to recive fish book reward from not registered book.", 80);
return;
}
var book = client.ActiveCharacter.RegisteredFishingBooks[bookNum];
if (!book.Template.Rewards.Contains(rewardItemId))
{
client.ActiveCharacter.YouAreFuckingCheater(
"Tryes to recive fish book reward that this book not contained.", 80);
return;
}
var indexOfRewardItem = Array.IndexOf(book.Template.Rewards, rewardItemId);
Asda2Item rewItem = null;
var err = client.ActiveCharacter.Asda2Inventory.TryAdd(rewardItemId,
book.Template.RewardAmounts[indexOfRewardItem
], true,
ref rewItem);
Log.Create(Log.Types.ItemOperations, LogSourceType.Character, client.ActiveCharacter.EntryId)
.AddAttribute("source", 0, "fishing_book")
.AddItemAttributes(rewItem)
.Write();
client.ActiveCharacter.Map.AddMessage(() =>
{
if (!book.IsComleted)
{
client.ActiveCharacter.YouAreFuckingCheater(
"Tryes to recive fish book reward from not completed book.", 150);
return;
}
if (err != Asda2InventoryError.Ok)
{
client.ActiveCharacter.SendInfoMsg("Can't recive reward cause " + err);
return;
}
book.ResetBook();
SendFishingBookRewardRecivedResponse(client, GetFishingBookRewardStatus.Ok, rewItem, bookNum);
});
}
/// <summary>
/// Handles an incoming creature name query.
/// </summary>
/// <param name="client">the Session the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
//[ClientPacketHandler((RealmServerOpCode.CMSG_CREATURE_QUERY)]
public static void HandleCreatureQueryRequest(IRealmClient client, RealmPacketIn packet)
{
uint creatureEntryId = packet.ReadUInt32();
//var creatureEntityId = packet.ReadEntityId(); //actually we dont really care about the guid since its all static data
if (creatureEntryId != 0)
{
var entry = NPCMgr.GetEntry(creatureEntryId);
if (entry != null)
{
SendCreatureQueryResponse(client, entry);
}
}
}
public static void HandleSaveTalentGroup(IRealmClient client, RealmPacketIn packet)
{
var count = packet.ReadInt32();
var talents = client.ActiveCharacter.Talents;
for (var i = 0; i < count; i++)
{
var talentId = (TalentId)packet.ReadUInt32();
var rank = packet.ReadInt32();
talents.Learn(talentId, rank);
}
SendTalentGroupList(talents);
}
public static void HandleSwapItem(IRealmClient client, RealmPacketIn packet)
{
var inv = client.ActiveCharacter.Inventory;
if (inv.CheckInteract() == InventoryError.OK)
{
var destCont = (InventorySlot)packet.ReadByte();
var destSlot = packet.ReadByte();
var srcCont = (InventorySlot)packet.ReadByte();
var srcSlot = packet.ReadByte();
inv.TrySwap(srcCont, srcSlot, destCont, destSlot);
}
//SendInventoryError(client, null, null, InventoryError.NO_EQUIPMENT_SLOT_AVAILABLE3);
}
public static void HandleDestroyItem(IRealmClient client, RealmPacketIn packet)
{
var inv = client.ActiveCharacter.Inventory;
if (inv.CheckInteract() == InventoryError.OK)
{
var contSlot = (InventorySlot)packet.ReadByte();
var slot = packet.ReadByte();
var cont = inv.GetContainer(contSlot, inv.IsBankOpen);
if (cont != null && cont.IsValidSlot(slot))
{
cont.TryDestroy(slot);
}
}
}
/// <summary>
/// Cancels a positive aura (by right-clicking on the corresponding icon)
/// </summary>
public static void HandleCancelCastSpell(IRealmClient client, RealmPacketIn packet)
{
Spell index = SpellHandler.Get((SpellId)packet.ReadUInt32());
if (index == null)
{
return;
}
Aura aura = client.ActiveCharacter.Auras[index, true];
if (aura == null || !aura.CanBeRemoved)
{
return;
}
aura.TryRemove(true);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="packet"></param>
public static void HandleSetAction(IRealmClient client, RealmPacketIn packet)
{
EntityId id = packet.ReadEntityId();
Character activeCharacter = client.ActiveCharacter;
NPC pet = activeCharacter.Map.GetObject(id) as NPC;
if (pet == null || pet.PermanentPetRecord == null ||
pet != activeCharacter.ActivePet && !activeCharacter.GodMode)
{
return;
}
while (packet.Length - packet.Position >= 8)
{
ReadButton(pet, packet);
}
}
