public void SendGroupList()
{
Console.WriteLine("Sending Group List");
for (uint i = 0; i < Size; i++)
{
ServerPacket grp = new ServerPacket(SMSG.GROUP_LIST);
grp.Write((int)Size - 1); // Counter
for (uint j = 0; j < Size; j++)
{
if (j != i)
{
grp.Write(Members[j].Name); // Member Name
grp.Write(Members[j].GUID); // Member GUID
grp.Write(Members[j].IsLeader); // Is Member Leader?
}
}
grp.Write(LeaderGUID); // Leader GUID
grp.Write(LootMethod);
grp.Write(LootMasterName);
grp.Write(LootMaster);
// grp.Write((byte)0);
// grp.Write(LootMaster); // Trying LootMaster GUID - Phaze
grp.Finish();
grp.AddDestination(Members[i].CharacterID);
WorldServer.Send(grp);
}
} //SendGroupList
public void LeaveWorld()
{
try {
this.Player.InWorld = false;
if (m_player.Group != null)
{
if (m_player.IsLeader || m_player.Group.Size < 3)
{
m_player.Group.Destroy();
}
else
{
m_player.Group.RemoveMember(m_player.Name);
}
}
ChannelManager.Deconnection(this);
m_player.SaveAndRemove();
WorldServer.RemoveClient(this);
WorldPacket pkg = new WorldPacket(WORLDMSG.PLAYER_LEAVE_WORLD);
pkg.Write(m_character.ObjectId);
WorldServer.Send(pkg);
} catch (Exception exp) {
DebugLogger.Logger.Log("", exp);
}
}
public void LevelUp()
{
int maxhealth = this.MaxHealth;
int maxpower = this.MaxPower;
this.Level++;
StatManager.CalculateNextLevelExp(this);
this.Exp = 0;
StatManager.CalculateNewStats(this);
this.Health = this.MaxHealth;
this.Power = this.MaxPower;
UpdateData();
Save();
ServerPacket pkg = new ServerPacket(SMSG.LEVELUP_INFO);
pkg.Write((uint)this.Level);
pkg.Write((uint)(this.MaxHealth - maxhealth));
pkg.Write((uint)(this.MaxPower - maxpower));
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Write((uint)0);
pkg.Finish();
pkg.AddDestination(this.CharacterID);
WorldServer.Send(pkg);
}
internal void DestroyObject(WorldObject obj)
{
if (m_objects[(int)OBJECTTYPE.PLAYER].Count > 0)
{
ServerPacket pkg = new ServerPacket(SMSG.OBJECT_DESTROY);
pkg.Write(obj.GUID);
pkg.Finish();
if (obj.ObjectType == OBJECTTYPE.PLAYER)
{
PlayerObject player = obj as PlayerObject;
foreach (PlayerObject plr in m_objects[(int)OBJECTTYPE.PLAYER].Values)
{
pkg.AddDestination(plr.CharacterID);
player.Inventory.SendDestroyInventory(plr.CharacterID);
}
}
else
{
foreach (PlayerObject plr in m_objects[(int)OBJECTTYPE.PLAYER].Values)
{
pkg.AddDestination(plr.CharacterID);
}
}
WorldServer.Send(pkg);
}
}
public static void ChangeMap(WorldClient client)
{
if (client.Player.MapTile == null)
{
return;
}
MapInstance map = GetMap(client.Player.WorldMapID);
if (map == null)
{
WorldPacket pkg = new WorldPacket(WORLDMSG.CHANGE_MAP);
pkg.Write(client.CharacterID);
WorldServer.Send(pkg);
client.LeaveWorld();
return;
}
else
{
client.Player.MapTile.Map.Leave(client.Player);
client.Player.Continent = (uint)map.Continent;
map.SetObjectPositionInBounds(client.Player);
ServerPacket pkg = new ServerPacket(SMSG.NEW_WORLD);
pkg.Write((byte)client.Player.Continent);
pkg.WriteVector(client.Player.Position);
pkg.Write(client.Player.Facing);
pkg.Finish();
pkg.AddDestination(client.CharacterID);
WorldServer.Send(pkg);
}
}
internal static void LoadScreen(WorldClient client)
{
ServerPacket pkg = new ServerPacket(SMSG.TRANSFER_PENDING);
pkg.Write((int)0);
pkg.Finish();
pkg.AddDestination(client.CharacterID);
WorldServer.Send(pkg);
}
public void Send(SMSG msgID, BinWriter data)
{
ServerPacket pkg = new ServerPacket(msgID);
pkg.Write(data.GetBuffer(), 0, (int)data.BaseStream.Length);
pkg.Finish();
pkg.AddDestination(m_character.ObjectId);
WorldServer.Send(pkg);
}
public void Send(SMSG msgID, byte[] data, int index, int count)
{
ServerPacket pkg = new ServerPacket(msgID);
pkg.Write(data, index, count);
pkg.Finish();
pkg.AddDestination(m_character.ObjectId);
WorldServer.Send(pkg);
}
public void LeaveWorld()
{
m_player.SaveAndRemove();
WorldServer.RemoveClient(this);
WorldPacket pkg = new WorldPacket(WORLDMSG.PLAYER_LEAVE_WORLD);
pkg.Write(m_character.ObjectId);
WorldServer.Send(pkg);
}
public void SendToGroup(ServerPacket grp)
{
grp.Finish();
for (uint i = 0; i < Size; i++)
{
grp.AddDestination(Members[i].CharacterID);
}
WorldServer.Send(grp);
}
public void Send(SMSG msgID, BinWriter data)
{
try {
ServerPacket pkg = new ServerPacket(msgID);
pkg.Write(data.GetBuffer(), 0, (int)data.BaseStream.Length);
pkg.Finish();
pkg.AddDestination(m_character.ObjectId);
WorldServer.Send(pkg);
} catch (Exception exp) {
DebugLogger.Logger.Log("", exp);
}
}
public void Send(SMSG msgID, byte[] data, int index, int count)
{
try {
ServerPacket pkg = new ServerPacket(msgID);
pkg.Write(data, index, count);
pkg.Finish();
pkg.AddDestination(m_character.ObjectId);
WorldServer.Send(pkg);
} catch (Exception exp) {
DebugLogger.Logger.Log("", exp);
}
}
public static ulong NextGUID()
{
ulong guid = m_currentGUID++;
if (m_currentGUID == m_currentMax)
{
m_currentGUID = (ulong)m_guidpool.Dequeue();
m_currentMax = (ulong)m_guidpool.Dequeue();
WorldServer.Send(new WorldPacket(WORLDMSG.ACQUIRE_GUIDS));
}
return(guid);
}
static void System(string msg, uint to)
{
ServerPacket pkg = new ServerPacket(SMSG.MESSAGECHAT);
pkg.Write((byte)CHATMESSAGETYPE.SYSTEM);
pkg.Write((int)0);
pkg.Write((ulong)0);
pkg.Write(msg);
pkg.Write((byte)0);
pkg.Finish();
pkg.AddDestination(to);
WorldServer.Send(pkg);
}
public static void DeleteDBObject(DBObject obj)
{
if (obj.PendingCreate)
{
obj.PendingDelete = true;
return;
}
RemoveDBObject(obj);
WorldPacket pkg = new WorldPacket(WORLDMSG.DELETE_DBOBJECT);
pkg.Write(obj.GetType().ToString());
pkg.Write(obj.ObjectId);
WorldServer.Send(pkg);
}
public void SendDestroyInventory(uint toCharacterID)
{
for (int i = 0; i <= (int)INVSLOT.EQUIPPEDFIRST; i++)
{
if (m_slots[i] != 0)
{
ServerPacket pkg = new ServerPacket(SMSG.DESTROY_OBJECT);
pkg.Write(m_slots[i]);
pkg.Finish();
pkg.AddDestination(toCharacterID);
WorldServer.Send(pkg);
}
}
}
public static ulong NextGUID()
{
ulong guid = m_currentGUID++;
try {
if (m_currentGUID == m_currentMax)
{
m_currentGUID = (ulong)m_guidpool.Dequeue();
m_currentMax = (ulong)m_guidpool.Dequeue();
WorldServer.Send(new WorldPacket(WORLDMSG.ACQUIRE_GUIDS));
}
} catch (Exception exp) {
DebugLogger.Log("", exp);
}
return(guid);
}
public static void CreateDBObject(DBObject obj)
{
if (obj.PendingCreate)
{
return;
}
obj.PendingCreate = true;
int id = currentRequestID++;
createDBRequests[id] = obj;
WorldPacket pkg = new WorldPacket(WORLDMSG.CREATE_DBOBJECT);
pkg.Write(id);
pkg.Write(obj.GetType().ToString());
WorldServer.Send(pkg);
}
public static void SaveDBObject(DBObject obj)
{
if (obj.Dirty == false)
{
return;
}
if (obj.PendingCreate)
{
obj.PendingSave = true;
return;
}
WorldPacket pkg = new WorldPacket(WORLDMSG.DESERIALIZE_OBJ);
pkg.Write(obj.GetType().ToString());
pkg.Write(obj.ObjectId);
obj.Serialize(pkg);
WorldServer.Send(pkg);
obj.Dirty = false;
}
public void Send(ServerPacket pkg, Vector position, float range)
{
long pos = pkg.BaseStream.Position;
foreach (MapTile tile in GetTilesInRange((int)position.X, (int)position.Y, (int)range))
{
foreach (PlayerObject player in tile.GetObjects(OBJECTTYPE.PLAYER))
{
if (position.Distance(player.Position) < range)
{
pkg.AddDestination(player.CharacterID);
}
}
}
if (pkg.BaseStream.Position > pos)
{
WorldServer.Send(pkg);
}
}
public void Enter(WorldObject obj)
{
MapTile mapTile = GetTileByLoc(obj.Position);
obj.MapTile = mapTile;
ServerPacket pkg = MakeCreatePacket(obj);
bool send = false;
foreach (MapTile tile in mapTile.Adjacents)
{
if (tile != null)
{
send |= tile.CreateObject(obj, pkg);
}
}
if (send)
{
WorldServer.Send(pkg);
}
mapTile.EnterTile(obj);
}
public override void UpdateData()
{
ServerPacket pkg = new ServerPacket(SMSG.UPDATE_OBJECT);
pkg.Write(1);
pkg.Write((byte)0); // A9 Fix by Phaze
UpdateData(pkg, false, false);
pkg.Finish();
if (MapTile != null)
{
MapTile.SendSurrounding(pkg, this);
}
ServerPacket pkg2 = new ServerPacket(SMSG.UPDATE_OBJECT);
pkg2.Write(1);
pkg2.Write((byte)0); // A9 Fix by Phaze
UpdateData(pkg2, true, true);
pkg2.Finish();
pkg2.AddDestination(this.CharacterID);
WorldServer.Send(pkg2);
}
public void GainXp(int exp, ulong targetguid)
{
ServerPacket pkg = new ServerPacket(SMSG.LOG_XPGAIN);
pkg.Write(targetguid);
pkg.Write((uint)exp);
pkg.Write((byte)0);
pkg.Write((ushort)exp);
pkg.Write((byte)0);
pkg.Write((byte)0);
pkg.Finish();
pkg.AddDestination(this.CharacterID);
WorldServer.Send(pkg);
this.Exp += exp;
this.UpdateData();
if (this.Exp >= this.NextLevelExp)
{
LevelUp();
}
}
public void SendSurrounding(ServerPacket pkg, PlayerObject notPlayer)
{
bool send = false;
foreach (MapTile tile in Adjacents)
{
if (tile != null)
{
foreach (PlayerObject player in tile.GetObjects(OBJECTTYPE.PLAYER))
{
if (notPlayer.CharacterID != player.CharacterID)
{
send = true;
pkg.AddDestination(player.CharacterID);
}
}
}
}
if (send)
{
WorldServer.Send(pkg);
}
}
public void SendSurrounding(ServerPacket pkg)
{
bool send = false;
foreach (MapTile tile in Adjacents)
{
if (tile != null)
{
ICollection Players = tile.GetObjects(OBJECTTYPE.PLAYER);
if (Players.Count > 0)
{
send = true;
foreach (PlayerObject player in Players)
{
pkg.AddDestination(player.CharacterID);
}
}
}
}
if (send)
{
WorldServer.Send(pkg);
}
}
/// <summary>
///
/// </summary>
/// <param name="obj">Object to create for the players on this maptile</param>
/// <param name="objCreationPkg">creation packet of obj</param>
/// <returns>Returns true if there was any players to send objCreationPkg to</returns>
internal bool CreateObject(WorldObject obj, ServerPacket objCreationPkg)
{
if (obj.ObjectType == OBJECTTYPE.PLAYER)
{
// we might want to change this incase there would be alot
// of objects on a single maptile cause it could possibly
// overgo the packet size limit (which is 0xFFFF or less, not sure)
// and only send one at a time or X at a time. Hopefully we
// won't have to since it's compressed...
bool ret = false;
BinWriter w = new BinWriter();
w.Write(0);
int objcount = 0;
for (int i = 0; i < (int)OBJECTTYPE.PLAYER; i++)
{
if (m_objects[i].Count > 0)
{
objcount += m_objects[i].Count;
foreach (WorldObject anObject in m_objects[i].Values)
{
anObject.AddCreateObject(w, false, true);
}
}
}
if (m_objects[(int)OBJECTTYPE.PLAYER].Count > 0)
{
ret = true;
objcount += m_objects[(int)OBJECTTYPE.PLAYER].Count;
foreach (PlayerObject plr in m_objects[(int)OBJECTTYPE.PLAYER].Values)
{
objCreationPkg.AddDestination(plr.CharacterID);
plr.AddCreateObject(w, false, true);
objcount += plr.Inventory.AddCreateInventory(w, false);
}
}
for (int i = ((int)OBJECTTYPE.PLAYER) + 1; i < (int)OBJECTTYPE.MAX; i++)
{
if (m_objects[i].Count > 0)
{
objcount += m_objects[i].Count;
foreach (WorldObject anObject in m_objects[i].Values)
{
anObject.AddCreateObject(w, false, true);
}
}
}
if (objcount > 0)
{
w.Set(0, objcount);
ServerPacket pkg = new ServerPacket(SMSG.COMPRESSED_UPDATE_OBJECT);
byte[] compressed = ZLib.Compress(w.GetBuffer(), 0, (int)w.BaseStream.Length);
pkg.Write((int)w.BaseStream.Length);
pkg.Write(compressed);
pkg.Finish();
pkg.AddDestination((obj as PlayerObject).CharacterID);
WorldServer.Send(pkg);
}
return(ret);
}
else
{
if (m_objects[(int)OBJECTTYPE.PLAYER].Count > 0)
{
foreach (PlayerObject plr in m_objects[(int)OBJECTTYPE.PLAYER].Values)
{
objCreationPkg.AddDestination(plr.CharacterID);
}
return(true);
}
return(false);
}
}
internal void Move(WorldObject obj)
{
// dunno if we are gonna do the check allowed to move check here.
// maybe make OnMove and LeaveTile return true or false
// if the object is allowed to move
MapTile newTile = GetTileByLoc(obj.Position);
MapTile oldTile = obj.MapTile;
if (newTile == oldTile)
{
oldTile.OnMove(obj);
return;
}
ADJACENT adj = oldTile.IsAdjacent(newTile);
if (adj == ADJACENT.NONE)
{
Leave(obj);
Enter(obj);
return;
}
ServerPacket createObjectPkg = MakeCreatePacket(obj);
bool sendPkg = false;
oldTile.LeaveTile(obj);
// nothing should happen with the object in this switch
// it's only for creating/destroying objects on the client
switch (adj)
{
case ADJACENT.TOPLEFT:
oldTile.AdjacentDestroyObject(ADJACENT.TOPRIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.RIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERRIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWER, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERLEFT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.TOPRIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOP, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOPLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERLEFT, obj, createObjectPkg);
break;
case ADJACENT.TOP:
oldTile.AdjacentDestroyObject(ADJACENT.LOWERLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWER, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.TOPLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOP, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOPRIGHT, obj, createObjectPkg);
break;
case ADJACENT.TOPRIGHT:
oldTile.AdjacentDestroyObject(ADJACENT.TOPLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWER, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.TOPLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOP, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOPRIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.RIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERRIGHT, obj, createObjectPkg);
break;
case ADJACENT.LEFT:
oldTile.AdjacentDestroyObject(ADJACENT.TOPRIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.RIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.TOPLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERLEFT, obj, createObjectPkg);
break;
case ADJACENT.RIGHT:
oldTile.AdjacentDestroyObject(ADJACENT.TOPLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERLEFT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.TOPRIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.RIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERRIGHT, obj, createObjectPkg);
break;
case ADJACENT.LOWERLEFT:
oldTile.AdjacentDestroyObject(ADJACENT.TOPLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOP, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOPRIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.RIGHT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LOWERRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.LOWERRIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWER, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOPLEFT, obj, createObjectPkg);
break;
case ADJACENT.LOWER:
oldTile.AdjacentDestroyObject(ADJACENT.TOPLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOP, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOPRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.LOWERLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWER, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERRIGHT, obj, createObjectPkg);
break;
case ADJACENT.LOWERRIGHT:
oldTile.AdjacentDestroyObject(ADJACENT.LOWERLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.LEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOPLEFT, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOP, obj);
oldTile.AdjacentDestroyObject(ADJACENT.TOPRIGHT, obj);
sendPkg = newTile.AdjacentCreateObject(ADJACENT.LOWERLEFT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWER, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.LOWERRIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.RIGHT, obj, createObjectPkg) ||
newTile.AdjacentCreateObject(ADJACENT.TOPRIGHT, obj, createObjectPkg);
break;
}
if (sendPkg)
{
WorldServer.Send(createObjectPkg);
}
obj.MapTile = newTile;
newTile.EnterTile(obj);
}
