mirror of
https://github.com/Bubberstation/Bubberstation.git
synced 2025-12-09 07:46:20 +00:00
77823ad210
## About The Pull Request [cleans up poor namespacing on light debugging tools](93cc9070d5) [Implements a pathfinding visualization tool](ed91f69ac4) It holds a set of inputs from the client, and uses them to generate and display paths from source/target. Left click sets the source, right click sets the target. Pathmap support too, if no target is set we display the paths from every turf in the map to the source, if one is set we build a path TO it from the source. I had to add COMSIG_MOB_CLICKON to observers to make this work (tho idk why it didn't exist already), I also removed the everpresent colorblind datum from admin datums, only needs to exist if they're using it. [Adds a mutable_appearance helper that dirlocks them, wallening port which I thought might be useful here, and will likely be useful elsewhere in future](87f752e7c3) [Fixes an infinite loop in pathmaps if we tried to pull a cached path to an unreachable target, && not || 4head](10086a655d) [Fixes JPS not dealing with border objects properly. They violate some of the assumptions JPS makes, so we need to backfill them with checks. These basically read as (if the thing that should normally take this path can't reach this turf, can we?)](f56cc4dd43) ## Why It's Good For The Game Maybe deals with #80619? Adds more robust testing tools for pathfinding, should allow people to better understand/debug these systems. I added this with the idea of adding multiz support but I don't have the time for that rn. JPS will work around thindows better, that's nice. https://file.house/IrBiR0bGxoKw1jJJoxgMRQ==.mp4 ## Changelog 🆑 fix: Fixed our pathfinding logic getting deeply confused by border objects admin: Added clientside displayed pathfinding debug tools, give em a go /🆑
60 lines
3.2 KiB
Plaintext
60 lines
3.2 KiB
Plaintext
// Mutable appearances are an inbuilt byond datastructure. Read the documentation on them by hitting F1 in DM.
|
|
// Basically use them instead of images for overlays/underlays and when changing an object's appearance if you're doing so with any regularity.
|
|
// Unless you need the overlay/underlay to have a different direction than the base object. Then you have to use an image due to a bug.
|
|
|
|
// Mutable appearances are children of images, just so you know.
|
|
|
|
// Mutable appearances erase template vars on new, because they accept an appearance to copy as an arg
|
|
// If we have nothin to copy, we set the float plane
|
|
/mutable_appearance/New(mutable_appearance/to_copy)
|
|
..()
|
|
if(!to_copy)
|
|
plane = FLOAT_PLANE
|
|
|
|
/** Helper similar to image()
|
|
*
|
|
* icon - Our appearance's icon
|
|
* icon_state - Our appearance's icon state
|
|
* layer - Our appearance's layer
|
|
* atom/offset_spokesman - An atom to use as reference for the z position of this appearance.
|
|
* Only required if a plane is passed in. If this is not passed in we accept offset_const as a substitute
|
|
* plane - The plane to use for the appearance. If this is not FLOAT_PLANE we require context for the offset to use
|
|
* alpha - Our appearance's alpha
|
|
* appearance_flags - Our appearance's appearance_flags
|
|
* offset_const - A constant to offset our plane by, so it renders on the right "z layer"
|
|
**/
|
|
/proc/mutable_appearance(icon, icon_state = "", layer = FLOAT_LAYER, atom/offset_spokesman, plane = FLOAT_PLANE, alpha = 255, appearance_flags = NONE, offset_const)
|
|
var/mutable_appearance/appearance = new()
|
|
appearance.icon = icon
|
|
appearance.icon_state = icon_state
|
|
appearance.layer = layer
|
|
appearance.alpha = alpha
|
|
appearance.appearance_flags |= appearance_flags
|
|
if(plane != FLOAT_PLANE)
|
|
// You need to pass in some non null object to reference
|
|
if(isatom(offset_spokesman))
|
|
// Note, we are ok with null turfs, that's not an error condition we'll just default to 0, the error would be
|
|
// Not passing ANYTHING in, key difference
|
|
SET_PLANE_EXPLICIT(appearance, plane, offset_spokesman)
|
|
// That or I'll let you pass in a static offset. Don't be stupid now
|
|
else if(!isnull(offset_const))
|
|
SET_PLANE_W_SCALAR(appearance, plane, offset_const)
|
|
// otherwise if you're setting plane you better have the guts to back it up
|
|
else
|
|
stack_trace("No plane offset passed in as context for a non floating mutable appearance, things are gonna go to hell on multiz maps")
|
|
else if(!isnull(offset_spokesman) && !isatom(offset_spokesman))
|
|
stack_trace("Why did you pass in offset_spokesman as [offset_spokesman]? We need an atom to properly offset planes")
|
|
|
|
if(PERFORM_ALL_TESTS(focus_only/topdown_filtering))
|
|
check_topdown_validity(appearance)
|
|
|
|
return appearance
|
|
|
|
/// Takes an input mutable appearance, returns a copy of it with the hidden flag flipped to avoid inheriting dir from what it's drawn on
|
|
/// This inheriting thing is handled by a hidden flag on the /image (MAs are subtypes of /image)
|
|
/proc/make_mutable_appearance_directional(mutable_appearance/to_process, dir = NORTH)
|
|
// We use the image() proc in combo with a manually set dir to flip this flag
|
|
// We can then copy the image's appearance to retain the flag, even on MAs and such
|
|
var/image/holder = image(to_process, dir = dir)
|
|
return new /mutable_appearance(holder)
|