public static void HandlePlayerLogin(ref PacketReader packet, ref WorldClass session)
{
byte[] guidMask = { 5, 7, 6, 1, 2, 3, 4, 0 };
byte[] guidBytes = { 6, 4, 3, 5, 0, 2, 7, 1 };
BitUnpack GuidUnpacker = new BitUnpack(packet);
ulong guid = GuidUnpacker.GetGuid(guidMask, guidBytes);
Log.Message(LogType.DEBUG, "Character with Guid: {0}, AccountId: {1} tried to enter the world.", guid, session.Account.Id);
session.Character = new Character(guid);
WorldMgr.AddSession(guid, ref session);
WorldMgr.WriteAccountData(AccountDataMasks.CharacterCacheMask, ref session);
MiscHandler.HandleMessageOfTheDay(ref session);
SpellHandler.HandleSendKnownSpells(ref session);
if (session.Character.LoginCinematic)
{
CinematicHandler.HandleStartCinematic(ref session);
}
ObjectHandler.HandleUpdateObject(ref session);
}
public static void DeleteNpc(string[] args, WorldClass session)
{
ChatMessageValues chatMessage = new ChatMessageValues(MessageType.ChatMessageSystem, "");
var pChar = session.Character;
var spawn = SpawnMgr.FindSpawn(pChar.TargetGuid);
if (spawn != null)
{
SpawnMgr.RemoveSpawn(spawn);
var destroyObject = ObjectHandler.HandleDestroyObject(ref session, pChar.TargetGuid);
session.Send(ref destroyObject);
WorldMgr.SendToInRangeCharacter(pChar, destroyObject);
chatMessage.Message = "Selected Spawn successfully removed.";
ChatHandler.SendMessage(ref session, chatMessage);
}
else
{
chatMessage.Message = "Not a creature.";
ChatHandler.SendMessage(ref session, chatMessage);
}
}
public static void HandleChatMessageWhisper(ref PacketReader packet, ref WorldClass session)
{
BitUnpack BitUnpack = new BitUnpack(packet);
var language = packet.Read <int>();
var nameLength = BitUnpack.GetBits <byte>(9);
var messageLength = BitUnpack.GetBits <byte>(8);
string message = packet.ReadString(messageLength);
string receiverName = packet.ReadString(nameLength);
WorldClass rSession = WorldMgr.GetSession(receiverName);
if (rSession == null)
{
return;
}
ChatMessageValues chatMessage = new ChatMessageValues(MessageType.ChatMessageWhisperInform, message, false, true);
SendMessage(ref session, chatMessage, rSession);
chatMessage = new ChatMessageValues(MessageType.ChatMessageWhisper, message, false, true);
SendMessage(ref rSession, chatMessage, session);
}
public static void RunSpeed(string[] args, WorldClass session)
{
ChatMessageValues chatMessage = new ChatMessageValues(0, "");
if (args.Length == 1)
{
MoveHandler.HandleMoveSetRunSpeed(ref session);
}
else
{
var speed = CommandParser.Read <float>(args, 1);
if (speed <= 50 && speed > 0)
{
chatMessage.Message = "Run speed set to " + speed + "!";
MoveHandler.HandleMoveSetRunSpeed(ref session, speed);
ChatHandler.SendMessage(ref session, chatMessage);
}
else
{
chatMessage.Message = "Please enter a value between 0.0 and 50.0!";
ChatHandler.SendMessage(ref session, chatMessage);
}
return;
}
chatMessage.Message = "Run speed set to default.";
ChatHandler.SendMessage(ref session, chatMessage);
}
public static void HandleSetActionButton(ref PacketReader packet, ref WorldClass session)
{
var pChar = session.Character;
byte[] actionMask = { 5, 2, 6, 7, 1, 4, 0, 3 };
byte[] actionBytes = { 4, 3, 2, 0, 5, 7, 6, 1 };
var slotId = packet.ReadByte();
BitUnpack actionUnpacker = new BitUnpack(packet);
var actionId = actionUnpacker.GetPackedValue(actionMask, actionBytes);
if (actionId == 0)
{
var action = pChar.ActionButtons.Where(button => button.SlotId == slotId && button.SpecGroup == pChar.ActiveSpecGroup).Select(button => button).First();
ActionMgr.RemoveActionButton(pChar, action, true);
Log.Message(LogType.DEBUG, "Character (Guid: {0}) removed action button {1} from slot {2}.", pChar.Guid, actionId, slotId);
return;
}
var newAction = new ActionButton
{
Action = actionId,
SlotId = slotId,
SpecGroup = pChar.ActiveSpecGroup
};
ActionMgr.AddActionButton(pChar, newAction, true);
Log.Message(LogType.DEBUG, "Character (Guid: {0}) added action button {1} to slot {2}.", pChar.Guid, actionId, slotId);
}
public static void HandleUITimeRequest(ref PacketReader packet, WorldClass session)
{
PacketWriter packetWriter = new PacketWriter(ServerMessage.UITime, true);
while (true)
{
IL_3E:
uint arg_26_0 = 3377425253u;
while (true)
{
uint num;
switch ((num = (arg_26_0 ^ 2768198855u)) % 3u)
{
case 1u:
packetWriter.WriteUnixTime();
arg_26_0 = (num * 827853117u ^ 2877711444u);
continue;
case 2u:
goto IL_3E;
}
goto Block_1;
}
}
Block_1:
session.Send(ref packetWriter);
}
public static void Start(string[] args, WorldClass session)
{
var pChar = session.Character;
SQLResult result = DB.Characters.Select("SELECT map, posX, posY, posZ, posO FROM character_creation_data WHERE race = ? AND class = ?", pChar.Race, pChar.Class);
Vector4 vector = new Vector4()
{
X = result.Read <float>(0, "PosX"),
Y = result.Read <float>(0, "PosY"),
Z = result.Read <float>(0, "PosZ"),
O = result.Read <float>(0, "PosO")
};
uint mapId = result.Read <uint>(0, "Map");
if (pChar.Map == mapId)
{
MoveHandler.HandleMoveTeleport(ref session, vector);
ObjectMgr.SetPosition(ref pChar, vector);
}
else
{
MoveHandler.HandleTransferPending(ref session, mapId);
MoveHandler.HandleNewWorld(ref session, vector, mapId);
ObjectMgr.SetPosition(ref pChar, vector);
ObjectMgr.SetMap(ref pChar, mapId);
ObjectHandler.HandleUpdateObjectCreate(ref session);
}
}
private void NewWorld()
{
WorldModel model;
using (var newWorldController = _controllerFactory.Create <INewWorldController>())
{
model = newWorldController.ShowView(View);
}
if (model == null || !CloseWorld())
{
return;
}
_world = new WorldClass
{
Model = model,
Status = WorldStatus.Changed
};
View.EnableCloseWorldToolStripItems();
View.EnableSaveWorldToolStripItems();
View.EnableSaveWorldAsToolStripItems();
View.ShowWorldToolStrips();
View.SetTitle(ViewTitle);
}
public static bool InvokeHandler(ref PacketReader reader, WorldClass session, ClientMessage opcode)
{
if (session.Character != null)
{
ulong charGuid = session.Character.Guid;
if (WorldMgr.Sessions.ContainsKey(charGuid))
{
WorldMgr.Sessions[charGuid] = session;
}
else
{
WorldMgr.AddSession(charGuid, ref session);
}
}
if (OpcodeHandlers.ContainsKey(opcode))
{
OpcodeHandlers[opcode].Invoke(ref reader, ref session);
return(true);
}
else
{
return(false);
}
}
void WriteInRangeObjects(IEnumerable <WorldObject> objects, WorldClass session, ObjectType type)
{
var pChar = session.Character;
var count = objects.Count();
var updateFlags = UpdateFlag.Rotation;
if (count > 0)
{
updateFlags |= type == ObjectType.GameObject ? UpdateFlag.StationaryPosition : UpdateFlag.Alive;
PacketWriter updateObject = new PacketWriter(ServerMessage.ObjectUpdate);
updateObject.WriteUInt16((ushort)pChar.Map);
updateObject.WriteUInt32((uint)count);
foreach (var o in objects)
{
WorldObject obj = o;
if (!pChar.InRangeObjects.ContainsKey(o.Guid))
{
WriteCreateObject(ref updateObject, obj, updateFlags, type);
if (pChar.Guid != o.Guid)
{
pChar.InRangeObjects.Add(obj.Guid, obj);
}
}
}
session.Send(ref updateObject);
}
}
private bool CloseWorld()
{
if (World?.Status == WorldStatus.Changed)
{
DialogResult result = View.ShowMessageBox("Your world has unsaved changes. Save now?", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
switch (result)
{
case DialogResult.Cancel:
return(false);
case DialogResult.Yes:
if (!SaveWorld())
{
return(false);
}
break;
}
}
_world = null;
View.DisableCloseWorldToolStripItems();
View.DisableSaveWorldToolStripItems();
View.DisableSaveWorldAsToolStripItems();
View.HideWorldToolStrips();
View.SetTitle(ViewTitle);
return(true);
}
public static void HandleSendKnownSpells(ref WorldClass session)
{
Character pChar = session.Character;
var specializationSpells = SpecializationMgr.GetSpecializationSpells(pChar);
var specializationSpellCount = ((specializationSpells != null) ? specializationSpells.Count : 0);
var talentSpells = SpecializationMgr.GetTalentSpells(pChar, pChar.ActiveSpecGroup);
var talentSpellCount = ((talentSpells != null) ? talentSpells.Count : 0);
int count = pChar.SpellList.Count + specializationSpellCount + talentSpellCount;
PacketWriter writer = new PacketWriter(ServerMessage.SendKnownSpells);
BitPack BitPack = new BitPack(writer);
BitPack.Write(count, 22);
BitPack.Write(1);
BitPack.Flush();
pChar.SpellList.ForEach(spell =>
writer.WriteUInt32(spell.SpellId));
if (specializationSpells != null)
{
specializationSpells.ForEach(spell => writer.WriteUInt32(spell.Spell));
}
if (talentSpells != null)
{
talentSpells.ForEach(spell => writer.WriteUInt32(spell));
}
session.Send(ref writer);
}
public static void HandleRequestUITime(ref PacketReader packet, ref WorldClass session)
{
PacketWriter uiTime = new PacketWriter(LegacyMessage.UITime);
uiTime.WriteUnixTime();
session.Send(uiTime);
}
public static void Handletest(ref PacketReader packet, WorldClass session)
{
PacketWriter packetWriter = new PacketWriter(ServerMessage.ResumeComms, true);
while (true)
{
IL_68:
int arg_52_0 = 2086761285;
while (true)
{
switch ((arg_52_0 ^ 716606170) % 3)
{
case 1:
{
session.Send(ref packetWriter);
WorldClass2 expr_3E = Manager.WorldMgr.GetSession2((session.Character != null) ? session.Character.Guid : 0uL);
if (expr_3E != null)
{
expr_3E.Send(ref packetWriter);
arg_52_0 = 92366913;
continue;
}
return;
}
case 2:
goto IL_68;
}
return;
}
}
}
public static void HandlePong(ref PacketReader packet, WorldClass session)
{
uint data = packet.Read <uint>();
packet.Read <uint>();
while (true)
{
IL_4D:
uint arg_35_0 = 1104434895u;
while (true)
{
uint num;
switch ((num = (arg_35_0 ^ 1516962984u)) % 3u)
{
case 0u:
goto IL_4D;
case 1u:
new PacketWriter(ServerMessage.Pong, true).WriteUInt32(data);
arg_35_0 = (num * 1473635169u ^ 3334520623u);
continue;
}
return;
}
}
}
public static void AddNpc(string[] args, WorldClass session)
{
var level = CommandParser.Read <byte>(args, 1);
var chatMessage = new ChatMessageValues(0, "Please enter a level between 0 and 91.");
if (level > 90 || level < 1)
{
ChatHandler.SendMessage(ref session, chatMessage);
return;
}
var pChar = session.Character;
if (SmartGuid.GetGuidType(pChar.TargetGuid) == HighGuidType.Player)
{
if (DB.Characters.Execute("UPDATE Characters SET Level = ? WHERE Guid = ?", level, pChar.Guid))
{
pChar.SetUpdateField <uint>((int)UnitFields.Level, level);
ObjectHandler.HandleUpdateObjectValues(ref session);
}
}
else
{
chatMessage.Message = "Please select a player.";
ChatHandler.SendMessage(ref session, chatMessage);
}
}
public static void HandlePlayerLogin(ref PacketReader packet, WorldClass session)
{
byte[] guidMask = { 1, 0, 7, 2, 5, 6, 4, 3 };
byte[] guidBytes = { 7, 6, 0, 1, 4, 3, 2, 5 };
BitUnpack GuidUnpacker = new BitUnpack(packet);
var unknown = packet.Read <float>();
var guid = GuidUnpacker.GetPackedValue(guidMask, guidBytes);
Log.Message(LogType.Debug, "Character with Guid: {0}, AccountId: {1} tried to enter the world.", guid, session.Account.Id);
session.Character = new Character(guid);
if (!WorldMgr.AddSession(guid, ref session))
{
Log.Message(LogType.Error, "A Character with Guid: {0} is already logged in", guid);
return;
}
WorldMgr.WriteAccountDataTimes(AccountDataMasks.CharacterCacheMask, ref session);
MiscHandler.HandleMessageOfTheDay(ref session);
TimeHandler.HandleLoginSetTimeSpeed(ref session);
SpecializationHandler.HandleUpdateTalentData(ref session);
SpellHandler.HandleSendKnownSpells(ref session);
MiscHandler.HandleUpdateActionButtons(ref session);
if (session.Character.LoginCinematic)
{
CinematicHandler.HandleStartCinematic(ref session);
}
ObjectHandler.HandleUpdateObjectCreate(ref session);
}
public static void ExecuteChatHandler(string chatCommand, WorldClass session)
{
string[] array = ChatCommandParser.smethod_5(chatCommand, new string[]
{
Module.smethod_34 <string>(1210918633u)
}, StringSplitOptions.None);
string key = ChatCommandParser.smethod_6(array[0], 0, 1);
while (true)
{
IL_9A:
uint arg_7E_0 = 4290933796u;
while (true)
{
uint num;
switch ((num = (arg_7E_0 ^ 3881183605u)) % 4u)
{
case 1u:
arg_7E_0 = ((ChatCommandParser.ChatCommands.ContainsKey(key) ? 1983062844u : 1891696354u) ^ num * 4159093623u);
continue;
case 2u:
ChatCommandParser.ChatCommands[key](array, session);
arg_7E_0 = (num * 4266578640u ^ 2567288869u);
continue;
case 3u:
goto IL_9A;
}
return;
}
}
}
public static void HandleLoginSetTimeSpeed(ref WorldClass session)
{
PacketWriter packetWriter = new PacketWriter(ServerMessage.LoginSetTimeSpeed, true);
packetWriter.WritePackedTime();
while (true)
{
IL_66:
uint arg_4E_0 = 1798748320u;
while (true)
{
uint num;
switch ((num = (arg_4E_0 ^ 458044892u)) % 3u)
{
case 0u:
goto IL_66;
case 2u:
packetWriter.WritePackedTime();
packetWriter.WriteFloat(0.01666667f);
packetWriter.WriteInt32(0);
packetWriter.WriteInt32(0);
session.Send(ref packetWriter);
arg_4E_0 = (num * 3161907175u ^ 1843293902u);
continue;
}
return;
}
}
}
public static void HandleQueryRealmName(ref PacketReader packet, WorldClass session)
{
Character pChar = session.Character;
uint realmId = packet.Read <uint>();
SQLResult result = DB.Realms.Select("SELECT name FROM realms WHERE id = ?", WorldConfig.RealmId);
string realmName = result.Read <string>(0, "Name");
PacketWriter realmQueryResponse = new PacketWriter(ServerMessage.RealmQueryResponse);
BitPack BitPack = new BitPack(realmQueryResponse);
realmQueryResponse.WriteUInt8(0);
realmQueryResponse.WriteUInt32(realmId); // <= 0 => End of packet
BitPack.Write(realmName.Length, 8);
BitPack.Write(1);
BitPack.Write(realmName.Length, 8);
BitPack.Flush();
realmQueryResponse.WriteString(realmName);
realmQueryResponse.WriteString(realmName);
session.Send(ref realmQueryResponse);
}
public static void AddTele(string[] args, WorldClass session)
{
var pChar = session.Character;
string location = CommandParser.Read <string>(args, 1);
SQLResult result = DB.World.Select("SELECT * FROM teleport_locations WHERE location = ?", location);
ChatMessageValues chatMessage = new ChatMessageValues(0, "");
if (result.Count == 0)
{
if (DB.World.Execute("INSERT INTO teleport_locations (location, x, y, z, o, map) " +
"VALUES (?, ?, ?, ?, ?, ?)", location, pChar.Position.X, pChar.Position.Y, pChar.Position.Z, pChar.Position.O, pChar.Map))
{
chatMessage.Message = string.Format("Teleport location '{0}' successfully added.", location);
ChatHandler.SendMessage(ref session, chatMessage);
}
}
else
{
chatMessage.Message = string.Format("Teleport location '{0}' already exist.", location);
ChatHandler.SendMessage(ref session, chatMessage);
}
}
public static void HandleCliSetSpecialization(ref PacketReader packet, ref WorldClass session)
{
var pChar = session.Character;
uint specGroupId = packet.Read <uint>();
uint specId = SpecializationMgr.GetSpecIdByGroup(pChar, (byte)specGroupId);
// check if new spec is primary or secondary
if (pChar.SpecGroupCount == 1 && pChar.PrimarySpec == 0)
{
pChar.ActiveSpecGroup = 0;
pChar.PrimarySpec = (ushort)specId;
}
else
{
pChar.ActiveSpecGroup = 1;
pChar.SecondarySpec = (ushort)specId;
pChar.SpecGroupCount = (byte)(pChar.SpecGroupCount + 1);
}
SpecializationMgr.SaveSpecInfo(pChar);
SendSpecializationSpells(ref session);
HandleUpdateTalentData(ref session);
pChar.SetUpdateField <Int32>((int)PlayerFields.CurrentSpecID, (int)pChar.GetActiveSpecId());
ObjectHandler.HandleUpdateObjectValues(ref session);
Log.Message(LogType.DEBUG, "Character (Guid: {0}) choosed spectialization {1} for spec group {2}.", pChar.Guid, pChar.GetActiveSpecId(), pChar.ActiveSpecGroup);
}
public static void HandleSetSelection(ref PacketReader packet, ref WorldClass session)
{
byte[] guidMask = { 2, 6, 1, 7, 4, 5, 3, 0 };
byte[] guidBytes = { 0, 6, 3, 2, 1, 4, 7, 5 };
BitUnpack GuidUnpacker = new BitUnpack(packet);
ulong fullGuid = GuidUnpacker.GetPackedValue(guidMask, guidBytes);
ulong guid = SmartGuid.GetGuid(fullGuid);
if (session.Character != null)
{
var sess = WorldMgr.GetSession(session.Character.Guid);
if (sess != null)
{
sess.Character.TargetGuid = fullGuid;
}
if (guid == 0)
{
Log.Message(LogType.DEBUG, "Character (Guid: {0}) removed current selection.", session.Character.Guid);
}
else
{
Log.Message(LogType.DEBUG, "Character (Guid: {0}) selected a {1} (Guid: {2}, Id: {3}).", session.Character.Guid, SmartGuid.GetGuidType(fullGuid), guid, SmartGuid.GetId(fullGuid));
}
}
}
public static void HandleLearnTalents(ref PacketReader packet, ref WorldClass session)
{
var pChar = session.Character;
var talentSpells = new List <uint>();
BitUnpack BitUnpack = new BitUnpack(packet);
uint talentCount = BitUnpack.GetBits <uint>(23);
for (int i = 0; i < talentCount; i++)
{
var talentId = packet.Read <ushort>();
SpecializationMgr.AddTalent(pChar, pChar.ActiveSpecGroup, talentId, true);
talentSpells.Add(CliDB.Talent.Single(talent => talent.Id == talentId).SpellId);
}
HandleUpdateTalentData(ref session);
pChar.SetUpdateField <Int32>((int)PlayerFields.SpellCritPercentage + 0, SpecializationMgr.GetUnspentTalentRowCount(pChar), 0);
ObjectHandler.HandleUpdateObjectValues(ref session);
foreach (var talentSpell in talentSpells)
{
SpellHandler.HandleLearnedSpells(ref session, new List <uint>(1)
{
talentSpell
});
}
Log.Message(LogType.DEBUG, "Character (Guid: {0}) learned {1} talents.", pChar.Guid, talentCount);
}
public static void AddNpc(string[] args, WorldClass session)
{
var pChar = session.Character;
int creatureId = CommandParser.Read <int>(args, 1);
Creature creature = DataMgr.FindCreature(creatureId);
if (creature != null)
{
ChatMessageValues chatMessage = new ChatMessageValues(0, "");
CreatureSpawn spawn = new CreatureSpawn()
{
Guid = CreatureSpawn.GetLastGuid() + 1,
Id = creatureId,
Creature = creature,
Position = pChar.Position,
Map = pChar.Map
};
if (spawn.AddToDB())
{
chatMessage.Message = "Spawn successfully added.";
spawn.AddToWorld();
ChatHandler.SendMessage(ref session, chatMessage);
}
else
{
chatMessage.Message = "Spawn can't be added.";
ChatHandler.SendMessage(ref session, chatMessage);
}
}
}
public static void HandlePlayerLogin(ref PacketReader packet, ref WorldClass session)
{
byte[] guidMask = { 6, 3, 0, 5, 7, 2, 1, 4 };
byte[] guidBytes = { 1, 0, 3, 2, 4, 7, 5, 6 };
BitUnpack GuidUnpacker = new BitUnpack(packet);
ulong guid = GuidUnpacker.GetGuid(guidMask, guidBytes);
Log.Message(LogType.DEBUG, "Character with Guid: {0}, AccountId: {1} tried to enter the world.", guid, session.Account.Id);
session.Character = new Character(guid, ref session);
WorldMgr.Session = session;
SpellMgr.LoadSpells();
WorldMgr.WriteAccountData(AccountDataMasks.CharacterCacheMask, ref session);
PacketWriter motd = new PacketWriter(LegacyMessage.MessageOfTheDay);
motd.WriteUInt32(3);
motd.WriteCString("Arctium MoP test");
motd.WriteCString("Welcome to our MoP server test.");
motd.WriteCString("Your development team =)");
session.Send(motd);
SpellHandler.SendSendKnownSpells();
UpdateHandler.HandleUpdateObject(ref packet, ref session);
}
public void WriteAccountData(AccountDataMasks mask, ref WorldClass session)
{
PacketWriter accountInitialized = new PacketWriter(LegacyMessage.AccountDataInitialized);
accountInitialized.WriteUnixTime();
accountInitialized.WriteUInt8(0);
accountInitialized.WriteUInt32((uint)mask);
for (int i = 0; i <= 8; ++i)
{
if (((int)mask & (1 << i)) != 0)
{
if (i == 1 && mask == AccountDataMasks.GlobalCacheMask)
{
accountInitialized.WriteUnixTime();
}
else
{
accountInitialized.WriteUInt32(0);
}
}
}
session.Send(accountInitialized);
}
public static void HandleCacheVersion(ref WorldClass session)
{
PacketWriter packetWriter = new PacketWriter(ServerMessage.CacheVersion, true);
while (true)
{
IL_48:
uint arg_30_0 = 575565698u;
while (true)
{
uint num;
switch ((num = (arg_30_0 ^ 945065969u)) % 3u)
{
case 0u:
goto IL_48;
case 1u:
packetWriter.WriteUInt32(0u);
session.Send(ref packetWriter);
arg_30_0 = (num * 2866656945u ^ 272808339u);
continue;
}
return;
}
}
}
public static void HandleTransferPending(ref WorldClass session, uint mapId)
{
bool Unknown = false;
bool IsTransport = false;
PacketWriter transferPending = new PacketWriter(ServerMessage.TransferPending);
BitPack BitPack = new BitPack(transferPending);
BitPack.Write(Unknown);
BitPack.Write(IsTransport);
if (Unknown)
{
transferPending.WriteUInt32(0);
}
if (IsTransport)
{
transferPending.WriteUInt32(0);
transferPending.WriteUInt32(0);
}
transferPending.WriteUInt32(mapId);
session.Send(ref transferPending);
}
public static void LearnSpell(string[] args, WorldClass session)
{
if (session.Character.TargetGuid == 0)
{
ChatHandler.SendMessage(ref session, new ChatMessageValues(MessageType.ChatMessageSystem, "Theres no targeted character to teach."));
return;
}
var target = new Character(session.Character.TargetGuid);
uint spellId = CommandParser.Read <uint>(args, 1);
try
{
SpellMgr.AddSpell(target, spellId);
}
catch (Exception e)
{
ChatMessageValues chatMessage = new ChatMessageValues(MessageType.ChatMessageSystem, e.Message);
ChatHandler.SendMessage(ref session, chatMessage);
}
var targetSession = WorldMgr.Sessions.First(o => o.Value.Character.Guid == target.Guid).Value;
SpellHandler.HandleLearnedSpells(ref targetSession, new List <uint>()
{
spellId
});
}
