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)); }