CRASHES MY RUNELITE#29
Open
raysdigitalfootprint wants to merge 698 commits into
Open
Conversation
7500 coins for no wilderness diary or only easy diary, 6000 coins for medium diary, 3750 coins for hard diary, and free for elite diary
The south rocks near the magical rocks mine cannot be used to go from east to west, because `You could climb down here, but it is too uneven to climb up.`
The dungeon access is assumed to be almost completion of the Zogre Flesh Eaters quest
* Added check for region override * Added regional overrides for transports falling outside of the region locks. * Added tests for the seasonal region override behaviour * Updated regions and region overrides
* Fix costConsumableTeleportationItems not applied to Quetzal whistle (#468) * Prevent labels from being drawn at the same spot * Now showing quantities to pick up
* disable large doors in Castle Wars due to world distinction issues * Remove the lines to be safe
* Add lumber yard fence
* Added conditionals for teleports on a sailing ship to display a message to embark to resume pathfinding * Added a teleport filter when embarked
* Store pathfinder nodes in parallel primitive arrays Replace the per-tile Node/TransportNode objects with a structure-of-arrays store (NodeGraph) indexed by int ids, plus primitive int frontier structures (IntDeque, IntMinHeap). Heavy searches explore hundreds of thousands of tiles, and the old design allocated one object per tile. Packing the fields into shared arrays collapses that to a handful of arrays and removes the per-object header overhead, while releasing them once the search ends. * Reuse empty requirement collections and skill arrays in transports Most transports declare no quests, var requirements, or skill levels, yet each one allocated its own HashSet (plus backing HashMap) and a 26-int skill array. Default these to shared immutable empties and only allocate when a real requirement is present. Measured against the loaded data this removes ~80k objects (~22.6k empty sets and ~13.3k all-zero skill arrays) from the static transport graph. * Intern shared transport requirement objects at load Transports built from the wiki data very commonly share identical item and var requirements (every fairy ring needs the same staff; many shortcuts share one diary varbit), yet each transport held its own copy. A post-load pass with local interning pools now shares equal TransportItems and VarRequirement instances (and the int[] arrays inside item requirements). Measured on the full dataset this collapses ~4,900 requirement wrapper objects to ~470 distinct, plus the reclaimed backing arrays, with no search-time cost (interning runs once at load). * Flatten collision map regions into shared arrays Each of the ~2,664 collision regions held its own FlagMap + BitSet + long[] (~3 objects per region, ~8k total). Pack every region's bits into one shared long[] with a per-region word-offset table, read with the same word/bit math BitSet used. SplitFlagMap already routes a coordinate to the region that contains it, so FlagMap's per-region bounds checks were redundant and are dropped. Removes ~8k objects on the hottest read path with no behaviour change - the exact-path-length pathfinding tests pass unchanged - and slightly better cache locality. * Open-address PrimitiveIntHashMap to drop per-entry nodes Replace the IntNode-per-entry bucket design with two parallel arrays (int[] keys + Object[] values), using a non-null value as the occupancy marker so an int key of 0 needs no sentinel. The transport lookup map is the only user, and the two packed maps held one IntNode per origin tile (~11.5k each), so this removes ~23k node objects plus their bucket arrays at rest and improves lookup cache locality. The full PrimitiveIntHashMap test contract (collection-append on duplicate keys, edge keys, zero load factor, rehash, fullness) is preserved. * Store transports per origin as flat arrays instead of Sets TransportAvailability kept a HashSet per origin tile (shared between a boxed-key Map and the primitive packed map), one of the larger remaining at-rest object sources. Store the transports as flat Transport[] arrays instead; the per-origin HashSet/HashMap wrappers are now used only transiently while building and are not retained. Two views are kept, sharing their arrays: the pathfinding map (POH origin tiles preserved so a search from a POH tile still resolves) and the coarse display map used by overlays (POH origins collapsed to the canonical landing tile). This removes the per-origin Set/HashMap/HashMap-node layer from both availabilities. * Flatten allTransports to a Transport array PathfinderConfig.allTransports was a Map<Integer, Set<Transport>> retained for the plugin's lifetime - one HashSet (plus its HashMap, membership nodes, and a boxed Integer key) per origin tile, which profiling showed was roughly half of the remaining at-rest objects. But refreshTransports only iterates the transports flat (it re-derives each origin from the transport), and remapPohDestinations only touches values, so the map structure is unnecessary. Flatten it to a Transport[] at construction and let the loader's map be garbage collected. The loader still returns the map, which the tests rely on. * Store transport quest requirements as an EnumSet Quest requirements are keyed on the Quest enum, so a non-empty set is now a compact EnumSet (a single bitmask object) instead of a HashSet plus its backing HashMap and per-element nodes. Most transports have no quests and keep the shared empty set; the ~3.4k that do shed ~3 objects each. EnumSet is a Set<Quest>, so all callers and tests are unchanged. * Deduplicate transport requirement sets at load internRequirements already shared individual VarRequirement and TransportItems instances, but each transport still held its own Set wrapper for its var and quest requirements. Identical requirements are very common across the permuted transport rows, so intern the requirement Sets themselves too: transports with equal var/quest requirements now share one read-only Set (and EnumSet) instance instead of a per-transport copy. Runs in the existing post-load interning pass, so transport allocation order is unchanged. * Intern transport display strings; consolidate interning pools Extend the load-time interning to a transport's displayInfo/objectInfo labels, deduplicating strings repeated across transport rows along with their char[]/byte[] backing. The growing set of per-call dedup pools is consolidated behind a LoadInterner holder so internRequirements takes a single argument. * Drop volatile from NodeGraph arrays to restore pathfinding speed The structure-of-arrays refactor cut memory as intended, but marking the six per-node arrays volatile made every accessor re-read the array reference and blocked the JIT from caching the base or eliminating bounds checks. The hot loop touches these hundreds of times per node, slowing a 143-step search from ~176ms to ~294ms (~1.6x). The arrays don't need to be volatile: the partial path is published to the render thread by the single volatile Pathfinder.bestLastNode handoff, and the walk methods already snapshot references into locals and tolerate a null or stale-but-valid (Arrays.copyOf preserves indices) array. * Use multiplicative hash in PrimitiveIntHashMap to fix probe clustering The open-addressed table used a cheap xor-shift hash. Packed world points of nearby tiles differ only in a few low bits, so spatially-clustered transport origins (agility shortcuts, boats, etc.) landed in clustered table slots. With linear probing that primary clustering produced long probe runs on the per-tile transport miss lookups, costing ~50ms on a transport-heavy 657-step search. Switching to a Fibonacci-style multiply plus xorshift avalanche spreads the keys, bringing open addressing back in line with the old chained map (167ms avg vs 161ms) while keeping its per-entry-object memory saving, and faster than the original chained implementation on master (192ms). * Hoist repeated node-field reads in pathfinder hot loop When nodes were objects the JIT cached node.isTile()/node.packedPosition in registers across the per-node checks for free. As int ids into the structure-of-arrays NodeGraph, each graph.xxx(id) call re-indexes a backing array (with a bounds check), and the main loop and addNeighbors read the same node's tile-ness and position several times each. Read each node's isTile/packedPosition once and pass them down, and read each neighbour's fields once per iteration. This removes several array indexings per node. The redundancy is absorbed by wide desktop CPUs but is costly on narrower/smaller-cache machines; on a constrained -Xmx512m G1 heap this cut a 2.47M-node exhaustive search from ~394ms to ~355ms avg. Exploration is unchanged (identical node count and path). --------- Co-authored-by: Zoinkwiz <29153234+Zoinkwiz@users.noreply.github.com>
* Add legends guild crevice shortcut Add legends guild crevice shortcut * Add legends guild ladder Add legends guild ladder * Formatting fix Formatting fix * Fix tab formatting Fix tab formatting
#255) - Updated seasonal_transports.tsv and transports.tsv to improve formatting and add new entries. - Introduced AgilityShortcutTest to verify that all AgilityShortcut enum constants have corresponding TSV entries. - Added ObservatoryGrappleShortcutTest to validate the transport requirements and properties for the Observatory Grapple Shortcut. - Enhanced transport data extraction methods to ensure comprehensive coverage of agility shortcuts and their requirements.
* Add PoH portal inside to outside entries * Add entries for the non-default PoH teleports (inside is selected but we want to tele outside, or outside is selected but we want to tele inside) * Add entries for the non-default PoH tablets. * fix missing trailing tabs * remove extra tab
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
18 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
For some reason when I set a path it will randomly increase my RAM useage to 1.5gb. Even if i clear the path and log out it fills my ram to 1.5gb and my frames drop to 1fps. All other apps still working fine. This happens randomly, maybe 1 in 3 paths I set. Paths can be simple, no obsticles ect and short path.
not sure if it matters;
PC 16gb ddr4 ram, i7 10700k, 3070ti, 2t nvme ssd