static void OnChangeMap(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
uint id = data.ReadUInt32();
LoginClient client = LoginServer.GetLoginClientByCharacterID(id);
client.IsChangingMap = true;
}
private static void OnLoginServerData(byte[] data)
{
try {
BinReader read = new BinReader(data);
read.BaseStream.Position += 4; // skip len
WORLDMSG msgID = (WORLDMSG)read.ReadInt32();
if (msgID == WORLDMSG.CLIENT_MESSAGE)
{
uint charID = read.ReadUInt32();
CMSG cmsg = (CMSG)read.ReadInt32();
WorldClient client = GetClientByCharacterID(charID);
if (client != null)
{
WorldPacketManager.HandlePacket(client, cmsg, read);
}
else
{
Console.WriteLine("Client(" + charID + ") was missing when " + cmsg.ToString() + " was received.");
}
}
else if (msgID == WORLDMSG.SCRIPT_MESSAGE)
{
int msg = read.ReadInt32();
Scripts.OnScriptMessage(msg, read);
}
else
{
WorldPacketManager.HandlePacket(msgID, read);
}
} catch (Exception exp) {
DebugLogger.Log("", exp);
}
}
public static void HandlePacket(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
try {
DebugLogger.Logger.Log("LoginClient handling packet " + msgID.ToString());
bool handled_packet = false;
ILoginServerPacketHandler handler = (ILoginServerPacketHandler)loginServerHandlers[msgID];
if (handler != null)
{
handled_packet = true;
handler.HandlePacket(connection, msgID, data);
}
LoginServerPacketDelegate wspd = (LoginServerPacketDelegate)loginServerDelegates[(int)msgID];
if (wspd != null)
{
handled_packet = true;
wspd(connection, msgID, data);
}
if (handled_packet == false)
{
DebugLogger.Logger.Log("WARNING: No valid handler found for " + msgID.ToString());
}
} catch (Exception exp) {
DebugLogger.Logger.Log("", exp);
}
}
static void OnInitGuids(WORLDMSG msgID, BinReader data)
{
m_currentGUID = data.ReadUInt64();
m_currentMax = data.ReadUInt64();
m_guidpool.Enqueue(data.ReadUInt64());
m_guidpool.Enqueue(data.ReadUInt64());
}
static void DeserializeObject(WORLDMSG msgID, BinReader data)
{
string str = data.ReadString();
Type type = dbTypes.GetType(str);
if (type == null)
{
throw new Exception("Failed to deserialize " + str + ": type == null");
}
uint ObjectID = data.ReadUInt32();
DBObject obj = GetDBObject(type, ObjectID);
if (obj != null)
{
obj.Deserialize(data);
// we will probably never deserialized an existing object
Console.WriteLine("woooah! WorldServer deserialized a " + str + " that already exists. Notify something!");
}
else
{
obj = (DBObject)Activator.CreateInstance(type);
obj.Deserialize(data);
AddDBObject(obj);
}
if (type == typeof(DBCharacter))
{
int n = data.ReadInt32();
DBCharacter c = (DBCharacter)obj;
if (n > 0)
{
c.Items = new DBItem[n];
for (int i = 0; i < n; i++)
{
ObjectID = data.ReadUInt32();
DBItem item = (DBItem)GetDBObject(typeof(DBItem), ObjectID);
if (item == null)
{
item = new DBItem();
item.Deserialize(data);
AddDBObject(item);
}
else
{
item.Deserialize(data);
}
item.Template = (DBItemTemplate)GetDBObject(typeof(DBItemTemplate), item.TemplateID);
if (item.Template == null)
{
Console.WriteLine("Missing Item Template " + item.TemplateID);
}
c.Items[i] = item;
}
}
else
{
c.Items = null;
}
}
}
static void OnPlayerEnterWorld(WORLDMSG msgID, BinReader data)
{
uint id = data.ReadUInt32();
ACCESSLEVEL accesslevel = (ACCESSLEVEL)data.ReadByte();
DBCharacter c = (DBCharacter)DBManager.GetDBObject(typeof(DBCharacter), id);
if (c == null)
{
Console.WriteLine("Failed to enter world with id " + id + ". WorldServer is missing Character object");
return;
}
WorldClient client = new WorldClient(c);
MapInstance map = (MapInstance)m_maps[c.WorldMapID];
if (map == null)
{
Console.WriteLine("Worldserver is not handling " + c.WorldMapID + "!");
client.LeaveWorld();
return;
}
map.SetObjectPositionInBounds(client.Player);
//client.CreatePlayerObject();
client.Player.AccessLvl = accesslevel;
map.Enter(client.Player);
}
static void OnRegisterVendor(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
ulong vGUID = data.ReadUInt64();
uint id = data.ReadUInt32();
uint level = data.ReadUInt32();
string name = data.ReadString();
DBVendor vendor;
if (id == 0)
{
Console.WriteLine("SpawnID was 0 for vendor registration");
}
DataObject[] objs = DataServer.Database.SelectObjects(typeof(DBVendor), "SpawnID = '" + id + "'");
if (objs.Length == 0)
{
vendor = new DBVendor();
vendor.SpawnID = id;
vendor.GUID = vGUID;
vendor.Name = name;
vendor.Level = level;
DataServer.Database.AddNewObject(vendor);
Console.WriteLine("Vendor " + vendor.ObjectId + " created");
}
else
{
vendor = (DBVendor)objs[0];
vendor.GUID = vGUID;
vendor.Level = level;
Console.WriteLine("Vendor " + vendor.ObjectId + " registered");
DataServer.Database.SaveObject(vendor);
}
return;
}
static void OnGroupCreate(WORLDMSG msgID, BinReader data)
{
uint charID = data.ReadUInt32();
WorldClient client = WorldServer.GetClientByCharacterID(charID);
uint leaderID = data.ReadUInt32();
WorldClient leader = WorldServer.GetClientByCharacterID(leaderID);
if (leader == null)
{
Console.WriteLine("Leader not found");
return;
}
if (leader.Player.Group == null)
{
leader.Player.Group = new GroupObject(client.Player, leader.Player);
}
else
{
for (uint i = 0; i < leader.Player.Group.Size; i++)
{
if (leader.Player.Group.Members[i].CharacterID == charID)
{
return;
}
}
leader.Player.Group.AddMember(client.Player);
}
client.Player.Group = leader.Player.Group;
leader.Player.IsLeader = true;
client.Player.Group.LeaderGUID = leader.Player.GUID;
client.Player.Group.SendGroupList();
}
public WorldPacket(WORLDMSG msgID) : base()
{
Write((UInt32)0); // WorldPacket len
Write((UInt32)msgID);
m_worldMsgId = msgID;
}
static void OnCreateDBObjectReply(WORLDMSG msgID, BinReader data)
{
int requestid = data.ReadInt32();
/*string str =*/ data.ReadString();
uint objid = data.ReadUInt32();
DBObject obj = (DBObject)createDBRequests[requestid];
createDBRequests.Remove(requestid);
obj.OnDBCreate(objid);
obj.PendingCreate = false;
AddDBObject(obj);
if (obj.PendingDelete == true)
{
obj.PendingDelete = false;
DeleteDBObject(obj);
return;
}
if (obj.PendingSave == true)
{
obj.PendingSave = false;
SaveDBObject(obj);
}
}
public static void RegisterPacketHandler(WORLDMSG msgID, ILoginServerPacketHandler handler)
{
if (loginServerHandlers.Contains(msgID))
{
throw new Exception("There's already a loginserver packet handler for " + msgID);
}
loginServerHandlers[msgID] = handler;
}
static void OnAcquireGuids(WORLDMSG msgID, BinReader data)
{
try {
m_guidpool.Enqueue(data.ReadUInt64());
m_guidpool.Enqueue(data.ReadUInt64());
} catch (Exception exp) {
DebugLogger.Log("", exp);
}
}
static void OnAcquireGuids(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
WorldPacket pkg = new WorldPacket(WORLDMSG.ACQUIRE_GUIDS_REPLY);
pkg.Write(current_guid);
current_guid += 200000;
pkg.Write(current_guid++);
connection.Send(pkg);
}
static void OnInitGuids(WORLDMSG msgID, BinReader data)
{
try {
m_currentGUID = data.ReadUInt64();
m_currentMax = data.ReadUInt64();
m_guidpool.Enqueue(data.ReadUInt64());
m_guidpool.Enqueue(data.ReadUInt64());
} catch (Exception exp) {
DebugLogger.Log("", exp);
}
}
public static void RegisterPacketHandler(WORLDMSG msgID, LoginServerPacketDelegate wspd)
{
if (loginServerDelegates[(int)msgID] != null)
{
LoginServerPacketDelegate dele = (LoginServerPacketDelegate)loginServerDelegates[(int)msgID];
loginServerDelegates[(int)msgID] = dele + wspd;
}
else
{
loginServerDelegates[(int)msgID] = wspd;
}
}
static void OnPlayerLeaveWorld(WORLDMSG msgID, BinReader data)
{
uint id = data.ReadUInt32();
WorldClient client = WorldServer.GetClientByCharacterID(id);
if (client == null)
{
Console.WriteLine("Failed to leave world. Client didn't exist on worldserver.");
return;
}
client.LeaveWorld();
}
static void InitSpells(WORLDMSG msgID, BinReader data)
{
int numSpells = data.ReadInt32();
for (int j = 0; j < numSpells; j++)
{
DBSpell spell = new DBSpell();
spell.Deserialize(data);
spellsDB.Add(spell.ObjectId, spell);
}
Console.WriteLine("WorldServer successfully received " + spellsDB.Count + " spells!");
}
public static void RegisterPacketHandler(WORLDMSG msgID, WorldServerPacketDelegate wspd)
{
if (worldServerDelegates[(int)msgID] != null)
{
WorldServerPacketDelegate dele = (WorldServerPacketDelegate)worldServerDelegates[(int)msgID];
worldServerDelegates[(int)msgID] = dele + wspd;
}
else
{
worldServerDelegates[(int)msgID] = wspd;
}
}
public static void RegisterPacketHandler(WORLDMSG msgID, LoginServerPacketDelegate wspd)
{
DebugLogger.Logger.Log("Registering login packet delegate for " + msgID);
if (loginServerDelegates[(int)msgID] != null)
{
LoginServerPacketDelegate dele = (LoginServerPacketDelegate)loginServerDelegates[(int)msgID];
loginServerDelegates[(int)msgID] = dele + wspd;
}
else
{
loginServerDelegates[(int)msgID] = wspd;
}
}
public static void HandlePacket(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
ILoginServerPacketHandler handler = (ILoginServerPacketHandler)loginServerHandlers[msgID];
if (handler != null)
{
handler.HandlePacket(connection, msgID, data);
}
LoginServerPacketDelegate wspd = (LoginServerPacketDelegate)loginServerDelegates[(int)msgID];
if (wspd != null)
{
wspd(connection, msgID, data);
}
}
public static void HandlePacket(WORLDMSG msgID, BinReader data)
{
IWorldServerPacketHandler handler = (IWorldServerPacketHandler)worldServerHandlers[msgID];
if (handler != null)
{
handler.HandlePacket(msgID, data);
}
WorldServerPacketDelegate wspd = (WorldServerPacketDelegate)worldServerDelegates[(int)msgID];
if (wspd != null)
{
wspd(msgID, data);
}
}
public static void HandlePacket(WORLDMSG msgID, BinReader data)
{
try {
IWorldServerPacketHandler handler = (IWorldServerPacketHandler)worldServerHandlers[msgID];
if (handler != null)
{
handler.HandlePacket(msgID, data);
}
WorldServerPacketDelegate wspd = (WorldServerPacketDelegate)worldServerDelegates[(int)msgID];
if (wspd != null)
{
wspd(msgID, data);
}
} catch (Exception exp) {
DebugLogger.Log("", exp);
}
}
static void OnCreateDBObject(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
try
{
int requestID = data.ReadInt32();
string str = data.ReadString();
Type type = dbTypes.GetType(str, true);
DBObject obj = (DBObject)Activator.CreateInstance(type);
DataServer.Database.AddNewObject(obj);
WorldPacket pkg = new WorldPacket(WORLDMSG.CREATE_DBOBJECT_REPLY);
pkg.Write(requestID);
pkg.Write(str);
pkg.Write(obj.ObjectId);
connection.Send(pkg);
}
catch (Exception e)
{
Console.WriteLine("Error in OnCreateDBObject!");
Console.WriteLine(e);
}
}
static void OnDeleteDBObject(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
try
{
string str = data.ReadString();
Type type = dbTypes.GetType(str, true);
uint objectID = data.ReadUInt32();
string field = DataObject.GetTableName(type) + "_ID";
DataObject[] objs = DataServer.Database.SelectObjects(type, field + " = '" + objectID + "'");
if (objs.Length == 0)
{
throw new Exception("Requested objectID " + objectID + " for " + str + " didn't exist!");
}
DataServer.Database.DeleteObject(objs[0]);
}
catch (Exception e)
{
Console.WriteLine("Error in OnDeleteDBObject!");
Console.WriteLine(e);
}
}
/*
* internal bool processWorldServerData()
* {
* if(m_client.PendingSendData)
* m_client.SendWork();
* if(m_client.Connected == false)
* return false;
* byte[] data;
* while((data = m_client.GetNextPacketData()) != null)
* OnWorldServerData(data);
* return m_client.Connected;
* }*/
private void OnWorldServerData(ClientBase c, byte[] data)
{
BinReader read = new BinReader(data);
read.BaseStream.Position += 4; // skip len
WORLDMSG msgID = (WORLDMSG)read.ReadInt32();
if (msgID == WORLDMSG.SERVER_MESSAGE)
{
SMSG smsg = (SMSG)read.ReadInt32();
Console.WriteLine("WorldServer sent: " + smsg);
int len = read.ReadInt32();
BinWriter pkg = LoginClient.NewPacket(smsg);
if (len > 0)
{
pkg.Write(read.ReadBytes(len));
}
while (read.BaseStream.Position < read.BaseStream.Length)
{
uint plrID = read.ReadUInt32();
LoginClient client = LoginServer.GetLoginClientByCharacterID(plrID);
if (client == null)
{
Console.WriteLine("client missing for plrID " + plrID + " while sending " + smsg.ToString());
}
else
{
client.Send(pkg);
}
}
}
else if (msgID == WORLDMSG.SCRIPT_MESSAGE)
{
LoginServer.Scripts.OnScriptMessage(read.ReadInt32(), read);
}
else
{
LoginPacketManager.HandlePacket(this, msgID, read);
}
}
static void InitMaps(WORLDMSG msgID, BinReader data)
{
int numMaps = data.ReadInt32();
for (int i = 0; i < numMaps; i++)
{
DBWorldMap map = new DBWorldMap(data);
int numSpawns = data.ReadInt32();
map.Spawns = new DBSpawn[numSpawns];
for (int j = 0; j < numSpawns; j++)
{
DBSpawn spawn = new DBSpawn();
spawn.Deserialize(data);
spawn.Creature = (DBCreature)DBManager.GetDBObject(typeof(DBCreature), spawn.CreatureID);
if (spawn.Creature == null)
{
Console.WriteLine("Spawn " + spawn.ObjectId + " is missing creature on worldserver.");
}
map.Spawns[j] = spawn;
}
m_maps[map.ObjectId] = new MapInstance(map);
}
}
static void OnPlayerLeaveWorld(WorldConnection connection, WORLDMSG msgID, BinReader data)
{
LoginClient client = LoginServer.GetLoginClientByCharacterID(data.ReadUInt32());
if (client == null)
{
return;
}
if (client.IsLoggingOut)
{
LoginServer.RemoveCharacter(client);
BinWriter pkg = LoginClient.NewPacket(SMSG.LOGOUT_COMPLETE);
client.Send(pkg);
client.IsLoggingOut = false;
client.WorldConnection = null;
}
else if (client.IsChangingMap)
{
}
else
{
client.Close("Kicked from worldserver.");
}
}
public static void UnregisterPacketHandler(WORLDMSG msgID, LoginServerPacketDelegate wspd)
{
LoginServerPacketDelegate dele = (LoginServerPacketDelegate)loginServerDelegates[(int)msgID];
loginServerDelegates[(int)msgID] = dele - wspd;
}
public LoginPacketDelegate(WORLDMSG msgID)
{
m_msgID = (int)msgID;
m_clientMessage = false;
}
public LoginPacketHandler(WORLDMSG msgID)
{
m_useDelegates = false;
m_msgID = (int)msgID;
m_clientMessage = false;
}
