Update MC (#18112)

* sdf

* fsda

* fuck

* fuck2

* toolz

* sdaf

* sdfa

* saf

* sdfa

* sdfa

* sdf

* sdfa

* temp rename

* temp rename

* temp rename

* sdaf

* the pain is immensurable in the land of byond

* the curse of rah

* safd

* sadf

* sadf

* gf

* asf

* fssdfa

* sfd

* sadf

* sfda

* brah

* brah

* it's easier for you to fix this

* ffs

* brah

* brah

code/datums/callback.dm

@@ -19,7 +19,7 @@
  * In case of sleeps, the parent proc (aka where you call this) will continue its processing while the called proc sleeps
  *
  * * thingtocall - The object whose function is to be called on, will be set as `src` in said function, or `GLOBAL_PROC` if the proc is a global one
- * * proctocall - The process to call, use `PROC_REF`, `TYPE_PROC_REF` or `GLOBAL_PROC_REF` according to your use case. Defines in code\__defines\byond_compat.dm
+ * * proctocall - The process to call, use `PROC_REF`, `TYPE_PROC_REF` or `GLOBAL_PROC_REF` according to your use case. Defines in code\__DEFINES\byond_compat.dm
  * * ... - Parameters to pass to said proc (VARIPARAM)
  */
 /proc/ImmediateInvokeAsync(thingtocall, proctocall, ...)

code/datums/datum.dm

@@ -98,7 +98,20 @@
 
 	return QDEL_HINT_QUEUE
 
-/datum/proc/process()
+/**
+ * This proc is called on a datum on every "cycle" if it is being processed by a subsystem. The time between each cycle is determined by the subsystem's "wait" setting.
+ * You can start and stop processing a datum using the START_PROCESSING and STOP_PROCESSING defines.
+ *
+ * Since the wait setting of a subsystem can be changed at any time, it is important that any rate-of-change that you implement in this proc is multiplied by the seconds_per_tick that is sent as a parameter,
+ * Additionally, any "prob" you use in this proc should instead use the SPT_PROB define to make sure that the final probability per second stays the same even if the subsystem's wait is altered.
+ * Examples where this must be considered:
+ * - Implementing a cooldown timer, use `mytimer -= seconds_per_tick`, not `mytimer -= 1`. This way, `mytimer` will always have the unit of seconds
+ * - Damaging a mob, do `L.adjustFireLoss(20 * seconds_per_tick)`, not `L.adjustFireLoss(20)`. This way, the damage per second stays constant even if the wait of the subsystem is changed
+ * - Probability of something happening, do `if(SPT_PROB(25, seconds_per_tick))`, not `if(prob(25))`. This way, if the subsystem wait is e.g. lowered, there won't be a higher chance of this event happening per second
+ *
+ * If you override this do not call parent, as it will return PROCESS_KILL. This is done to prevent objects that dont override process() from staying in the processing list
+ */
+/datum/proc/process(seconds_per_tick)
 	set waitfor = FALSE
 	return PROCESS_KILL
 

code/datums/helper_datums/stack_end_detector.dm

@@ -0,0 +1,32 @@
+/**
+	Stack End Detector.
+	Can detect if a given code stack has exited, used by the mc for stack overflow detection.
+
+ **/
+/datum/stack_end_detector
+	var/datum/weakref/_WF
+	var/datum/stack_canary/_canary
+
+/datum/stack_end_detector/New()
+	_canary = new()
+	_WF = WEAKREF(_canary)
+
+/** Prime the stack overflow detector.
+	Store the return value of this proc call in a proc level var.
+	Can only be called once.
+**/
+/datum/stack_end_detector/proc/prime_canary()
+	if (!_canary)
+		CRASH("Prime_canary called twice")
+	. = _canary
+	_canary = null
+
+/// Returns true if the stack is still going. Calling before the canary has been primed also returns true
+/datum/stack_end_detector/proc/check()
+	return !!_WF.resolve()
+
+/// Stack canary. Will go away if the stack it was primed by is ended by byond for return or stack overflow reasons.
+/datum/stack_canary
+
+/// empty proc to avoid warnings about unused variables. Call this proc on your canary in the stack it's watching.
+/datum/stack_canary/proc/use_variable()