public static HMessage PacketBuilder(IList <HWallItem> items, ushort header)
{
var itemsMessage = new HMessage(header);
var owners = items.GroupBy(i => i.OwnerId).Select(g => g.First());
itemsMessage.WriteInteger(owners.Count());
foreach (var owner in owners)
{
itemsMessage.WriteInteger(owner.OwnerId);
itemsMessage.WriteString(owner.OwnerName);
}
itemsMessage.WriteInteger(items.Count);
foreach (var obj in items)
{
itemsMessage.WriteString(obj.Id.ToString());
itemsMessage.WriteInteger(obj.TypeId);
itemsMessage.WriteString(obj.Location);
itemsMessage.WriteString(obj.State);
itemsMessage.WriteInteger(obj.SecondsToExpiration);
itemsMessage.WriteInteger((int)obj.UsagePolicy);
itemsMessage.WriteInteger(obj.OwnerId);
}
return(itemsMessage);
}
public static HMessage PacketBuilder(IList <HFloorObject> objects, ushort header)
{
var ret = new HMessage(header);
var l = objects.ToList();
var ownersCount = l.GroupBy(x => x.OwnerId).Select(g => g.First()).ToList();
ret.WriteInteger(ownersCount.Count());
foreach (var owner in ownersCount)
{
ret.WriteInteger(owner.OwnerId);
ret.WriteString(owner.OwnerName);
}
ret.WriteInteger(objects.Count);
foreach (var obj in objects)
{
ret.WriteInteger(obj.Id);
ret.WriteInteger(obj.TypeId);
ret.WriteInteger(obj.Tile.X);
ret.WriteInteger(obj.Tile.Y);
ret.WriteInteger((int)obj.Facing);
ret.WriteString(obj.Tile.Z.ToString("0.0", CultureInfo.InvariantCulture));
ret.WriteString("1.0");
ret.WriteInteger(0); // LinkedPortId (maybe not a good idea but we don't know the value)
ret.WriteInteger(obj.Category);
var stuff = obj.Stuff.ToList();
foreach (var thing in stuff)
{
if (thing is string)
{
ret.WriteString((string)thing);
}
else if (thing is int)
{
ret.WriteInteger((int)thing);
}
}
ret.WriteInteger(obj.SecondsToExpiration);
ret.WriteInteger((int)obj.UsagePolicy);
ret.WriteInteger(obj.OwnerId);
if (obj.TypeId < 0)
{
ret.WriteString(""); // no idea about this one tbh
}
}
return(ret);
}
public static HMessage MakeEntity(int Id, int Index, int X, int Y, int Z, string name, string motto, HGender gender, int entitytype, string figureid, string FavouriteGroup, ushort header)
{
var ret = new HMessage(header);
ret.WriteInteger(1);
ret.WriteInteger(Id);
ret.WriteInteger(Index);
ret.WriteInteger(X);
ret.WriteInteger(Y);
ret.WriteInteger(Z);
ret.WriteString(name);
ret.WriteString(motto);
ret.WriteInteger((int)gender);
ret.WriteInteger(entitytype);
ret.WriteString(figureid);
ret.WriteString(FavouriteGroup);
return(ret);
}
private Task SendInterceptedDataResponseAsync(string stamp, DataInterceptedEventArgs args)
{
var interceptedData = new HMessage((ushort)(args.Packet.Destination + 6));
interceptedData.WriteString(stamp);
interceptedData.WriteInteger(args.Step);
interceptedData.WriteBoolean(args.IsBlocked);
interceptedData.WriteInteger(args.Packet.Length + 4);
interceptedData.WriteBytes(args.Packet.ToBytes());
return(_remoteContractor.SendPacketAsync(interceptedData));
}
public static HMessage TurnEntityToPet(HEntity entity, int petid, int pettypeid, string petcolor, ushort header)
{
var ret = new HMessage(header);
ret.WriteInteger(1);
ret.WriteInteger(entity.Id);
ret.WriteString(entity.Name);
ret.WriteString(entity.Motto);
ret.WriteString(string.Concat(new object[]
{
petid,
" ",
pettypeid,
" ",
petcolor
}));
ret.WriteInteger(entity.Index);
ret.WriteInteger(entity.Tile.X);
ret.WriteInteger(entity.Tile.Y);
ret.WriteString("0.0");
ret.WriteInteger(0);
ret.WriteInteger(2);
ret.WriteInteger(0);
ret.WriteInteger(entity.Id);
ret.WriteString(entity.Name);
ret.WriteBoolean(false);
ret.WriteInteger(0);
ret.WriteInteger(0);
ret.WriteBoolean(false);
ret.WriteInteger(0);
ret.WriteString("std");
return(ret);
}
public static HMessage PacketBuilder(IList <HEntity> Users, ushort header)
{
var ret = new HMessage(header);
ret.WriteInteger(Users.Count());
foreach (var obj in Users)
{
ret.WriteInteger(obj.Id);
ret.WriteInteger(obj.Index);
ret.WriteInteger(obj.Tile.X);
ret.WriteInteger(obj.Tile.Y);
ret.WriteInteger(0);
ret.WriteString(obj.Name);
ret.WriteString(obj.Motto);
ret.WriteInteger((int)obj.Gender);
ret.WriteInteger(obj.EntityType);
ret.WriteString(obj.FigureId);
ret.WriteString(obj.FavoriteGroup);
return(ret);
}
return(null);
}
public void SendMessage(int itemId)
{
HMessage message = new HMessage(Form.wiredEffectData);
message.WriteBoolean(false);
message.WriteInteger(5);
message.WriteInteger(0);
message.WriteInteger(3393);
message.WriteInteger(itemId);
message.WriteString("");
message.WriteInteger(0);
message.WriteInteger(0);
message.WriteInteger(0);
message.WriteInteger(5);
message.WriteInteger(0);
Form.connection.SendToClientAsync(message);
}
public void SendMessage(int itemId)
{
HMessage message = new HMessage(Form.wiredTriggerData);
message.WriteBoolean(false);
message.WriteInteger(5);
message.WriteInteger(0);
message.WriteInteger(3383);
message.WriteInteger(itemId);
message.WriteString(string.Empty);
message.WriteInteger(1);
message.WriteInteger(0);
message.WriteInteger(0);
message.WriteInteger(0);
message.WriteInteger(0);
Form.connection.SendToClientAsync(message);
}
public void SendMessage(int itemId)
{
HMessage message = new HMessage(Form.wiredEffectData);
message.WriteBoolean(false);
message.WriteInteger(5);
message.WriteInteger(0);
message.WriteInteger(7555);
message.WriteInteger(itemId);
message.WriteString(((char)9).ToString());
message.WriteInteger(1);
message.WriteInteger(0);
message.WriteInteger(0);
message.WriteInteger(27);
message.WriteInteger(0);
message.WriteInteger(0);
Form.connection.SendToClientAsync(message);
}
public async Task InitPages(Page page)
{
Console.WriteLine($"Init page> {page.Name}");
Console.WriteLine("{l}{u:3213}{i:" + page.Id + "}{i:-1}{s:NORMAL}");
HMessage message = new HMessage(GetPage);
message.WriteInteger(page.Id);
message.WriteInteger(-1);
message.WriteString("NORMAL");
await this.Connection.SendToServerAsync(message);
foreach (Page subPage in page.SubPages)
{
await Task.Delay(300);
await InitPages(subPage);
}
}
public HMessage Compose(IEnumerator <Token> e, bool isOutgoing, bool consumeToken = true)
{
if (Game == null)
{
throw new Exception("The game has not been disassembled, unable to parse packet");
}
ushort header;
if (consumeToken)
{
e.AssertTokenType("header", new[] { TokenType.Integer, TokenType.Identifier });
}
else
{
e.Current.AssertTokenType("header", new[] { TokenType.Integer, TokenType.Identifier });
}
if (e.Current.Type == TokenType.Integer)
{
header = ushort.Parse(e.Current.Value);
}
else
{
string messageName = e.Current.Value;
var identifiers = isOutgoing ? (Identifiers)Out : In;
if (!identifiers.TryGetId(messageName, out header))
{
throw new Exception($"Unknown {(isOutgoing ? "outgoing" : "incoming")} message name: {messageName}");
}
}
var packet = new HMessage(header);
while (e.MoveNext())
{
if (e.Current.Type == TokenType.NewLine ||
e.Current.Type == TokenType.SequenceTerminator)
{
break;
}
switch (e.Current.Type)
{
case TokenType.Identifier:
{
var identifier = e.Current.Value.ToLower();
switch (identifier)
{
case "true": packet.WriteBoolean(true); break;
case "false": packet.WriteBoolean(false); break;
case "b": // byte
{
e.AssertTokenType("':'", TokenType.Colon);
byte[] bytes = new byte[1] {
e.ParseByte()
};
packet.WriteBytes(bytes);
}
break;
case "s": // short
{
e.AssertTokenType("':'", TokenType.Colon);
packet.WriteShort((ushort)e.ParseShort());
}
break;
case "i": // int
{
e.AssertTokenType("':'", TokenType.Colon);
packet.WriteInteger(e.ParseInt());
}
break;
case "a": // byte array
{
e.AssertTokenType("':'", TokenType.Colon);
byte[] bytes = e.ParseByteArray();
packet.WriteInteger(bytes.Length);
packet.WriteBytes(bytes);
}
break;
default:
throw new Exception($"Unexpected identifier '{identifier}'");
}
}
break;
case TokenType.Subtract:
case TokenType.Integer:
{
bool negate = e.Current.Type == TokenType.Subtract;
if (negate)
{
e.AssertTokenType("integer", TokenType.Integer);
}
var s = (negate ? "-" : "") + e.Current.Value;
if (!int.TryParse(s, out int value))
{
throw new Exception($"Invalid integer value: {s}");
}
packet.WriteInteger(value);
}
break;
case TokenType.String: packet.WriteString(e.Current.Value); break;
case TokenType.ByteArray:
{
byte[] bytes = ParserExtensions.ParseByteArray(e.Current);
packet.WriteBytes(bytes);
}
break;
case TokenType.NewLine: break;
default:
throw new Exception($"Unexpected token type {e.Current.Type}");
}
}
return(packet);
}
private async Task ReceiveRemoteModuleDataAsync()
{
try
{
HMessage packet = await RemoteModule.ReceivePacketAsync().ConfigureAwait(false);
if (packet == null)
{
DataAwaiters.Values.ToList().ForEach(awaiter =>
{
if (awaiter != null)
{
awaiter.SetResult(null);
}
});
RemoteModule = null;
Task grabRemoteModuleTask =
GrabRemoteModuleAsync();
return;
}
var response = new HMessage(packet.Header);
#region Switch: packet.Header
switch (packet.Header)
{
default: response = null; break;
case 0:
{
response.WriteShort((ushort)Hotel);
break;
}
case 1:
{
response.WriteString(Game?.Location);
if (!string.IsNullOrWhiteSpace(Game?.Location))
{
response.WriteString(Path.GetFullPath("Hashes.ini"));
}
break;
}
case 2:
{
response.WriteString(GameData.Source);
break;
}
case 3:
{
response.WriteShort(Connection.Port);
response.WriteString(Connection.Host);
response.WriteString(Connection.Address);
break;
}
case 4:
{
if (Connection != null)
{
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
await Connection.SendToClientAsync(
data).ConfigureAwait(false);
response = null;
}
break;
}
case 5:
{
if (Connection != null)
{
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
await Connection.SendToServerAsync(
data).ConfigureAwait(false);
response = null;
}
break;
}
case 6:
case 7:
{
string stamp = packet.ReadString();
if (DataAwaiters.ContainsKey(stamp))
{
var destination = (HDestination)(packet.Header - 6);
int step = packet.ReadInteger();
bool isBlocked = packet.ReadBoolean();
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
var interPacket = new HMessage(data, destination);
var args = new DataInterceptedEventArgs(interPacket, step, (destination == HDestination.Server));
args.IsBlocked = isBlocked;
DataAwaiters[stamp].SetResult(args);
response = null;
}
break;
}
}
#endregion
if (response != null)
{
await RemoteModule.SendPacketAsync(response).ConfigureAwait(false);
}
}
finally
{
if (RemoteModule != null)
{
Task receiveRemModuDataTask =
ReceiveRemoteModuleDataAsync();
}
}
}
private void HandleData(DataInterceptedEventArgs e)
{
ModuleItem[] moduleItems = Contractor.GetModuleItems();
bool isOutgoing = (e.Packet.Destination == HDestination.Server);
if (Contractor.RemoteModule != null)
{
string stamp = DateTime.Now.Ticks.ToString();
stamp += isOutgoing;
stamp += e.Step;
Contractor.DataAwaiters[stamp] =
new TaskCompletionSource <DataInterceptedEventArgs>();
var interceptedData = new HMessage((ushort)(e.Packet.Destination + 4));
interceptedData.WriteString(stamp);
interceptedData.WriteInteger(e.Step);
interceptedData.WriteBoolean(e.IsBlocked);
interceptedData.WriteInteger(e.Packet.Length + 4);
interceptedData.WriteBytes(e.Packet.ToBytes());
Contractor.RemoteModule.SendAsync(interceptedData);
DataInterceptedEventArgs args = Contractor
.DataAwaiters[stamp].Task.Result;
if (args != null)
{
e.Packet = args.Packet;
e.IsBlocked = args.IsBlocked;
}
Contractor.DataAwaiters.Remove(stamp);
}
foreach (ModuleItem moduleItem in moduleItems)
{
if (!moduleItem.IsInitialized)
{
continue;
}
ITExtension extension = moduleItem.Extension;
if (extension == null)
{
continue;
}
try
{
if (isOutgoing)
{
extension.HandleOutgoing(e);
extension.Triggers?.HandleOutgoing(e);
}
else
{
extension.HandleIncoming(e);
extension.Triggers?.HandleIncoming(e);
}
}
catch (Exception ex)
{
if (!e.HasContinued)
{
e.Continue();
}
WriteLog(ex);
DisplayModuleException(moduleItem, e, ex);
}
}
}
