Merge remote-tracking branch 'upstream/master' into w-pixels

Author: LetterN

citadel.dme

@@ -450,6 +450,7 @@
 #include "code\__HELPERS\files\paths.dm"
 #include "code\__HELPERS\files\walk.dm"
 #include "code\__HELPERS\game\depth.dm"
+#include "code\__HELPERS\game\level_connectivity.dm"
 #include "code\__HELPERS\game\combat\arc.dm"
 #include "code\__HELPERS\game\turfs\blocks.dm"
 #include "code\__HELPERS\game\turfs\line.dm"
@@ -754,6 +755,7 @@
 #include "code\datums\material_container.dm"
 #include "code\datums\mind.dm"
 #include "code\datums\mixed.dm"
+#include "code\datums\movement_detector.dm"
 #include "code\datums\mutable_appearance.dm"
 #include "code\datums\periodic_news.dm"
 #include "code\datums\position_point_vector.dm"
@@ -1151,6 +1153,7 @@
 #include "code\game\atoms\atom-tool_system-wrappers.dm"
 #include "code\game\atoms\atom-tool_system.dm"
 #include "code\game\atoms\atom-vv.dm"
+#include "code\game\atoms\atom_orbit.dm"
 #include "code\game\atoms\atoms_initializing_EXPENSIVE.dm"
 #include "code\game\atoms\buckling.dm"
 #include "code\game\atoms\defense_old.dm"

code/__DEFINES/traits/unsorted.dm

@@ -34,3 +34,6 @@ Remember to update _globalvars/traits.dm if you're adding/removing/renaming trai
 #define TRAIT_FISH_SAFE_STORAGE "fish_case"
 /// Stuff that can go inside fish cases
 #define TRAIT_FISH_CASE_COMPATIBILE "fish_case_compatibile"
+
+/// Whether or not orbiting is blocked or not
+#define TRAIT_ORBITING_FORBIDDEN "orbiting_forbidden"

code/__HELPERS/game/level_connectivity.dm

@@ -0,0 +1,49 @@
+//* This file is explicitly licensed under the MIT license. *//
+//* Copyright (c) 2026 Citadel Station Developers           *//
+
+/**
+ * Checks if two entities are on in the same map.
+ * * Levels in the same `map` (usually the case for levels in the same overmap sector) are considered on the same map.
+ * * If levels are not in a map struct, they must be the same level.
+ * * This does **not** work on overmap entity objects.
+ *
+ * returns TRUE if same sector, FALSE otherwise
+ */
+/proc/is_same_map(atom/A, atom/B)
+	var/Z_A = get_z(A)
+	var/Z_B = get_z(B)
+	if(!Z_A || !Z_B)
+		return FALSE
+	if(Z_A == Z_B)
+		return TRUE
+	// not same level, check if same map
+	return SSmapping.ordered_levels[Z_A].parent_map == SSmapping.ordered_levels[Z_B].parent_map
+
+/**
+ * Checks if two entities are on the same overmap sector
+ * * Like `is_same_map(A, B)` but for overmap sectors with multiple maps (very rare) this passes;
+ *   use if semantically this should pass if something is on the same planet.
+ * * This uses **enclosing** overmap sector; this means shuttles are considered the same sector
+ *   as their landed maps!
+ * * This does **not** work on overmap entity objects.
+ */
+/proc/is_same_sector(atom/A, atom/B)
+	return SSovermaps.get_enclosing_overmap_entity(A) == SSovermaps.get_enclosing_overmap_entity(B)
+
+/**
+ * Gets overmap sector distance in pixels between two entities.
+ * * This does **not** work on overmap entity objects.
+ * * This uses **enclosing** overmap sector; this means shuttles are considered the same sector
+ *   as their landed maps!
+ * * This uses bounds_dist(); this means that the distance measured is edge-to-edge, not center-to-center.
+ *
+ * returns number of pixels; 0 if same sector, INFINITY if unreachable / on a different overmap
+ */
+/proc/get_atom_sector_dist(atom/A, atom/B)
+	var/obj/overmap/entity/O_A = SSovermaps.get_enclosing_overmap_entity(A)
+	var/obj/overmap/entity/O_B = SSovermaps.get_enclosing_overmap_entity(B)
+	if(O_A == O_B)
+		return 0
+	else if((O_A.overmap != O_B.overmap) || !O_A.overmap)
+		return INFINITY
+	return max(0, bounds_dist(O_A, O_B))

code/datums/callback.dm

@@ -115,6 +115,8 @@
 		else
 			calling_arguments = args
 	if(datum_flags & DF_VAR_EDITED)
+		if(usr != GLOB.AdminProcCallHandler && !(usr && usr?.client?.ckey)) //This happens when a timer or the MC invokes a callback
+			return HandleUserlessProcCall(usr, object, delegate, calling_arguments)
 		return WrapAdminProcCall(object, delegate, calling_arguments)
 	if (object == GLOBAL_PROC)
 		return call(delegate)(arglist(calling_arguments))
@@ -150,6 +152,8 @@
 		else
 			calling_arguments = args
 	if(datum_flags & DF_VAR_EDITED)
+		if(usr != GLOB.AdminProcCallHandler && !(usr && usr?.client?.ckey)) //This happens when a timer or the MC invokes a callback
+			return HandleUserlessProcCall(usr, object, delegate, calling_arguments)
 		return WrapAdminProcCall(object, delegate, calling_arguments)
 	if (object == GLOBAL_PROC)
 		return call(delegate)(arglist(calling_arguments))

code/datums/components/movable/status_emoji.dm

@@ -32,8 +32,8 @@
 	align_to.get_centering_pixel_x_offset()
 
 	// we always align to their icon's top right.
-	var/align_x = (align_to.get_pixel_x_self_width() - emoji.icon_size_x) + emoji.shift_x
-	var/align_y = (align_to.get_pixel_y_self_width() - emoji.icon_size_y) + emoji.shift_y
+	var/align_x = (align_to.icon_x_dimension - emoji.icon_size_x) + emoji.shift_x
+	var/align_y = (align_to.icon_y_dimension - emoji.icon_size_y) + emoji.shift_y
 
 	overlay.pixel_x = align_x
 	overlay.pixel_y = align_y

code/datums/components/orbiter.dm

@@ -1,7 +1,12 @@
 /datum/component/orbiter
 	can_transfer = TRUE
 	dupe_mode = COMPONENT_DUPE_UNIQUE_PASSARGS
-	var/list/orbiters
+	/// Assoc list of all orbiters -> their initial matrix
+	var/list/orbiter_list
+	/// Assoc list of orbiters -> their orbiting parameters
+	var/list/orbiter_params
+	/// Movement tracker used to check when our owner moves
+	var/datum/movement_detector/tracker
 
 //radius: range to orbit at, radius of the circle formed by orbiting (in pixels)
 //clockwise: whether you orbit clockwise or anti clockwise
@@ -12,60 +17,78 @@
 	if(!istype(orbiter) || !isatom(parent) || isarea(parent))
 		return COMPONENT_INCOMPATIBLE
 
-	orbiters = list()
-
-	var/atom/master = parent
-	master.orbiters = src
+	orbiter_list = list()
+	orbiter_params = list()
 
 	begin_orbit(orbiter, radius, clockwise, rotation_speed, rotation_segments, pre_rotation)
 
 /datum/component/orbiter/RegisterWithParent()
-	. = ..()
 	var/atom/target = parent
-	while(ismovable(target))
-		RegisterSignal(target, COMSIG_MOVABLE_MOVED, PROC_REF(move_react))
-		target = target.loc
+
+	target.orbiters = src
+	if(ismovable(target))
+		tracker = new(target, CALLBACK(src, PROC_REF(move_react)))
+
+	RegisterSignal(parent, COMSIG_MOVABLE_UPDATE_GLIDE_SIZE, PROC_REF(orbiter_glide_size_update))
 
 /datum/component/orbiter/UnregisterFromParent()
-	. = ..()
+	UnregisterSignal(parent, COMSIG_MOVABLE_UPDATE_GLIDE_SIZE)
 	var/atom/target = parent
-	while(ismovable(target))
-		UnregisterSignal(target, COMSIG_MOVABLE_MOVED)
-		target = target.loc
+	target.orbiters = null
+	QDEL_NULL(tracker)
 
 /datum/component/orbiter/Destroy()
 	var/atom/master = parent
-	master.orbiters = null
-	for(var/i in orbiters)
+	if(master.orbiters == src)
+		master.orbiters = null
+	for(var/i in orbiter_list)
 		end_orbit(i)
-	orbiters = null
+	orbiter_list = null
+	orbiter_params = null
 	return ..()
 
 /datum/component/orbiter/InheritComponent(datum/component/orbiter/newcomp, original, atom/movable/orbiter, radius, clockwise, rotation_speed, rotation_segments, pre_rotation)
 	if(!newcomp)
 		begin_orbit(arglist(args.Copy(3)))
 		return
 	// The following only happens on component transfers
-	orbiters += newcomp.orbiters
-
-/datum/component/orbiter/PostTransfer()
-	if(!isatom(parent) || isarea(parent) || !get_turf(parent))
+	for(var/o in newcomp.orbiter_list)
+		var/atom/movable/incoming_orbiter = o
+		incoming_orbiter.orbiting = src
+		// It is important to transfer the signals so we don't get locked to the new orbiter component for all time
+		newcomp.UnregisterSignal(incoming_orbiter, list(COMSIG_MOVABLE_MOVED /*, COMSIG_ATOM_BEFORE_SHUTTLE_MOVE, COMSIG_ATOM_AFTER_SHUTTLE_MOVE */))
+		RegisterSignal(incoming_orbiter, COMSIG_MOVABLE_MOVED, PROC_REF(orbiter_move_react))
+		// RegisterSignal(incoming_orbiter, COMSIG_ATOM_BEFORE_SHUTTLE_MOVE, PROC_REF(orbiter_before_shuttle_move))
+
+	orbiter_list += newcomp.orbiter_list
+	orbiter_params += newcomp.orbiter_params
+	newcomp.orbiter_list = null
+	newcomp.orbiter_params = null
+
+/datum/component/orbiter/PostTransfer(datum/new_parent)
+	if(!isatom(new_parent) || isarea(new_parent) || !get_turf(new_parent))
 		return COMPONENT_INCOMPATIBLE
-	move_react()
+	move_react(new_parent)
 
 /datum/component/orbiter/proc/begin_orbit(atom/movable/orbiter, radius, clockwise, rotation_speed, rotation_segments, pre_rotation)
-	SEND_SIGNAL(parent, COMSIG_ATOM_ORBIT_BEGIN, orbiter, radius, clockwise, rotation_speed, rotation_segments, pre_rotation)
 	if(orbiter.orbiting)
 		if(orbiter.orbiting == src)
 			orbiter.orbiting.end_orbit(orbiter, TRUE)
 		else
 			orbiter.orbiting.end_orbit(orbiter)
-	orbiters[orbiter] = TRUE
+
+	orbiter_params[orbiter] = args.Copy(2)
+	orbiter_list[orbiter] = TRUE
 	orbiter.orbiting = src
+
+	// ADD_TRAIT(orbiter, TRAIT_NO_FLOATING_ANIM, ORBITING_TRAIT)
 	RegisterSignal(orbiter, COMSIG_MOVABLE_MOVED, PROC_REF(orbiter_move_react))
+	// RegisterSignal(orbiter, COMSIG_ATOM_BEFORE_SHUTTLE_MOVE, PROC_REF(orbiter_before_shuttle_move))
+
+	SEND_SIGNAL(parent, COMSIG_ATOM_ORBIT_BEGIN, orbiter)
 
 	var/matrix/initial_transform = matrix(orbiter.transform)
-	orbiters[orbiter] = initial_transform
+	orbiter_list[orbiter] = initial_transform
 
 	// Head first!
 	if(pre_rotation)
@@ -82,70 +105,98 @@
 
 	orbiter.SpinAnimation(rotation_speed, -1, clockwise, rotation_segments, parallel = FALSE)
 
-	orbiter.forceMove(get_turf(parent))
-	to_chat(orbiter, "<span class='notice'>Now orbiting [parent].</span>")
+	// if(ismob(orbiter))
+	// 	var/mob/orbiter_mob = orbiter
+	// 	orbiter_mob.updating_glide_size = FALSE
+	if(ismovable(parent))
+		var/atom/movable/movable_parent = parent
+		orbiter.glide_size = movable_parent.glide_size
+
+	orbiter.abstract_move(get_turf(parent))
+	to_chat(orbiter, SPAN_NOTICE("Now orbiting [parent]."))
+
+/datum/component/orbiter/proc/orbiter_before_shuttle_move(atom/source)
+	SIGNAL_HANDLER
+	// We need to detach ourselves before the shuttle moves and reattach afterwards
+	end_orbit(source, TRUE)
+	// RegisterSignal(source, COMSIG_ATOM_AFTER_SHUTTLE_MOVE, PROC_REF(orbiter_after_shuttle_move))
+
+/datum/component/orbiter/proc/orbiter_after_shuttle_move(atom/source)
+	SIGNAL_HANDLER
+	// UnregisterSignal(source, COMSIG_ATOM_AFTER_SHUTTLE_MOVE)
+	begin_orbit(arglist(list(source) + orbiter_params[source]))
 
 /datum/component/orbiter/proc/end_orbit(atom/movable/orbiter, refreshing=FALSE)
-	if(!orbiters[orbiter])
+	if(!orbiter_list[orbiter])
 		return
-	SEND_SIGNAL(parent, COMSIG_ATOM_ORBIT_END, orbiter, refreshing)
-	UnregisterSignal(orbiter, COMSIG_MOVABLE_MOVED)
-	orbiter.SpinAnimation(0, 0, parallel = FALSE)
-	if(istype(orbiters[orbiter],/matrix)) //This is ugly.
-		orbiter.transform = orbiters[orbiter]
-	orbiters -= orbiter
+	UnregisterSignal(orbiter, list(COMSIG_MOVABLE_MOVED /*, COMSIG_ATOM_BEFORE_SHUTTLE_MOVE, COMSIG_ATOM_AFTER_SHUTTLE_MOVE */))
+	// SEND_SIGNAL(parent, COMSIG_ATOM_ORBIT_STOP, orbiter) // on tg used by ghost player plays
+	orbiter.SpinAnimation(0, 0)
+	if(istype(orbiter_list[orbiter],/matrix)) //This is ugly.
+		orbiter.transform = orbiter_list[orbiter]
+	orbiter_list -= orbiter
+	if(!refreshing)
+		orbiter_params -= orbiter
 	orbiter.stop_orbit(src)
 	orbiter.orbiting = null
-	if(!refreshing && !length(orbiters) && !QDELING(src))
+
+	if(ismob(orbiter))
+		var/mob/orbiter_mob = orbiter
+		// orbiter_mob.updating_glide_size = TRUE
+		orbiter_mob.glide_size = 8
+
+		if(isobserver(orbiter))
+			var/mob/observer/dead/ghostie = orbiter
+			ghostie.orbiting_ref = null
+
+	// REMOVE_TRAIT(orbiter, TRAIT_NO_FLOATING_ANIM, ORBITING_TRAIT)
+
+	if(!refreshing && !length(orbiter_list) && !QDELING(src))
 		qdel(src)
 
 // This proc can receive signals by either the thing being directly orbited or anything holding it
-/datum/component/orbiter/proc/move_react(atom/orbited, atom/oldloc, direction)
+/datum/component/orbiter/proc/move_react(atom/movable/master, atom/mover, atom/oldloc, direction)
 	set waitfor = FALSE // Transfer calls this directly and it doesnt care if the ghosts arent done moving
 
-	var/atom/movable/master = parent
 	if(master.loc == oldloc)
 		return
 
 	var/turf/newturf = get_turf(master)
 	if(!newturf)
 		qdel(src)
 
-	// Handling the signals of stuff holding us (or not anymore)
-	// These are prety rarely activated, how often are you following something in a bag?
-	if(oldloc && !isturf(oldloc)) // We used to be registered to it, probably
-		var/atom/target = oldloc
-		while(ismovable(target))
-			UnregisterSignal(target, COMSIG_MOVABLE_MOVED)
-			target = target.loc
-	if(orbited?.loc && orbited.loc != newturf) // We want to know when anything holding us moves too
-		var/atom/target = orbited.loc
-		while(ismovable(target))
-			RegisterSignal(target, COMSIG_MOVABLE_MOVED, PROC_REF(move_react), TRUE)
-			target = target.loc
-
 	var/atom/curloc = master.loc
-	for(var/i in orbiters)
-		var/atom/movable/thing = i
-		if(QDELETED(thing) || thing.loc == newturf)
+	for(var/atom/movable/movable_orbiter as anything in orbiter_list)
+		if(QDELETED(movable_orbiter) || movable_orbiter.loc == newturf)
 			continue
-		thing.forceMove(newturf)
+		movable_orbiter.abstract_move(newturf)
 		if(CHECK_TICK && master.loc != curloc)
 			// We moved again during the checktick, cancel current operation
 			break
 
 
 /datum/component/orbiter/proc/orbiter_move_react(atom/movable/orbiter, atom/oldloc, direction)
+	SIGNAL_HANDLER
+
 	if(orbiter.loc == get_turf(parent))
 		return
 	end_orbit(orbiter)
 
+/datum/component/orbiter/proc/orbiter_glide_size_update(datum/source, target)
+	SIGNAL_HANDLER
+	for(var/orbiter in orbiter_list)
+		var/atom/movable/movable_orbiter = orbiter
+		movable_orbiter.glide_size = target
+
 /////////////////////
 
 /atom/movable/proc/orbit(atom/A, radius = 10, clockwise = FALSE, rotation_speed = 20, rotation_segments = 36, pre_rotation = TRUE)
 	if(!istype(A) || !get_turf(A) || A == src)
 		return
-
+	if (HAS_TRAIT(A, TRAIT_ORBITING_FORBIDDEN))
+		// Stealth-mins have an empty name, don't want "You cannot orbit   at this time."
+		to_chat(src, SPAN_NOTICE("You cannot orbit ["[A]" || "them"] at this time."))
+		return
 	orbit_target = A
 	return A.AddComponent(/datum/component/orbiter, src, radius, clockwise, rotation_speed, rotation_segments, pre_rotation)