public static void FreeSafe(ServerToClientMessage msg)
{
if (msg.IsAllocatedFromPool)
{
msg.IsAllocatedFromPool = false;
safePool.Free(msg);
}
}
public static void CreateChatMessage(ChatType type, string message, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("wm.Sender can't be NULL on outgoing messages."));
wm.MessageType = MessageType.S2C_ChatMessage;
wm.Code = (int)type;
wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
wm.DeliveryChannel = 0;
wm.Data = message;
}
/// <summary>
/// Formats the ServerToClientMessage with entity data.
/// Data holds colon separated entity data.
/// Buffer holds 8 bytes for Id(4), TypeId(4)
/// </summary>
/// <param name="e">The entity instance to read data from.</param>
/// <param name="wm">The ServerToClientMessage instance that will hold the data.</param>
public static void CreateAddEntityToZoneMessage(Entity e, ServerToClientMessage wm)
{
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = new byte[8];
wm.Code = (int)PlayerAction.AddEntity;
wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
wm.DeliveryChannel = 1;
BitConverter.GetBytes(e.Id).CopyTo(wm.Buffer, 0); // 4b: 0-3 entity Id
BitConverter.GetBytes(e.TypeId).CopyTo(wm.Buffer, 4); // 1=character, 2=structure, so on,
wm.Data = GenerateEntityFormat(e);
}
public static void CreateDamageEntityMessage(Entity to, Entity from, int amount, ServerToClientMessage wm)
{
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = BitConverter.GetBytes(to.Id);
wm.Code = (int)PlayerAction.Damage;
wm.DeliveryMethod = NetDeliveryMethod.ReliableUnordered;
wm.DeliveryChannel = 0;
string data = amount.ToString();
if (from != null)
data = String.Format("{0}:{1}", amount, from.Id);
wm.Data = data;
}
public static ServerToClientMessage Copy(ServerToClientMessage a, NetConnection sender)
{
ServerToClientMessage wm = safePool.Get();
Debug.Assert(!wm.IsAllocatedFromPool, "Allocated ServerToClientMessage from pool which is in use!");
wm.IsAllocatedFromPool = true;
wm.Sender = sender;
wm.MessageType = a.MessageType;
wm.Buffer = a.Buffer;
wm.Data = a.Data;
wm.Code = a.Code;
wm.TurnNumber = a.TurnNumber;
wm.DeliveryMethod = a.DeliveryMethod;
wm.DeliveryChannel = a.DeliveryChannel;
return wm;
}
/// <summary>
/// Formats a ServerToClientMessage with logout message data.
/// </summary>
/// <param name="mpr">Player record of the player logging out.</param>
/// <param name="turnNumber">Current turn number.</param>
/// <param name="wm"></param>
public static void CreateCharacterLogoutMessage(MasterPlayerRecord mpr, int turnNumber, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("Character has null sender, this will crash the MessageSender!"));
if (mpr.State != ClientState.InWorld)
wm.MessageType = mpr.LogoutCharacterGranted ? MessageType.S2C_PlayerLoggedOut : MessageType.S2C_LogoutDenied;
else
wm.MessageType = mpr.LogoutCharacterGranted ? MessageType.S2C_CharacterLoggedOut : MessageType.S2C_LogoutDenied;
wm.Code = (int)PlayerAction.RemoveEntity;
wm.Data = mpr.LogoutCharacterGranted ? "Logout OK" : "Logout denied";
wm.TurnNumber = turnNumber;
wm.Buffer = BitConverter.GetBytes(mpr.CharacterId);
wm.DeliveryChannel = 0;
wm.DeliveryMethod = NetDeliveryMethod.ReliableUnordered;
}
private void HandleDamage(ServerToClientMessage wm)
{
int entityId = BitConverter.ToInt32(wm.Buffer, 0);
Entity entity = zoneManager.GetEntity(entityId);
Entity from = null;
if (entity != null)
{
string[] damageData = wm.Data.Split(':');
int fromId = -1;
int damageAmount = int.Parse(damageData[0]);
if (damageData.Length > 1)
{
fromId = int.Parse(damageData[1]);
from = zoneManager.GetEntity(fromId);
if (from != null)
context.WorldManager.FireShot(from, entity);
}
Logger.Output(this, "HandleDamage() Doing {0} damage to entity ID {1}", damageAmount, entityId);
}
else
Logger.Output(this, "HandleDamage() failed to damage entity ID {0}, doesn't exist.", entityId);
}
public static void CreateTeleportMessage(Zone newZone, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("wm.Sender can't be NULL on outgoing messages."));
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = null;
wm.Code = (int)PlayerAction.Teleport;
wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
wm.DeliveryChannel = 0;
StringBuilder sb = new StringBuilder();
sb.Append("#Z");
sb.Append(newZone.Id);
sb.Append(":");
sb.Append(newZone.Name);
sb.Append(":");
sb.Append(newZone.Width);
sb.Append(":");
sb.Append(newZone.Height);
foreach (Entity entity in newZone.AllEntities)
{
if (entity is Character)
{
sb.Append("#C");
sb.Append(((Character)entity).ToFormatString());
}
else
{
sb.Append("#E");
sb.Append(entity.TypeId);
sb.Append("|");
sb.Append(GenerateEntityFormat(entity));
}
}
wm.Data = sb.ToString();
}
/// <summary>
/// Formats the ServerToClientMessage with zone data.
/// Data holds colon separated entity data.
/// </summary>
/// <param name="zones">The zone instance(s) to read data from.</param>
/// <param name="wm">The ServerToClientMessage instance that will hold the data.</param>
public static void CreateZoneSyncMessage(IEnumerable<Zone> zones, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("wm.Sender can't be NULL on outgoing messages."));
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = null;
wm.Code = (int)PlayerAction.AddZone;
wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
wm.DeliveryChannel = 1;
const string ZONE_DELIMITER = "#Z";
const string CHARACTER_DELIMITER = "#C";
const string ENTITY_DELIMITER = "#E";
StringBuilder sb = new StringBuilder();
// Build a list of entities in zones.
foreach (Zone zone in zones)
{
sb.Append(ZONE_DELIMITER);
sb.Append(zone.Id);
sb.Append(":");
sb.Append(zone.Name);
sb.Append(":");
sb.Append(zone.Width);
sb.Append(":");
sb.Append(zone.Height);
foreach (Entity entity in zone.AllEntities)
{
if (entity is Character)
{
sb.Append(CHARACTER_DELIMITER);
sb.Append(((Character)entity).ToFormatString());
}
else
{
sb.Append(ENTITY_DELIMITER);
sb.Append(entity.TypeId);
sb.Append("|");
sb.Append(GenerateEntityFormat(entity));
}
}
}
wm.Data = sb.ToString();
}
/// <summary>
/// Formats a RemoveEntity zone message.
/// </summary>
/// <param name="entity">The entity to be removed.</param>
/// <param name="wm">The ServerToClientMessage instance that will hold the data.</param>
public static void CreateRemoveEntityFromZoneMessage(Entity entity, ServerToClientMessage wm)
{
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = BitConverter.GetBytes(entity.Id);
wm.Code = (int)PlayerAction.RemoveEntity;
wm.DeliveryMethod = NetDeliveryMethod.ReliableUnordered;
wm.DeliveryChannel = 0;
wm.Data = null;
}
/// <summary>
/// Formats a RemoveZone message.
/// </summary>
/// <param name="zones">The zone instance(s) to be removed from the client.</param>
/// <param name="wm">The ServerToClientMessage instance that willhold the data.</param>
public static void CreateRemoveZoneMessage(IEnumerable<Zone> zones, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("wm.Sender can't be NULL on outgoing messages."));
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Buffer = null;
wm.Code = (int)PlayerAction.RemoveZone;
wm.DeliveryMethod = NetDeliveryMethod.ReliableUnordered;
wm.DeliveryChannel = 0;
StringBuilder sb = new StringBuilder();
foreach (Zone zone in zones)
{
sb.Append(zone.Id);
sb.Append(":");
}
wm.Data = sb.ToString();
}
private void HandleMoveEntity(ServerToClientMessage wm)
{
}
private void HandleRemoveZone(ServerToClientMessage wm)
{
string[] zones = wm.Data.Split(':');
for (int i = 0; i < zones.Length; i++)
{
// Make sure it's an actual ID
if (string.IsNullOrWhiteSpace(zones[i]))
continue;
// Make sure the zone exists.
Zone zone = zoneManager.GetZone(Convert.ToInt32(zones[i]));
if (zone == null)
continue;
// Finally remove the zone.
zoneManager.RemoveZone(zone.Id);
}
}
private void SendChannelMessage(int channel, ServerToClientMessage wm)
{
LinkedNode<MasterPlayerRecord> node = context.Mpt.First;
while (node != null)
{
Character c = (Character)node.Value.pCharacter;
if (c.Channels.Contains(channel))
c.MessageBuffer.Add(ServerToClientMessage.Copy(wm, c.Sender));
node = node.Next;
}
}
private void HandleZoneMessage(ServerToClientMessage wm)
{
Entity e;
// Check action and act
PlayerAction a = (PlayerAction)wm.Code;
switch (a)
{
case PlayerAction.AddEntity:
case PlayerAction.MoveEntity:
case PlayerAction.RemoveEntity:
case PlayerAction.AddZone:
case PlayerAction.RemoveZone:
case PlayerAction.Attack:
case PlayerAction.Damage:
case PlayerAction.Move:
case PlayerAction.Pickup:
case PlayerAction.Drop:
case PlayerAction.Use:
case PlayerAction.EquipmentChange:
case PlayerAction.EquipmentSync:
case PlayerAction.Teleport:
case PlayerAction.PlayerDied:
case PlayerAction.InventoryChange:
case PlayerAction.InventorySync:
case PlayerAction.InvalidAction:
case PlayerAction.InvalidMove:
case PlayerAction.InvalidTarget:
break;
}
Logger.Output(this, "HandleZoneMessage() type {0}", a);
}
private void ProcessZoneMessage(ServerToClientMessage wm)
{
// Check action and act
PlayerAction a = (PlayerAction)wm.Code;
switch (a)
{
case PlayerAction.AddEntity:
HandleAddEntity(wm);
break;
case PlayerAction.MoveEntity:
HandleMoveEntity(wm);
break;
case PlayerAction.RemoveEntity:
HandleRemoveEntity(wm);
break;
case PlayerAction.Damage:
HandleDamage(wm);
break;
case PlayerAction.AddZone:
HandleAddZone(wm);
break;
case PlayerAction.RemoveZone:
HandleRemoveZone(wm);
break;
case PlayerAction.Teleport:
HandleTeleport(wm);
break;
case PlayerAction.InvalidAction:
break;
}
Logger.Output(this, "HandleZoneMessage() type {0}", a);
}
private void ProcessChatMessage(ServerToClientMessage wm)
{
int channel = wm.Code;
string message = wm.Data;
context.Gui.AddMessage(2, message);
}
private void HandleTeleport(ServerToClientMessage wm)
{
string[] data = wm.Data.Remove(0, 1).Split('#');
for (int i = 0; i < data.Length; i++)
{
string key = data[i].Substring(0, 1);
string value = data[i].Substring(1, data[i].Length - 1);
if (key == "Z")
{
// id:name:width:height
string[] zoneInfo = value.Split(':');
int id = Convert.ToInt32(zoneInfo[0]);
if (zoneManager.ZoneExists(id))
{
Logger.Output(this, "HandleTeleport() Removing existing zone {0}.", id);
zoneManager.RemoveZone(id);
}
int width = Convert.ToInt32(zoneInfo[2]);
int height = Convert.ToInt32(zoneInfo[3]);
Zone zone = new Zone();
zone.Initialize(id, zoneInfo[1], width, height);
zoneManager.AddZone(zone);
int oldZone = playerCharacter.Zone;
zoneManager.MoveEntity(playerCharacter, zone);
zoneManager.RemoveZone(oldZone);
Logger.Output(this, "HandleTeleport() Zone (Id:{0}, Name:{1}, Size:{2}x{3}", id, zoneInfo[1], width, height);
}
else if (key == "C")
{
Character character = new Character(value);
zoneManager.AddEntity(character);
Logger.Output(this, "HandleTeleport() Character (Id:{0}, Name:{1}, Pos:{2}", character.Id, character.Name, character.Position);
}
else if (key == "E")
{
int typeId = int.Parse(value.Split('|')[0]);
string entityData = value.Split('|')[1];
AddEntityFromFormat(typeId, entityData);
Logger.Output(this, "HandleTeleport() Entity sent to parser.");
}
}
}
private void HandleAddEntity(ServerToClientMessage wm)
{
int entityId = BitConverter.ToInt32(wm.Buffer, 0);
int typeId = BitConverter.ToInt32(wm.Buffer, 4);
// Entity already exists. maybe we should delete it instead of return..
if (zoneManager.GetEntity(entityId) != null)
return;
// Format and add entity based on type.
AddEntityFromFormat(typeId, wm.Data);
}
/// <summary>
/// Formats a ServerToClientMessage with InvalidAction message data.
/// Data contains a textual description which is a GP implementation detail.
/// Buffer contains 4 bytes for the player action.
/// </summary>
/// <param name="action"></param>
/// <param name="message"></param>
/// <param name="wm"></param>
public static void CreateInvalidActionMessage(PlayerAction action, string message, ServerToClientMessage wm)
{
if (wm.Sender == null)
throw (new Exception("wm.Sender can't be NULL on outgoing messages."));
wm.MessageType = MessageType.S2C_ZoneMessage;
wm.Code = (int)PlayerAction.InvalidAction;
wm.Buffer = new byte[4];
wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
wm.DeliveryChannel = 0;
wm.Data = message;
BitConverter.GetBytes((int)action).CopyTo(wm.Buffer, 0); // 4b: 0-3 player action.
}
/// <summary>
/// Just dumps the messages into the list.
/// </summary>
/// <param name="wm"></param>
private void DisplayWorldMessage(ServerToClientMessage wm)
{
if (this.InvokeRequired)
{
this.Invoke(displayMessage, wm);
}
else
{
try
{
switch (wm.MessageType)
{
case MessageType.S2C_ZoneMessage:
PlayerAction action = (PlayerAction)wm.Code;
switch (action)
{
case PlayerAction.InvalidMove:
Logger.Output(this, "InvalidMove Id: {0}", BitConverter.ToInt32(wm.Buffer, 0));
break;
default:
Logger.Output(this, "ZoneMessage action: {0}", action);
break;
}
break;
default:
Logger.Output(this, "Unhandled message type: {0}, code: {1}, data: '{2}'", wm.MessageType, wm.Code, wm.Data);
break;
}
UpdateCharacterStats();
}
catch (Exception ex)
{
Debug.WriteLine(String.Format("DisplayWorldMessag Exception: {0}", ex.Message));
}
}
}
private void HandleRemoveEntity(ServerToClientMessage wm)
{
int entityId = BitConverter.ToInt32(wm.Buffer, 0);
if (zoneManager.GetEntity(entityId) != null)
{
zoneManager.RemoveEntity(entityId);
Logger.Output(this, "HandleRemoveEntity() removing entity ID {0}.", entityId);
}
else
Logger.Output(this, "HandleRemoveEntity() failed to remove entity ID {0}, doesn't exist.", entityId);
}
