public static async Task <bool> WaitForIncomingPacketFilterAsync(PacketFilterInfo pfi, int timeout,
bool invokeHandler = true, bool fixedSize = false)
{
AutoResetEvent are = new AutoResetEvent(false);
byte[] packet = null;
Engine.AddReceiveFilter(new PacketFilterInfo(pfi.PacketID, pfi.GetConditions(), (data, info) =>
{
packet = data;
are.Set();
}));
Task filterTask = are.ToTask();
if (await Task.WhenAny(filterTask, Task.Delay(timeout)) == filterTask)
{
if (invokeHandler)
{
PacketHandler handler = IncomingPacketHandlers.GetHandler(packet[0]);
handler?.OnReceive(new PacketReader(packet, packet.Length, fixedSize));
}
}
Engine.RemoveReceiveFilter(pfi);
return(packet != null);
}
public static bool WaitForContainerContentsUse(int serial, int timeout)
{
int pos = 19;
if (Engine.ClientVersion < new Version(6, 0, 1, 7))
{
pos = 18;
}
PacketFilterInfo pfi = new PacketFilterInfo(0x3C,
new[] { PacketFilterConditions.IntAtPositionCondition(serial, pos) });
PacketWaitEntry we = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
Engine.SendPacketToServer(new UseObject(serial));
try
{
bool result = we.Lock.WaitOne(timeout);
return(result);
}
finally
{
Engine.PacketWaitEntries.Remove(we);
}
}
public static bool WaitForTarget(int timeout)
{
PacketFilterInfo pfi = new PacketFilterInfo(0x6C);
Engine.WaitingForTarget = true;
PacketWaitEntry we = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming);
try
{
do
{
bool result = we.Lock.WaitOne(timeout);
if (!result)
{
return(false);
}
if (we.Packet[6] == 0x03)
{
continue;
}
return(true);
}while (true);
}
finally
{
Engine.PacketWaitEntries.Remove(we);
Engine.WaitingForTarget = false;
}
}
public static bool WaitForProperties(object obj, int timeout)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return(false);
}
PacketFilterInfo pfi = new PacketFilterInfo(0xD6,
new[] { PacketFilterConditions.IntAtPositionCondition(serial, 5) });
PacketWaitEntry we = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
Engine.SendPacketToServer(new BatchQueryProperties(serial));
try
{
bool result = we.Lock.WaitOne(timeout);
return(result);
}
finally
{
Engine.PacketWaitEntries.Remove(we);
}
}
private void OnShardChanged(string name)
{
if (!name.Equals("Demise - AOS"))
{
return;
}
_pfi = new PacketFilterInfo(0xFA, OnStoreClick);
Engine.AddSendPreFilter(_pfi);
}
private void OnSeasonChange(byte[] arg1, PacketFilterInfo arg2)
{
if (Engine.Player != null && Engine.Player.Map == Map.Felucca)
{
Engine.SendPacketToClient(_desolationSeason, _desolationSeason.Length);
return;
}
Engine.SendPacketToClient(_standardSeason, _standardSeason.Length);
}
public static void AddRecvFilter(int client, byte packetID, PacketFilterCondition[] conditions)
{
ClientInfo ci;
if (ClientInfoCollection.GetClient(client, out ci))
{
PacketFilterInfo pfi = new PacketFilterInfo(packetID, conditions);
byte[] bytes = pfi.Serialize();
Network.SendCommand(ci.IPCServerIndex, Command.AddRecvFilterConditional, bytes);
}
}
protected override void OnChanged(bool enabled)
{
PacketFilterInfo pfi = new PacketFilterInfo(0x65, null, OnWeatherPacket);
if (enabled)
{
Engine.AddReceiveFilter(pfi);
}
else
{
Engine.RemoveReceiveFilter(pfi);
}
}
public static bool WaitForTargetOrFizzle(int timeout)
{
PacketFilterInfo targetPfi = new PacketFilterInfo(0x6C);
PacketFilterInfo fizzPfi = new PacketFilterInfo(0xC0,
new[]
{
PacketFilterConditions.IntAtPositionCondition(Engine.Player.Serial, 2),
PacketFilterConditions.ShortAtPositionCondition(0x3735, 10)
});
Engine.WaitingForTarget = true;
PacketWaitEntry targetWe = Engine.PacketWaitEntries.Add(targetPfi, PacketDirection.Incoming);
PacketWaitEntry fizzWe = Engine.PacketWaitEntries.Add(fizzPfi, PacketDirection.Incoming);
try
{
Task <bool> targetTask = Task.Run(() =>
{
do
{
bool result = targetWe.Lock.WaitOne(timeout);
if (!result)
{
return(false);
}
if (targetWe.Packet[6] == 0x03)
{
continue;
}
return(true);
}while (true);
});
Task fizzTask = Task.Run(() => fizzWe.Lock.WaitOne(timeout));
int index = Task.WaitAny(targetTask, fizzTask);
return(index == 0 && targetTask.Result);
}
finally
{
Engine.PacketWaitEntries.Remove(targetWe);
Engine.PacketWaitEntries.Remove(fizzWe);
Engine.WaitingForTarget = false;
}
}
public static bool WaitForContext(object obj, string entryName, int timeout)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id, true);
return(false);
}
AutoResetEvent are = new AutoResetEvent(false);
PacketFilterInfo pfi = new PacketFilterInfo(0xBF,
new[]
{
PacketFilterConditions.ShortAtPositionCondition(0x14, 3),
PacketFilterConditions.IntAtPositionCondition(serial, 7)
}, (bytes, info) =>
{
IEnumerable <ContextMenuEntry> entries = ParseContextMenuEntries(bytes);
ContextMenuEntry entry =
entries.FirstOrDefault(e => e.Text.Trim().ToLower().Equals(entryName.Trim().ToLower()));
if (entry == null)
{
UOC.SystemMessage(Strings.Context_menu_entry_not_found___, (int)UOC.SystemMessageHues.Yellow,
true, true);
return;
}
Engine.SendPacketToServer(new ContextMenuClick(serial, entry.Index));
are.Set();
});
Engine.AddReceiveFilter(pfi);
Engine.SendPacketToServer(new ContextMenuRequest(serial));
try
{
bool result = are.WaitOne(timeout);
return(result);
}
finally
{
Engine.RemoveReceiveFilter(pfi);
}
}
protected override void OnChanged(bool enabled)
{
PacketFilterInfo pfi = new PacketFilterInfo(0x4F, OnLightLevel);
if (enabled)
{
Engine.AddReceiveFilter(pfi);
byte[] packet = { 0x4F, (byte)Options.CurrentOptions.LightLevel };
Engine.SendPacketToClient(packet, packet.Length);
}
else
{
Engine.RemoveReceiveFilter(pfi);
}
}
public static bool ConfirmPrompt(string message, bool closable = false)
{
ConfirmPromptGump gump = new ConfirmPromptGump(message, closable);
PacketFilterInfo pfi = new PacketFilterInfo(0xB1,
new[] { PacketFilterConditions.UIntAtPositionCondition(gump.ID, 7) });
Engine.AddSendPostFilter(pfi);
gump.SendGump();
gump.AutoResetEvent.WaitOne();
Engine.RemoveSendPostFilter(pfi);
return(gump.Result);
}
public static bool WaitForPrompt(int timeout)
{
PacketFilterInfo pfi = new PacketFilterInfo(0xC2);
PacketWaitEntry packetWaitEntry = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
try
{
bool result = packetWaitEntry.Lock.WaitOne(timeout);
return(result);
}
finally
{
Engine.PacketWaitEntries.Remove(packetWaitEntry);
}
}
public static (bool Result, string Message) MessagePrompt(string message, string initialText = "", bool closable = false)
{
MessagePromptGump gump = new MessagePromptGump(message, initialText, closable);
PacketFilterInfo pfi = new PacketFilterInfo(0xB1,
new[] { PacketFilterConditions.UIntAtPositionCondition(gump.ID, 7) });
Engine.AddSendPostFilter(pfi);
gump.SendGump();
gump.AutoResetEvent.WaitOne();
Engine.RemoveSendPostFilter(pfi);
return(gump.Result, gump.Message);
}
public static bool WaitForContainerContents(int serial, int timeout)
{
PacketFilterInfo pfi = new PacketFilterInfo(0x3C,
new[] { PacketFilterConditions.IntAtPositionCondition(serial, 19) });
PacketWaitEntry we = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
try
{
bool result = we.Lock.WaitOne(timeout);
return(result);
}
finally
{
Engine.PacketWaitEntries.Remove(we);
}
}
public static bool WaitForIncomingPacket(PacketFilterInfo pfi, int timeout, Action beforeWait = null)
{
PacketWaitEntry we = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
bool result;
beforeWait?.Invoke();
try
{
result = we.Lock.WaitOne(timeout);
}
finally
{
Engine.PacketWaitEntries.Remove(we);
}
return(result);
}
protected override void OnChanged(bool enabled)
{
PacketFilterInfo pfi = new PacketFilterInfo(0xBC, OnSeasonChange);
if (enabled)
{
Engine.AddReceiveFilter(pfi);
if (Engine.Player != null && Engine.Player.Map == Map.Felucca)
{
Engine.SendPacketToClient(_desolationSeason, _desolationSeason.Length);
return;
}
Engine.SendPacketToClient(_standardSeason, _standardSeason.Length);
}
else
{
Engine.RemoveReceiveFilter(pfi);
}
}
public static bool WaitForContext(object obj, int entry, int timeout)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return(false);
}
AutoResetEvent are = new AutoResetEvent(false);
PacketFilterInfo pfi = new PacketFilterInfo(0xBF,
new[]
{
PacketFilterConditions.ShortAtPositionCondition(0x14, 3),
PacketFilterConditions.IntAtPositionCondition(serial, 7)
}, (bytes, info) =>
{
Engine.SendPacketToServer(new ContextMenuClick(serial, entry));
are.Set();
});
Engine.AddReceiveFilter(pfi);
Engine.SendPacketToServer(new ContextMenuRequest(serial));
try
{
bool result = are.WaitOne(timeout);
return(result);
}
finally
{
Engine.RemoveReceiveFilter(pfi);
}
}
public static bool WaitForGump(uint gumpId, int timeout = 30000)
{
PacketFilterInfo pfi = new PacketFilterInfo(0xDD);
if (gumpId != 0)
{
pfi = new PacketFilterInfo(0xDD,
new[] { PacketFilterConditions.UIntAtPositionCondition(gumpId, 7) });
}
PacketWaitEntry packetWaitEntry = Engine.PacketWaitEntries.Add(pfi, PacketDirection.Incoming, true);
try
{
bool result = packetWaitEntry.Lock.WaitOne(timeout);
return(result);
}
finally
{
Engine.PacketWaitEntries.Remove(packetWaitEntry);
}
}
public DemiseSearchGump(string message = "", string searchTerm = "",
IReadOnlyCollection <VendorItem> results = null) : base(100, 100)
{
_results = results;
_message = message;
_searchTerm = searchTerm;
Movable = true;
Closable = true;
Resizable = false;
Disposable = false;
AddPage(0);
AddBackground(100, 0, 600, 600, 30536);
AddLabel(140, 45, 2100, "Search Term:");
AddBackground(220, 40, 339, 30, 3000);
AddTextEntry(225, 45, 340, 30, 0, SEARCH_ENTRY_ID, searchTerm);
AddButton(620, 45, 4005, 4006, SEARCH_BUTTON, GumpButtonType.Reply, 0);
AddLabel(140, 80, 2100, message);
_pfi = new PacketFilterInfo(0xB1, new[] { PacketFilterConditions.UIntAtPositionCondition(ID, 7) });
Engine.AddSendPostFilter(_pfi);
if (_results == null)
{
return;
}
// ReSharper disable once PossibleLossOfFraction
int pages = (int)Math.Ceiling((double)(_results.Count / PER_PAGE)) + 1;
for (int i = 1; i < pages + 1; i++)
{
AddPage(i);
VendorItem[] items = _results.Skip((i - 1) * PER_PAGE).Take(PER_PAGE).ToArray();
int startY = 110;
foreach (VendorItem item in items)
{
SendProperties(item);
Bitmap art = Art.GetStatic(item.ItemID);
AddImageTiledButton(140, startY, 2328, 2328, 0, GumpButtonType.Page, i, item.ItemID, item.Hue,
40 - art.Width / 2, 30 - art.Height / 2);
AddItemProperty(item.Serial);
AddLabel(240, startY, 2100, $"Name: {item.Name}");
AddLabel(240, startY + 20, 2100, $"Shop Name: {item.ShopName}");
AddLabel(240, startY + 40, 2100, $"Price: {item.Price}");
AddButton(620, startY + 20, 4005, 4006, item.Serial, GumpButtonType.Reply, 0);
AddLabel(540, startY + 20, 2100, $"{(Map) item.Map}");
AddHtml(140, 520, 460, 20,
$"<A HREF=\"https://demisesearch.azurewebsites.net/search/{Uri.EscapeUriString( searchTerm )}\">Open results on website</A>",
false, false);
startY += 70;
}
if (i > 1)
{
AddButton(140, 540, 5603, 5607, PREVIOUS_BUTTON, GumpButtonType.Page, i - 1);
}
if (i < pages)
{
AddButton(640, 540, 5601, 5605, NEXT_BUTTON, GumpButtonType.Page, i + 1);
}
}
}
public static void AddReceiveFilter(PacketFilterInfo pfi)
{
_incomingPacketFilter.Add(pfi);
}
public static void RemoveReceiveFilter(PacketFilterInfo pfi)
{
_incomingPacketFilter.Remove(pfi);
}
/// <summary>
/// Process IPC message and fire corresponding event.
/// </summary>
private void ProcessMessage(byte[] message)
{
Command command = (Command)message[0];
switch (command)
{
case Command.Ping:
dPing ping = PingEvent;
if (ping != null)
{
ThreadPool.QueueUserWorkItem(delegate { ping(0); });
}
return;
case Command.PingResponse:
dPingResponse pingResponse = PingResponseEvent;
if (pingResponse != null)
{
ThreadPool.QueueUserWorkItem(delegate { pingResponse(0); });
}
return;
case Command.SendPacket:
dSendPacket sendPacket = SendPacketEvent;
if (sendPacket != null)
{
int caveAddress = BitConverter.ToInt32(message, 3);
PacketType packetType = (PacketType)message[7];
byte[] packet = new byte[message.Length - 8];
Buffer.BlockCopy(message, 8, packet, 0, packet.Length);
ThreadPool.QueueUserWorkItem(delegate { sendPacket(caveAddress, packetType, packet); });
}
return;
case Command.AddSendFilter:
{
dAddSendFilter addSendFilter = AddSendFilterEvent;
if (addSendFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { addSendFilter(message[1], null); });
}
return;
}
case Command.AddSendFilterConditional:
{
dAddSendFilter addSendFilter = AddSendFilterEvent;
if (addSendFilter != null)
{
PacketFilterInfo pfi = PacketFilterInfo.Deserialize(message);
ThreadPool.QueueUserWorkItem(delegate { addSendFilter((byte)pfi.PacketID, pfi.Conditions); });
}
return;
}
case Command.AddRecvFilter:
{
dAddRecvFilter addRecvFilter = AddRecvFilterEvent;
if (addRecvFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { addRecvFilter(message[1], null); });
}
return;
}
case Command.AddRecvFilterConditional:
{
dAddRecvFilter addRecvFilter = AddRecvFilterEvent;
if (addRecvFilter != null)
{
PacketFilterInfo pfi = PacketFilterInfo.Deserialize(message);
ThreadPool.QueueUserWorkItem(delegate { addRecvFilter((byte)pfi.PacketID, pfi.Conditions); });
}
return;
}
case Command.RemoveRecvFilter:
dRemoveRecvFilter removeRecvFilter = RemoveRecvFilterEvent;
if (removeRecvFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { removeRecvFilter(message[1]); });
}
return;
case Command.RemoveSendFilter:
dRemoveSendFilter removeSendFilter = RemoveSendFilterEvent;
if (removeSendFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { removeSendFilter(message[1]); });
}
return;
case Command.ClearSendFilter:
dClearSendFilter clearSendFilter = ClearSendFilterEvent;
if (clearSendFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { clearSendFilter(); });
}
return;
case Command.ClearRecvFilter:
dClearRecvFilter clearRecvFilter = ClearRecvFilterEvent;
if (clearRecvFilter != null)
{
ThreadPool.QueueUserWorkItem(delegate { clearRecvFilter(); });
}
return;
case Command.InstallSendHook:
dInstallSendHook installSendHook = InstallSendHookEvent;
if (installSendHook != null)
{
ThreadPool.QueueUserWorkItem(delegate { installSendHook(); });
}
return;
case Command.InstallRecvHook:
dInstallRecvHook installRecvHook = InstallRecvHookEvent;
if (installRecvHook != null)
{
ThreadPool.QueueUserWorkItem(delegate { installRecvHook(); });
}
return;
case Command.UninstallSendHook:
dUninstallSendHook uninstallSendHook = UninstallSendHookEvent;
if (uninstallSendHook != null)
{
ThreadPool.QueueUserWorkItem(delegate { uninstallSendHook(); });
}
return;
case Command.UninstallRecvHook:
dUninstallRecvHook uninstallRecvHook = UninstallRecvHookEvent;
if (uninstallRecvHook != null)
{
ThreadPool.QueueUserWorkItem(delegate { uninstallRecvHook(); });
}
return;
}
}
private static void OnLightLevel(byte[] arg1, PacketFilterInfo arg2)
{
byte[] packet = { 0x4F, (byte)Options.CurrentOptions.LightLevel };
Engine.SendPacketToClient(packet, packet.Length);
}
public static void RemoveSendPostFilter(PacketFilterInfo pfi)
{
_outgoingPacketPostFilter.Remove(pfi);
}
public static async Task <int> GetTargeSerialAsync(string message = "", int timeout = 30000)
{
if (string.IsNullOrEmpty(message))
{
message = Strings.Target_object___;
}
SystemMessage(message);
Random random = new Random();
return(await Task.Run(() =>
{
bool wasTargetting = Engine.TargetExists;
uint value = (uint)random.Next(1, int.MaxValue);
//TODO
PacketWriter pw = new PacketWriter(19);
pw.Write((byte)0x6C);
pw.Write((byte)0);
pw.Write(value);
pw.Write((byte)0);
pw.Fill();
AutoResetEvent are = new AutoResetEvent(false);
int serial = -1;
PacketFilterInfo pfi = new PacketFilterInfo(0x6C,
new[] { PacketFilterConditions.UIntAtPositionCondition(value, 2) },
(packet, info) =>
{
serial = (packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8) | packet[10];
are.Set();
});
try
{
Engine.AddSendFilter(pfi);
Engine.SendPacketToClient(pw);
bool result = are.WaitOne(timeout);
if (result)
{
return serial;
}
Engine.SendPacketToClient(new CancelTargetCursor(value));
SystemMessage(Strings.Timeout___);
return serial;
}
finally
{
Engine.RemoveSendFilter(pfi);
if (wasTargetting)
{
ResendTargetToClient();
}
}
}));
}
public static void AddSendPostFilter(PacketFilterInfo pfi)
{
_outgoingPacketPostFilter.Add(pfi);
}
private static void OnStoreClick(byte[] arg1, PacketFilterInfo arg2)
{
DemiseSearchGump gump = new DemiseSearchGump();
gump.SendGump();
}
public static async Task <(TargetType, TargetFlags, int, int, int, int, int)> GetTargetInfoAsync(
string message = "", int timeout = 30000)
{
if (string.IsNullOrEmpty(message))
{
message = Strings.Target_object___;
}
SystemMessage(message);
Random random = new Random();
return(await Task.Run(() =>
{
bool wasTargetting = Engine.TargetExists;
uint value = (uint)random.Next(1, int.MaxValue);
//TODO
PacketWriter pw = new PacketWriter(19);
pw.Write((byte)0x6C);
pw.Write((byte)1);
pw.Write(value);
pw.Write((byte)0);
pw.Fill();
AutoResetEvent are = new AutoResetEvent(false);
TargetType targetType = TargetType.Object;
TargetFlags targetFlags = TargetFlags.None;
int serial = 0;
int x = 0;
int y = 0;
int z = 0;
int itemID = 0;
PacketFilterInfo pfi = new PacketFilterInfo(0x6C,
new[] { PacketFilterConditions.UIntAtPositionCondition(value, 2) }, (packet, info) =>
{
targetType = (TargetType)packet[1];
targetFlags = (TargetFlags)packet[6];
serial = (packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8) | packet[10];
x = (packet[11] << 8) | packet[12];
y = (packet[13] << 8) | packet[14];
z = (packet[15] << 8) | packet[16];
itemID = (packet[17] << 8) | packet[18];
are.Set();
});
try
{
Engine.AddSendPreFilter(pfi);
Engine.SendPacketToClient(pw);
bool result = are.WaitOne(timeout);
if (result)
{
return (targetType, targetFlags, serial, x, y, z, itemID);
}
Engine.SendPacketToClient(new CancelTargetCursor(value));
SystemMessage(Strings.Timeout___);
return (targetType, targetFlags, serial, x, y, z, itemID);
}
finally
{
Engine.RemoveSendPreFilter(pfi);
if (wasTargetting)
{
ResendTargetToClient();
}
}
}));
}
private static PacketWaitEntry CreateWaitEntry(PacketFilterInfo packetFilterInfo,
PacketDirection direction = PacketDirection.Incoming)
{
return(Engine.PacketWaitEntries.Add(packetFilterInfo, direction));
}
