StonedMC

This commit ports the StonedMC from /tg/station, intended to replace the
Process Scheduler from goon. Currently, they exist simultaneously, as
it's very difficult to port our 22 processes to the SMC all at once.
Instead, we can make them work together until everything is converted
over at a later point, and then take the old PS out back and put a
couple of rounds into it's deformed skull.

Primary benefits of this new process controller include: Other people
that can actually maintain it, unlike the PS, pre-world-init
initialization for subsystems, ease of ports from /tg/station13, and
potential performance improvement (to be seen).

code/__DEFINES/MC.dm

@@ -0,0 +1,78 @@
+#define MC_TICK_CHECK ( ( TICK_USAGE > Master.current_ticklimit || src.state != SS_RUNNING ) ? pause() : 0 )
+
+#define MC_SPLIT_TICK_INIT(phase_count) var/original_tick_limit = Master.current_ticklimit; var/split_tick_phases = ##phase_count
+#define MC_SPLIT_TICK \
+    if(split_tick_phases > 1){\
+        Master.current_ticklimit = ((original_tick_limit - TICK_USAGE) / split_tick_phases) + TICK_USAGE;\
+        --split_tick_phases;\
+    } else {\
+        Master.current_ticklimit = original_tick_limit;\
+    }
+
+// Used to smooth out costs to try and avoid oscillation.
+#define MC_AVERAGE_FAST(average, current) (0.7 * (average) + 0.3 * (current))
+#define MC_AVERAGE(average, current) (0.8 * (average) + 0.2 * (current))
+#define MC_AVERAGE_SLOW(average, current) (0.9 * (average) + 0.1 * (current))
+
+#define MC_AVG_FAST_UP_SLOW_DOWN(average, current) (average > current ? MC_AVERAGE_SLOW(average, current) : MC_AVERAGE_FAST(average, current))
+#define MC_AVG_SLOW_UP_FAST_DOWN(average, current) (average < current ? MC_AVERAGE_SLOW(average, current) : MC_AVERAGE_FAST(average, current))
+
+#define NEW_SS_GLOBAL(varname) if(varname != src){if(istype(varname)){Recover();qdel(varname);}varname = src;}
+
+#define START_PROCESSING(Processor, Datum) if (!Datum.isprocessing) {Datum.isprocessing = TRUE;Processor.processing += Datum}
+#define STOP_PROCESSING(Processor, Datum) Datum.isprocessing = FALSE;Processor.processing -= Datum
+
+//SubSystem flags (Please design any new flags so that the default is off, to make adding flags to subsystems easier)
+
+//subsystem does not initialize.
+#define SS_NO_INIT 1
+
+//subsystem does not fire.
+//	(like can_fire = 0, but keeps it from getting added to the processing subsystems list)
+//	(Requires a MC restart to change)
+#define SS_NO_FIRE 2
+
+//subsystem only runs on spare cpu (after all non-background subsystems have ran that tick)
+//	SS_BACKGROUND has its own priority bracket
+#define SS_BACKGROUND 4
+
+//subsystem does not tick check, and should not run unless there is enough time (or its running behind (unless background))
+#define SS_NO_TICK_CHECK 8
+
+//Treat wait as a tick count, not DS, run every wait ticks.
+//	(also forces it to run first in the tick, above even SS_NO_TICK_CHECK subsystems)
+//	(implies all runlevels because of how it works)
+//	(overrides SS_BACKGROUND)
+//	This is designed for basically anything that works as a mini-mc (like SStimer)
+#define SS_TICKER 16
+
+//keep the subsystem's timing on point by firing early if it fired late last fire because of lag
+//	ie: if a 20ds subsystem fires say 5 ds late due to lag or what not, its next fire would be in 15ds, not 20ds.
+#define SS_KEEP_TIMING 32
+
+//Calculate its next fire after its fired.
+//	(IE: if a 5ds wait SS takes 2ds to run, its next fire should be 5ds away, not 3ds like it normally would be)
+//	This flag overrides SS_KEEP_TIMING
+#define SS_POST_FIRE_TIMING 64
+
+//SUBSYSTEM STATES
+#define SS_IDLE 0		//aint doing shit.
+#define SS_QUEUED 1		//queued to run
+#define SS_RUNNING 2	//actively running
+#define SS_PAUSED 3		//paused by mc_tick_check
+#define SS_SLEEPING 4	//fire() slept.
+#define SS_PAUSING 5 	//in the middle of pausing
+
+#define SUBSYSTEM_DEF(X) GLOBAL_REAL(SS##X, /datum/controller/subsystem/##X);\
+/datum/controller/subsystem/##X/New(){\
+    NEW_SS_GLOBAL(SS##X);\
+    PreInit();\
+}\
+/datum/controller/subsystem/##X
+
+#define PROCESSING_SUBSYSTEM_DEF(X) GLOBAL_REAL(SS##X, /datum/controller/subsystem/processing/##X);\
+/datum/controller/subsystem/processing/##X/New(){\
+    NEW_SS_GLOBAL(SS##X);\
+    PreInit();\
+}\
+/datum/controller/subsystem/processing/##X

code/__DEFINES/_globals.dm

@@ -0,0 +1,38 @@
+//See controllers/globals.dm
+#define GLOBAL_MANAGED(X, InitValue)\
+/datum/controller/global_vars/proc/InitGlobal##X(){\
+    ##X = ##InitValue;\
+    gvars_datum_init_order += #X;\
+}
+#define GLOBAL_UNMANAGED(X) /datum/controller/global_vars/proc/InitGlobal##X() { return; }
+
+#ifndef TESTING
+#define GLOBAL_PROTECT(X)\
+/datum/controller/global_vars/InitGlobal##X(){\
+    ..();\
+    gvars_datum_protected_varlist[#X] = TRUE;\
+}
+#else
+#define GLOBAL_PROTECT(X)
+#endif
+
+#define GLOBAL_REAL_VAR(X) var/global/##X
+#define GLOBAL_REAL(X, Typepath) var/global##Typepath/##X
+
+#define GLOBAL_RAW(X) /datum/controller/global_vars/var/global##X
+
+#define GLOBAL_VAR_INIT(X, InitValue) GLOBAL_RAW(/##X); GLOBAL_MANAGED(X, InitValue)
+
+#define GLOBAL_VAR_CONST(X, InitValue) GLOBAL_RAW(/const/##X) = InitValue; GLOBAL_UNMANAGED(X)
+
+#define GLOBAL_LIST_INIT(X, InitValue) GLOBAL_RAW(/list/##X); GLOBAL_MANAGED(X, InitValue)
+
+#define GLOBAL_LIST_EMPTY(X) GLOBAL_LIST_INIT(X, list())
+
+#define GLOBAL_DATUM_INIT(X, Typepath, InitValue) GLOBAL_RAW(Typepath/##X); GLOBAL_MANAGED(X, InitValue)
+
+#define GLOBAL_VAR(X) GLOBAL_RAW(/##X); GLOBAL_UNMANAGED(X)
+
+#define GLOBAL_LIST(X) GLOBAL_RAW(/list/##X); GLOBAL_UNMANAGED(X)
+
+#define GLOBAL_DATUM(X, Typepath) GLOBAL_RAW(Typepath/##X); GLOBAL_UNMANAGED(X)

code/__DEFINES/flags.dm

@@ -89,3 +89,5 @@
 #define AFFECT_ROBOTIC_ORGAN	1
 #define AFFECT_ORGANIC_ORGAN	2
 #define AFFECT_ALL_ORGANS		3
+
+GLOBAL_LIST_INIT(bitflags, list(1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768))

code/__DEFINES/math.dm

@@ -30,4 +30,20 @@
 #define Lcm(a, b)					(abs(a) / Gcd((a), (b)) * abs(b))
 #define Root(n, x)					((x) ** (1 / (n)))
 #define ToDegrees(radians)			((radians) * 57.2957795)			// 180 / Pi
-#define ToRadians(degrees)			((degrees) * 0.0174532925)			// Pi / 180
+#define ToRadians(degrees)			((degrees) * 0.0174532925)			// Pi / 180
+
+//"fancy" math for calculating time in ms from tick_usage percentage and the length of ticks
+//percent_of_tick_used * (ticklag * 100(to convert to ms)) / 100(percent ratio)
+//collapsed to percent_of_tick_used * tick_lag
+#define TICK_DELTA_TO_MS(percent_of_tick_used) ((percent_of_tick_used) * world.tick_lag)
+#define TICK_USAGE_TO_MS(starting_tickusage) (TICK_DELTA_TO_MS(TICK_USAGE_REAL - starting_tickusage))
+
+//time of day but automatically adjusts to the server going into the next day within the same round.
+//for when you need a reliable time number that doesn't depend on byond time.
+#define REALTIMEOFDAY (world.timeofday + (MIDNIGHT_ROLLOVER * MIDNIGHT_ROLLOVER_CHECK))
+#define MIDNIGHT_ROLLOVER_CHECK ( GLOB.rollovercheck_last_timeofday != world.timeofday ? update_midnight_rollover() : GLOB.midnight_rollovers )
+
+#define CEILING(x, y) ( -round(-(x) / (y)) * (y) )
+
+// round() acts like floor(x, 1) by default but can't handle other values
+#define FLOOR(x, y) ( round((x) / (y)) * (y) )

code/__DEFINES/subsystems.dm

@@ -0,0 +1,119 @@
+//Update this whenever the db schema changes
+//make sure you add an update to the schema_version stable in the db changelog
+#define DB_MAJOR_VERSION 4
+#define DB_MINOR_VERSION 1
+
+//Timing subsystem
+//Don't run if there is an identical unique timer active
+//if the arguments to addtimer are the same as an existing timer, it doesn't create a new timer, and returns the id of the existing timer
+#define TIMER_UNIQUE		0x1
+//For unique timers: Replace the old timer rather then not start this one
+#define TIMER_OVERRIDE		0x2
+//Timing should be based on how timing progresses on clients, not the sever.
+//	tracking this is more expensive,
+//	should only be used in conjuction with things that have to progress client side, such as animate() or sound()
+#define TIMER_CLIENT_TIME	0x4
+//Timer can be stopped using deltimer()
+#define TIMER_STOPPABLE		0x8
+//To be used with TIMER_UNIQUE
+//prevents distinguishing identical timers with the wait variable
+#define TIMER_NO_HASH_WAIT  0x10
+
+#define TIMER_NO_INVOKE_WARNING 600 //number of byond ticks that are allowed to pass before the timer subsystem thinks it hung on something
+
+#define TIMER_ID_NULL -1
+
+//For servers that can't do with any additional lag, set this to none in flightpacks.dm in subsystem/processing.
+#define FLIGHTSUIT_PROCESSING_NONE 0
+#define FLIGHTSUIT_PROCESSING_FULL 1
+
+#define INITIALIZATION_INSSATOMS 0	//New should not call Initialize
+#define INITIALIZATION_INNEW_MAPLOAD 2	//New should call Initialize(TRUE)
+#define INITIALIZATION_INNEW_REGULAR 1	//New should call Initialize(FALSE)
+
+#define INITIALIZE_HINT_NORMAL 0    //Nothing happens
+#define INITIALIZE_HINT_LATELOAD 1  //Call LateInitialize
+#define INITIALIZE_HINT_QDEL 2  //Call qdel on the atom
+
+//type and all subtypes should always call Initialize in New()
+#define INITIALIZE_IMMEDIATE(X) ##X/New(loc, ...){\
+    ..();\
+    if(!initialized) {\
+        args[1] = TRUE;\
+        SSatoms.InitAtom(src, args);\
+    }\
+}
+
+// Subsystem init_order, from highest priority to lowest priority
+// Subsystems shutdown in the reverse of the order they initialize in
+// The numbers just define the ordering, they are meaningless otherwise.
+
+#define INIT_ORDER_GARBAGE 19
+#define INIT_ORDER_DBCORE 18
+#define INIT_ORDER_BLACKBOX 17
+#define INIT_ORDER_SERVER_MAINT 16
+#define INIT_ORDER_INPUT 15
+#define INIT_ORDER_RESEARCH 14
+#define INIT_ORDER_EVENTS 13
+#define INIT_ORDER_JOBS 12
+#define INIT_ORDER_TRAITS 11
+#define INIT_ORDER_TICKER 10
+#define INIT_ORDER_MAPPING 9
+#define INIT_ORDER_ATOMS 8
+#define INIT_ORDER_NETWORKS 7
+#define INIT_ORDER_LANGUAGE 6
+#define INIT_ORDER_MACHINES 5
+#define INIT_ORDER_CIRCUIT 4
+#define INIT_ORDER_TIMER 1
+#define INIT_ORDER_DEFAULT 0
+#define INIT_ORDER_AIR -1
+#define INIT_ORDER_MINIMAP -3
+#define INIT_ORDER_ASSETS -4
+#define INIT_ORDER_ICON_SMOOTHING -5
+#define INIT_ORDER_OVERLAY -6
+#define INIT_ORDER_XKEYSCORE -10
+#define INIT_ORDER_STICKY_BAN -10
+#define INIT_ORDER_LIGHTING -20
+#define INIT_ORDER_SHUTTLE -21
+#define INIT_ORDER_SQUEAK -40
+#define INIT_ORDER_PATH -50
+#define INIT_ORDER_PERSISTENCE -100
+
+// Subsystem fire priority, from lowest to highest priority
+// If the subsystem isn't listed here it's either DEFAULT or PROCESS (if it's a processing subsystem child)
+
+#define FIRE_PRIORITY_IDLE_NPC		10
+#define FIRE_PRIORITY_SERVER_MAINT	10
+#define FIRE_PRIORITY_GARBAGE		15
+#define FIRE_PRIORITY_RESEARCH		15
+#define FIRE_PRIORITY_AIR			20
+#define FIRE_PRIORITY_NPC			20
+#define FIRE_PRIORITY_PROCESS		25
+#define FIRE_PRIORITY_THROWING		25
+#define FIRE_PRIORITY_FLIGHTPACKS	30
+#define FIRE_PRIORITY_SPACEDRIFT	30
+#define FIRE_PRIOTITY_SMOOTHING		35
+#define FIRE_PRIORITY_ORBIT			35
+#define FIRE_PRIORITY_OBJ			40
+#define FIRE_PRIORUTY_FIELDS		40
+#define FIRE_PRIORITY_ACID			40
+#define FIRE_PRIOTITY_BURNING		40
+#define FIRE_PRIORITY_INBOUNDS		40
+#define FIRE_PRIORITY_DEFAULT		50
+#define FIRE_PRIORITY_PARALLAX		65
+#define FIRE_PRIORITY_NETWORKS		80
+#define FIRE_PRIORITY_MOBS			100
+#define FIRE_PRIORITY_TGUI			110
+#define FIRE_PRIORITY_TICKER		200
+#define FIRE_PRIORITY_OVERLAYS		500
+#define FIRE_PRIORITY_INPUT			1000 // This must always always be the max highest priority. Player input must never be lost.
+
+// SS runlevels
+
+#define RUNLEVEL_INIT 0
+#define RUNLEVEL_LOBBY 1
+#define RUNLEVEL_SETUP 2
+#define RUNLEVEL_GAME 4
+#define RUNLEVEL_POSTGAME 8
+
+#define RUNLEVELS_DEFAULT (RUNLEVEL_SETUP | RUNLEVEL_GAME | RUNLEVEL_POSTGAME)

code/__DEFINES/tick.dm

@@ -1,5 +1,10 @@
-#define TICK_LIMIT_RUNNING 90
-#define TICK_LIMIT_TO_RUN 85
+#define TICK_LIMIT_RUNNING 80
+#define TICK_LIMIT_TO_RUN 70
+#define TICK_LIMIT_MC 70
+#define TICK_LIMIT_MC_INIT_DEFAULT 98
+
+#define TICK_USAGE world.tick_usage //for general usage
+#define TICK_USAGE_REAL world.tick_usage    //to be used where the result isn't checked
 
 #define TICK_CHECK ( world.tick_usage > TICK_LIMIT_RUNNING ? stoplag() : 0 )
 #define CHECK_TICK if(world.tick_usage > TICK_LIMIT_RUNNING)  stoplag()

code/__HELPERS/cmp.dm

@@ -0,0 +1,38 @@
+/proc/cmp_numeric_dsc(a,b)
+	return b - a
+
+/proc/cmp_numeric_asc(a,b)
+	return a - b
+
+/proc/cmp_text_asc(a,b)
+	return sorttext(b,a)
+
+/proc/cmp_text_dsc(a,b)
+	return sorttext(a,b)
+
+/proc/cmp_name_asc(atom/a, atom/b)
+	return sorttext(b.name, a.name)
+
+/proc/cmp_name_dsc(atom/a, atom/b)
+	return sorttext(a.name, b.name)
+
+/proc/cmp_ckey_asc(client/a, client/b)
+	return sorttext(b.ckey, a.ckey)
+
+/proc/cmp_ckey_dsc(client/a, client/b)
+	return sorttext(a.ckey, b.ckey)
+
+/proc/cmp_subsystem_init(datum/controller/subsystem/a, datum/controller/subsystem/b)
+	return initial(b.init_order) - initial(a.init_order)	//uses initial() so it can be used on types
+
+/proc/cmp_subsystem_display(datum/controller/subsystem/a, datum/controller/subsystem/b)
+	return sorttext(b.name, a.name)
+
+/proc/cmp_subsystem_priority(datum/controller/subsystem/a, datum/controller/subsystem/b)
+	return a.priority - b.priority
+
+/proc/cmp_atom_layer_asc(atom/A,atom/B)
+	if(A.plane != B.plane)
+		return A.plane - B.plane
+	else
+		return A.layer - B.layer

code/__HELPERS/lists.dm

@@ -678,4 +678,84 @@ proc/dd_sortedObjectList(list/incoming)
 		if(isnum(key))
 			L |= key
 		else
-			L[key] = temp[key]
+			L[key] = temp[key]
+
+//Move a single element from position fromIndex within a list, to position toIndex
+//All elements in the range [1,toIndex) before the move will be before the pivot afterwards
+//All elements in the range [toIndex, L.len+1) before the move will be after the pivot afterwards
+//In other words, it's as if the range [fromIndex,toIndex) have been rotated using a <<< operation common to other languages.
+//fromIndex and toIndex must be in the range [1,L.len+1]
+//This will preserve associations ~Carnie
+/proc/moveElement(list/L, fromIndex, toIndex)
+	if(fromIndex == toIndex || fromIndex+1 == toIndex)	//no need to move
+		return
+	if(fromIndex > toIndex)
+		++fromIndex	//since a null will be inserted before fromIndex, the index needs to be nudged right by one
+
+	L.Insert(toIndex, null)
+	L.Swap(fromIndex, toIndex)
+	L.Cut(fromIndex, fromIndex+1)
+
+
+//Move elements [fromIndex,fromIndex+len) to [toIndex-len, toIndex)
+//Same as moveElement but for ranges of elements
+//This will preserve associations ~Carnie
+/proc/moveRange(list/L, fromIndex, toIndex, len=1)
+	var/distance = abs(toIndex - fromIndex)
+	if(len >= distance)	//there are more elements to be moved than the distance to be moved. Therefore the same result can be achieved (with fewer operations) by moving elements between where we are and where we are going. The result being, our range we are moving is shifted left or right by dist elements
+		if(fromIndex <= toIndex)
+			return	//no need to move
+		fromIndex += len	//we want to shift left instead of right
+
+		for(var/i=0, i<distance, ++i)
+			L.Insert(fromIndex, null)
+			L.Swap(fromIndex, toIndex)
+			L.Cut(toIndex, toIndex+1)
+	else
+		if(fromIndex > toIndex)
+			fromIndex += len
+
+		for(var/i=0, i<len, ++i)
+			L.Insert(toIndex, null)
+			L.Swap(fromIndex, toIndex)
+			L.Cut(fromIndex, fromIndex+1)
+
+//Move elements from [fromIndex, fromIndex+len) to [toIndex, toIndex+len)
+//Move any elements being overwritten by the move to the now-empty elements, preserving order
+//Note: if the two ranges overlap, only the destination order will be preserved fully, since some elements will be within both ranges ~Carnie
+/proc/swapRange(list/L, fromIndex, toIndex, len=1)
+	var/distance = abs(toIndex - fromIndex)
+	if(len > distance)	//there is an overlap, therefore swapping each element will require more swaps than inserting new elements
+		if(fromIndex < toIndex)
+			toIndex += len
+		else
+			fromIndex += len
+
+		for(var/i=0, i<distance, ++i)
+			L.Insert(fromIndex, null)
+			L.Swap(fromIndex, toIndex)
+			L.Cut(toIndex, toIndex+1)
+	else
+		if(toIndex > fromIndex)
+			var/a = toIndex
+			toIndex = fromIndex
+			fromIndex = a
+
+		for(var/i=0, i<len, ++i)
+			L.Swap(fromIndex++, toIndex++)
+
+//replaces reverseList ~Carnie
+/proc/reverseRange(list/L, start=1, end=0)
+	if(L.len)
+		start = start % L.len
+		end = end % (L.len+1)
+		if(start <= 0)
+			start += L.len
+		if(end <= 0)
+			end += L.len + 1
+
+		--end
+		while(start < end)
+			L.Swap(start++,end--)
+
+	return L

code/__HELPERS/sorts/InsertSort.dm

@@ -0,0 +1,19 @@
+//simple insertion sort - generally faster than merge for runs of 7 or smaller
+/proc/sortInsert(list/L, cmp=/proc/cmp_numeric_asc, associative, fromIndex=1, toIndex=0)
+	if(L && L.len >= 2)
+		fromIndex = fromIndex % L.len
+		toIndex = toIndex % (L.len+1)
+		if(fromIndex <= 0)
+			fromIndex += L.len
+		if(toIndex <= 0)
+			toIndex += L.len + 1
+
+		var/datum/sortInstance/SI = GLOB.sortInstance
+		if(!SI)
+			SI = new
+		SI.L = L
+		SI.cmp = cmp
+		SI.associative = associative
+
+		SI.binarySort(fromIndex, toIndex, fromIndex)
+	return L

code/__HELPERS/sorts/MergeSort.dm

@@ -0,0 +1,19 @@
+//merge-sort - gernerally faster than insert sort, for runs of 7 or larger
+/proc/sortMerge(list/L, cmp=/proc/cmp_numeric_asc, associative, fromIndex=1, toIndex)
+	if(L && L.len >= 2)
+		fromIndex = fromIndex % L.len
+		toIndex = toIndex % (L.len+1)
+		if(fromIndex <= 0)
+			fromIndex += L.len
+		if(toIndex <= 0)
+			toIndex += L.len + 1
+
+		var/datum/sortInstance/SI = GLOB.sortInstance
+		if(!SI)
+			SI = new
+		SI.L = L
+		SI.cmp = cmp
+		SI.associative = associative
+
+		SI.mergeSort(fromIndex, toIndex)
+	return L

code/__HELPERS/sorts/TimSort.dm

@@ -0,0 +1,20 @@
+//TimSort interface
+/proc/sortTim(list/L, cmp=/proc/cmp_numeric_asc, associative, fromIndex=1, toIndex=0)
+	if(L && L.len >= 2)
+		fromIndex = fromIndex % L.len
+		toIndex = toIndex % (L.len+1)
+		if(fromIndex <= 0)
+			fromIndex += L.len
+		if(toIndex <= 0)
+			toIndex += L.len + 1
+
+		var/datum/sortInstance/SI = GLOB.sortInstance
+		if(!SI)
+			SI = new
+
+		SI.L = L
+		SI.cmp = cmp
+		SI.associative = associative
+
+		SI.timSort(fromIndex, toIndex)
+	return L

code/__HELPERS/sorts/__main.dm

@@ -0,0 +1,647 @@
+	//These are macros used to reduce on proc calls
+#define fetchElement(L, i) (associative) ? L[L[i]] : L[i]
+
+	//Minimum sized sequence that will be merged. Anything smaller than this will use binary-insertion sort.
+	//Should be a power of 2
+#define MIN_MERGE 32
+
+	//When we get into galloping mode, we stay there until both runs win less often than MIN_GALLOP consecutive times.
+#define MIN_GALLOP 7
+
+	//This is a global instance to allow much of this code to be reused. The interfaces are kept separately
+GLOBAL_DATUM_INIT(sortInstance, /datum/sortInstance, new())
+/datum/sortInstance
+	//The array being sorted.
+	var/list/L
+
+	//The comparator proc-reference
+	var/cmp = /proc/cmp_numeric_asc
+
+	//whether we are sorting list keys (0: L[i]) or associated values (1: L[L[i]])
+	var/associative = 0
+
+	//This controls when we get *into* galloping mode.  It is initialized	to MIN_GALLOP.
+	//The mergeLo and mergeHi methods nudge it higher for random data, and lower for highly structured data.
+	var/minGallop = MIN_GALLOP
+
+	//Stores information regarding runs yet to be merged.
+	//Run i starts at runBase[i] and extends for runLen[i] elements.
+	//runBase[i] + runLen[i] == runBase[i+1]
+	var/list/runBases = list()
+	var/list/runLens = list()
+
+
+	proc/timSort(start, end)
+		runBases.Cut()
+		runLens.Cut()
+
+		var/remaining = end - start
+
+		//If array is small, do a 'mini-TimSort' with no merges
+		if(remaining < MIN_MERGE)
+			var/initRunLen = countRunAndMakeAscending(start, end)
+			binarySort(start, end, start+initRunLen)
+			return
+
+		//March over the array finding natural runs
+		//Extend any short natural runs to runs of length minRun
+		var/minRun = minRunLength(remaining)
+
+		do
+				//identify next run
+			var/runLen = countRunAndMakeAscending(start, end)
+
+				//if run is short, extend to min(minRun, remaining)
+			if(runLen < minRun)
+				var/force = (remaining <= minRun) ? remaining : minRun
+
+				binarySort(start, start+force, start+runLen)
+				runLen = force
+
+				//add data about run to queue
+			runBases.Add(start)
+			runLens.Add(runLen)
+
+				//maybe merge
+			mergeCollapse()
+
+				//Advance to find next run
+			start += runLen
+			remaining -= runLen
+
+		while(remaining > 0)
+
+
+			//Merge all remaining runs to complete sort
+		//ASSERT(start == end)
+		mergeForceCollapse();
+		//ASSERT(runBases.len == 1)
+
+			//reset minGallop, for successive calls
+		minGallop = MIN_GALLOP
+
+		return L
+
+	/*
+	Sorts the specified portion of the specified array using a binary
+	insertion sort.  This is the best method for sorting small numbers
+	of elements.  It requires O(n log n) compares, but O(n^2) data
+	movement (worst case).
+
+	If the initial part of the specified range is already sorted,
+	this method can take advantage of it: the method assumes that the
+	elements in range [lo,start) are already sorted
+
+	lo		the index of the first element in the range to be sorted
+	hi		the index after the last element in the range to be sorted
+	start	the index of the first element in the range that is	not already known to be sorted
+	*/
+	proc/binarySort(lo, hi, start)
+		//ASSERT(lo <= start && start <= hi)
+		if(start <= lo)
+			start = lo + 1
+
+		for(,start < hi, ++start)
+			var/pivot = fetchElement(L,start)
+
+			//set left and right to the index where pivot belongs
+			var/left = lo
+			var/right = start
+			//ASSERT(left <= right)
+
+			//[lo, left) elements <= pivot < [right, start) elements
+			//in other words, find where the pivot element should go using bisection search
+			while(left < right)
+				var/mid = (left + right) >> 1	//round((left+right)/2)
+				if(call(cmp)(fetchElement(L,mid), pivot) > 0)
+					right = mid
+				else
+					left = mid+1
+
+			//ASSERT(left == right)
+			moveElement(L, start, left)	//move pivot element to correct location in the sorted range
+
+	/*
+	Returns the length of the run beginning at the specified position and reverses the run if it is back-to-front
+
+	A run is the longest ascending sequence with:
+		a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
+	or the longest descending sequence with:
+		a[lo] >  a[lo + 1] >  a[lo + 2] >  ...
+
+	For its intended use in a stable mergesort, the strictness of the
+	definition of "descending" is needed so that the call can safely
+	reverse a descending sequence without violating stability.
+	*/
+	proc/countRunAndMakeAscending(lo, hi)
+		//ASSERT(lo < hi)
+
+		var/runHi = lo + 1
+		if(runHi >= hi)
+			return 1
+
+		var/last = fetchElement(L,lo)
+		var/current = fetchElement(L,runHi++)
+
+		if(call(cmp)(current, last) < 0)
+			while(runHi < hi)
+				last = current
+				current = fetchElement(L,runHi)
+				if(call(cmp)(current, last) >= 0)
+					break
+				++runHi
+			reverseRange(L, lo, runHi)
+		else
+			while(runHi < hi)
+				last = current
+				current = fetchElement(L,runHi)
+				if(call(cmp)(current, last) < 0)
+					break
+				++runHi
+
+		return runHi - lo
+
+	//Returns the minimum acceptable run length for an array of the specified length.
+	//Natural runs shorter than this will be extended with binarySort
+	proc/minRunLength(n)
+		//ASSERT(n >= 0)
+		var/r = 0	//becomes 1 if any bits are shifted off
+		while(n >= MIN_MERGE)
+			r |= (n & 1)
+			n >>= 1
+		return n + r
+
+	//Examines the stack of runs waiting to be merged and merges adjacent runs until the stack invariants are reestablished:
+	//	runLen[i-3] > runLen[i-2] + runLen[i-1]
+	//	runLen[i-2] > runLen[i-1]
+	//This method is called each time a new run is pushed onto the stack.
+	//So the invariants are guaranteed to hold for i<stackSize upon entry to the method
+	proc/mergeCollapse()
+		while(runBases.len >= 2)
+			var/n = runBases.len - 1
+			if(n > 1 && runLens[n-1] <= runLens[n] + runLens[n+1])
+				if(runLens[n-1] < runLens[n+1])
+					--n
+				mergeAt(n)
+			else if(runLens[n] <= runLens[n+1])
+				mergeAt(n)
+			else
+				break	//Invariant is established
+
+
+	//Merges all runs on the stack until only one remains.
+	//Called only once, to finalise the sort
+	proc/mergeForceCollapse()
+		while(runBases.len >= 2)
+			var/n = runBases.len - 1
+			if(n > 1 && runLens[n-1] < runLens[n+1])
+				--n
+			mergeAt(n)
+
+
+	//Merges the two consecutive runs at stack indices i and i+1
+	//Run i must be the penultimate or antepenultimate run on the stack
+	//In other words, i must be equal to stackSize-2 or stackSize-3
+	proc/mergeAt(i)
+		//ASSERT(runBases.len >= 2)
+		//ASSERT(i >= 1)
+		//ASSERT(i == runBases.len - 1 || i == runBases.len - 2)
+
+		var/base1 = runBases[i]
+		var/base2 = runBases[i+1]
+		var/len1 = runLens[i]
+		var/len2 = runLens[i+1]
+
+		//ASSERT(len1 > 0 && len2 > 0)
+		//ASSERT(base1 + len1 == base2)
+
+		//Record the legth of the combined runs. If i is the 3rd last run now, also slide over the last run
+		//(which isn't involved in this merge). The current run (i+1) goes away in any case.
+		runLens[i] += runLens[i+1]
+		runLens.Cut(i+1, i+2)
+		runBases.Cut(i+1, i+2)
+
+
+		//Find where the first element of run2 goes in run1.
+		//Prior elements in run1 can be ignored (because they're already in place)
+		var/k = gallopRight(fetchElement(L,base2), base1, len1, 0)
+		//ASSERT(k >= 0)
+		base1 += k
+		len1 -= k
+		if(len1 == 0)
+			return
+
+		//Find where the last element of run1 goes in run2.
+		//Subsequent elements in run2 can be ignored (because they're already in place)
+		len2 = gallopLeft(fetchElement(L,base1 + len1 - 1), base2, len2, len2-1)
+		//ASSERT(len2 >= 0)
+		if(len2 == 0)
+			return
+
+		//Merge remaining runs, using tmp array with min(len1, len2) elements
+		if(len1 <= len2)
+			mergeLo(base1, len1, base2, len2)
+		else
+			mergeHi(base1, len1, base2, len2)
+
+
+	/*
+		Locates the position to insert key within the specified sorted range
+		If the range contains elements equal to key, this will return the index of the LEFTMOST of those elements
+
+		key		the element to be inserted into the sorted range
+		base	the index of the first element of the sorted range
+		len		the length of the sorted range, must be greater than 0
+		hint	the offset from base at which to begin the search, such that 0 <= hint < len; i.e. base <= hint < base+hint
+
+		Returns the index at which to insert element 'key'
+	*/
+	proc/gallopLeft(key, base, len, hint)
+		//ASSERT(len > 0 && hint >= 0 && hint < len)
+
+		var/lastOffset = 0
+		var/offset = 1
+		if(call(cmp)(key, fetchElement(L,base+hint)) > 0)
+			var/maxOffset = len - hint
+			while(offset < maxOffset && call(cmp)(key, fetchElement(L,base+hint+offset)) > 0)
+				lastOffset = offset
+				offset = (offset << 1) + 1
+
+			if(offset > maxOffset)
+				offset = maxOffset
+
+			lastOffset += hint
+			offset += hint
+
+		else
+			var/maxOffset = hint + 1
+			while(offset < maxOffset && call(cmp)(key, fetchElement(L,base+hint-offset)) <= 0)
+				lastOffset = offset
+				offset = (offset << 1) + 1
+
+			if(offset > maxOffset)
+				offset = maxOffset
+
+			var/temp = lastOffset
+			lastOffset = hint - offset
+			offset = hint - temp
+
+			//ASSERT(-1 <= lastOffset && lastOffset < offset && offset <= len)
+
+		//Now L[base+lastOffset] < key <= L[base+offset], so key belongs somewhere to the right of lastOffset but no farther than
+		//offset. Do a binary search with invariant L[base+lastOffset-1] < key <= L[base+offset]
+		++lastOffset
+		while(lastOffset < offset)
+			var/m = lastOffset + ((offset - lastOffset) >> 1)
+
+			if(call(cmp)(key, fetchElement(L,base+m)) > 0)
+				lastOffset = m + 1
+			else
+				offset = m
+
+		//ASSERT(lastOffset == offset)
+		return offset
+
+	/**
+	 * Like gallopLeft, except that if the range contains an element equal to
+	 * key, gallopRight returns the index after the rightmost equal element.
+	 *
+	 * @param key the key whose insertion point to search for
+	 * @param a the array in which to search
+	 * @param base the index of the first element in the range
+	 * @param len the length of the range; must be > 0
+	 * @param hint the index at which to begin the search, 0 <= hint < n.
+	 *	 The closer hint is to the result, the faster this method will run.
+	 * @param c the comparator used to order the range, and to search
+	 * @return the int k,  0 <= k <= n such that a[b + k - 1] <= key < a[b + k]
+	 */
+	proc/gallopRight(key, base, len, hint)
+		//ASSERT(len > 0 && hint >= 0 && hint < len)
+
+		var/offset = 1
+		var/lastOffset = 0
+		if(call(cmp)(key, fetchElement(L,base+hint)) < 0)	//key <= L[base+hint]
+			var/maxOffset = hint + 1	//therefore we want to insert somewhere in the range [base,base+hint] = [base+,base+(hint+1))
+			while(offset < maxOffset && call(cmp)(key, fetchElement(L,base+hint-offset)) < 0)	//we are iterating backwards
+				lastOffset = offset
+				offset = (offset << 1) + 1	//1 3 7 15
+
+			if(offset > maxOffset)
+				offset = maxOffset
+
+			var/temp = lastOffset
+			lastOffset = hint - offset
+			offset = hint - temp
+
+		else	//key > L[base+hint]
+			var/maxOffset = len - hint	//therefore we want to insert somewhere in the range (base+hint,base+len) = [base+hint+1, base+hint+(len-hint))
+			while(offset < maxOffset && call(cmp)(key, fetchElement(L,base+hint+offset)) >= 0)
+				lastOffset = offset
+				offset = (offset << 1) + 1
+
+			if(offset > maxOffset)
+				offset = maxOffset
+
+			lastOffset += hint
+			offset += hint
+
+		//ASSERT(-1 <= lastOffset && lastOffset < offset && offset <= len)
+
+		++lastOffset
+		while(lastOffset < offset)
+			var/m = lastOffset + ((offset - lastOffset) >> 1)
+
+			if(call(cmp)(key, fetchElement(L,base+m)) < 0)	//key <= L[base+m]
+				offset = m
+			else							//key > L[base+m]
+				lastOffset = m + 1
+
+		//ASSERT(lastOffset == offset)
+
+		return offset
+
+
+	//Merges two adjacent runs in-place in a stable fashion.
+	//For performance this method should only be called when len1 <= len2!
+	proc/mergeLo(base1, len1, base2, len2)
+		//ASSERT(len1 > 0 && len2 > 0 && base1 + len1 == base2)
+
+		var/cursor1 = base1
+		var/cursor2 = base2
+
+		//degenerate cases
+		if(len2 == 1)
+			moveElement(L, cursor2, cursor1)
+			return
+
+		if(len1 == 1)
+			moveElement(L, cursor1, cursor2+len2)
+			return
+
+
+		//Move first element of second run
+		moveElement(L, cursor2++, cursor1++)
+		--len2
+
+		outer:
+			while(1)
+				var/count1 = 0	//# of times in a row that first run won
+				var/count2 = 0	//	"	"	"	"	"	"  second run won
+
+				//do the straightfoward thin until one run starts winning consistently
+
+				do
+					//ASSERT(len1 > 1 && len2 > 0)
+					if(call(cmp)(fetchElement(L,cursor2), fetchElement(L,cursor1)) < 0)
+						moveElement(L, cursor2++, cursor1++)
+						--len2
+
+						++count2
+						count1 = 0
+
+						if(len2 == 0)
+							break outer
+					else
+						++cursor1
+
+						++count1
+						count2 = 0
+
+						if(--len1 == 1)
+							break outer
+
+				while((count1 | count2) < minGallop)
+
+
+				//one run is winning consistently so galloping may provide huge benifits
+				//so try galloping, until such time as the run is no longer consistently winning
+				do
+					//ASSERT(len1 > 1 && len2 > 0)
+
+					count1 = gallopRight(fetchElement(L,cursor2), cursor1, len1, 0)
+					if(count1)
+						cursor1 += count1
+						len1 -= count1
+
+						if(len1 <= 1)
+							break outer
+
+					moveElement(L, cursor2, cursor1)
+					++cursor2
+					++cursor1
+					if(--len2 == 0)
+						break outer
+
+					count2 = gallopLeft(fetchElement(L,cursor1), cursor2, len2, 0)
+					if(count2)
+						moveRange(L, cursor2, cursor1, count2)
+
+						cursor2 += count2
+						cursor1 += count2
+						len2 -= count2
+
+						if(len2 == 0)
+							break outer
+
+					++cursor1
+					if(--len1 == 1)
+						break outer
+
+					--minGallop
+
+				while((count1|count2) > MIN_GALLOP)
+
+				if(minGallop < 0)
+					minGallop = 0
+				minGallop += 2;  // Penalize for leaving gallop mode
+
+
+		if(len1 == 1)
+			//ASSERT(len2 > 0)
+			moveElement(L, cursor1, cursor2+len2)
+
+		//else
+			//ASSERT(len2 == 0)
+			//ASSERT(len1 > 1)
+
+
+	proc/mergeHi(base1, len1, base2, len2)
+		//ASSERT(len1 > 0 && len2 > 0 && base1 + len1 == base2)
+
+		var/cursor1 = base1 + len1 - 1	//start at end of sublists
+		var/cursor2 = base2 + len2 - 1
+
+		//degenerate cases
+		if(len2 == 1)
+			moveElement(L, base2, base1)
+			return
+
+		if(len1 == 1)
+			moveElement(L, base1, cursor2+1)
+			return
+
+		moveElement(L, cursor1--, cursor2-- + 1)
+		--len1
+
+		outer:
+			while(1)
+				var/count1 = 0	//# of times in a row that first run won
+				var/count2 = 0	//	"	"	"	"	"	"  second run won
+
+				//do the straightfoward thing until one run starts winning consistently
+				do
+					//ASSERT(len1 > 0 && len2 > 1)
+					if(call(cmp)(fetchElement(L,cursor2), fetchElement(L,cursor1)) < 0)
+						moveElement(L, cursor1--, cursor2-- + 1)
+						--len1
+
+						++count1
+						count2 = 0
+
+						if(len1 == 0)
+							break outer
+					else
+						--cursor2
+						--len2
+
+						++count2
+						count1 = 0
+
+						if(len2 == 1)
+							break outer
+				while((count1 | count2) < minGallop)
+
+				//one run is winning consistently so galloping may provide huge benifits
+				//so try galloping, until such time as the run is no longer consistently winning
+				do
+					//ASSERT(len1 > 0 && len2 > 1)
+
+					count1 = len1 - gallopRight(fetchElement(L,cursor2), base1, len1, len1-1)	//should cursor1 be base1?
+					if(count1)
+						cursor1 -= count1
+
+						moveRange(L, cursor1+1, cursor2+1, count1)	//cursor1+1 == cursor2 by definition
+
+						cursor2 -= count1
+						len1 -= count1
+
+						if(len1 == 0)
+							break outer
+
+					--cursor2
+
+					if(--len2 == 1)
+						break outer
+
+					count2 = len2 - gallopLeft(fetchElement(L,cursor1), cursor1+1, len2, len2-1)
+					if(count2)
+						cursor2 -= count2
+						len2 -= count2
+
+						if(len2 <= 1)
+							break outer
+
+					moveElement(L, cursor1--, cursor2-- + 1)
+					--len1
+
+					if(len1 == 0)
+						break outer
+
+					--minGallop
+				while((count1|count2) > MIN_GALLOP)
+
+				if(minGallop < 0)
+					minGallop = 0
+				minGallop += 2	// Penalize for leaving gallop mode
+
+		if(len2 == 1)
+			//ASSERT(len1 > 0)
+
+			cursor1 -= len1
+			moveRange(L, cursor1+1, cursor2+1, len1)
+
+		//else
+			//ASSERT(len1 == 0)
+			//ASSERT(len2 > 0)
+
+
+	proc/mergeSort(start, end)
+		var/remaining = end - start
+
+		//If array is small, do an insertion sort
+		if(remaining < MIN_MERGE)
+			binarySort(start, end, start/*+initRunLen*/)
+			return
+
+		var/minRun = minRunLength(remaining)
+
+		do
+			var/runLen = (remaining <= minRun) ? remaining : minRun
+
+			binarySort(start, start+runLen, start)
+
+			//add data about run to queue
+			runBases.Add(start)
+			runLens.Add(runLen)
+
+			//Advance to find next run
+			start += runLen
+			remaining -= runLen
+
+		while(remaining > 0)
+
+		while(runBases.len >= 2)
+			var/n = runBases.len - 1
+			if(n > 1 && runLens[n-1] <= runLens[n] + runLens[n+1])
+				if(runLens[n-1] < runLens[n+1])
+					--n
+				mergeAt2(n)
+			else if(runLens[n] <= runLens[n+1])
+				mergeAt2(n)
+			else
+				break	//Invariant is established
+
+		while(runBases.len >= 2)
+			var/n = runBases.len - 1
+			if(n > 1 && runLens[n-1] < runLens[n+1])
+				--n
+			mergeAt2(n)
+
+		return L
+
+	proc/mergeAt2(i)
+		var/cursor1 = runBases[i]
+		var/cursor2 = runBases[i+1]
+
+		var/end1 = cursor1+runLens[i]
+		var/end2 = cursor2+runLens[i+1]
+
+		var/val1 = fetchElement(L,cursor1)
+		var/val2 = fetchElement(L,cursor2)
+
+		while(1)
+			if(call(cmp)(val1,val2) <= 0)
+				if(++cursor1 >= end1)
+					break
+				val1 = fetchElement(L,cursor1)
+			else
+				moveElement(L,cursor2,cursor1)
+
+				if(++cursor2 >= end2)
+					break
+				++end1
+				++cursor1
+
+				val2 = fetchElement(L,cursor2)
+
+
+		//Record the legth of the combined runs. If i is the 3rd last run now, also slide over the last run
+		//(which isn't involved in this merge). The current run (i+1) goes away in any case.
+		runLens[i] += runLens[i+1]
+		runLens.Cut(i+1, i+2)
+		runBases.Cut(i+1, i+2)
+
+#undef MIN_GALLOP
+#undef MIN_MERGE
+
+#undef fetchElement

code/__HELPERS/time.dm

@@ -165,4 +165,11 @@ proc/isDay(var/month, var/day)
 	else
 		day = "1 day"
 
-	return "[day][hour][minute][second]"
+	return "[day][hour][minute][second]"
+
+GLOBAL_VAR_INIT(midnight_rollovers, 0)
+GLOBAL_VAR_INIT(rollovercheck_last_timeofday, 0)
+/proc/update_midnight_rollover()
+	if (world.timeofday < GLOB.rollovercheck_last_timeofday) //TIME IS GOING BACKWARDS!
+		return GLOB.midnight_rollovers++
+	return GLOB.midnight_rollovers

code/__HELPERS/unsorted.dm

@@ -1914,3 +1914,10 @@ var/mob/dview/dview_mob = new
 		for(var/atom/thing in here)
 			if(istype(thing, type) && (check_shift && thing.pixel_x == shift_x && thing.pixel_y == shift_y))
 				. += thing
+
+//gives us the stack trace from CRASH() without ending the current proc.
+/proc/stack_trace(msg)
+	CRASH(msg)
+
+/datum/proc/stack_trace(msg)
+	CRASH(msg)

code/controllers/ProcessScheduler/core/process.dm

@@ -34,8 +34,6 @@
 	/**
 	 * Config vars
 	 */
-	// Process name
-	var/name
 
 	// Process schedule interval
 	// This controls how often the process would run under ideal conditions.
@@ -364,7 +362,7 @@
 	var/highestRunTime = round(highest_run_time, 0.001)
 	var/deferTime = round(cpu_defer_count / 10 * world.tick_lag, 0.01)
 	if(!statclick)
-		statclick = new (src)
+		statclick = new /obj/effect/statclick/debug(src)
 	stat("[name]", statclick.update("T#[getTicks()] | AR [averageRunTime] | LR [lastRunTime] | HR [highestRunTime] | D [deferTime]"))
 
 /datum/controller/process/proc/catchException(var/exception/e, var/thrower)

code/controllers/ProcessScheduler/core/processScheduler.dm

@@ -232,7 +232,7 @@ var/global/datum/controller/processScheduler/processScheduler
 		stat("Processes", "Scheduler not running")
 		return
 	if(!statclick)
-		statclick = new (src)
+		statclick = new /obj/effect/statclick/debug(src)
 	stat("Processes", statclick.update("[processes.len] (R [running.len] / Q [queued.len] / I [idle.len])"))
 	for(var/datum/controller/process/p in processes)
 		p.statProcess()

code/controllers/configuration.dm

@@ -189,6 +189,16 @@
 
 	var/disable_karma = 0 // Disable all karma functions and unlock karma jobs by default
 
+	// StonedMC
+	var/tick_limit_mc_init = TICK_LIMIT_MC_INIT_DEFAULT	//SSinitialization throttling
+
+	// Highpop tickrates
+	var/base_mc_tick_rate = 1
+	var/high_pop_mc_tick_rate = 1.1
+
+	var/high_pop_mc_mode_amount = 65
+	var/disable_high_pop_mc_mode_amount	= 60
+
 /datum/configuration/New()
 	var/list/L = subtypesof(/datum/game_mode)
 	for(var/T in L)

code/controllers/controller.dm

@@ -0,0 +1,19 @@
+/datum/controller
+	var/name
+	// The object used for the clickable stat() button.
+	var/obj/effect/statclick/statclick
+
+/datum/controller/proc/Initialize()
+
+//cleanup actions
+/datum/controller/proc/Shutdown()
+
+//when we enter dmm_suite.load_map
+/datum/controller/proc/StartLoadingMap()
+
+//when we exit dmm_suite.load_map
+/datum/controller/proc/StopLoadingMap()
+
+/datum/controller/proc/Recover()
+
+/datum/controller/proc/stat_entry()

code/controllers/failsafe.dm

@@ -1,39 +1,97 @@
-var/global/datum/controller/failsafe/failsafe
+var/global/datum/controller/failsafe/Failsafe
 
-/datum/controller/failsafe // This thing pretty much just keeps poking the controllers.
-	processing_interval = 100 // Poke the controllers every 10 seconds.
 
-	/*
-	 * Controller alert level.
-	 * For every poke that fails this is raised by 1.
-	 * When it reaches 5 the MC is replaced with a new one
-	 * (effectively killing any controller process() and starting a new one).
-	 */
+/datum/controller/failsafe // This thing pretty much just keeps poking the master controller
+	name = "Failsafe"
 
-	// master
-	var/masterControllerIteration = 0
-	var/masterControllerAlertLevel = 0
+	// The length of time to check on the MC (in deciseconds).
+	// Set to 0 to disable.
+	var/processing_interval = 20
+	// The alert level. For every failed poke, we drop a DEFCON level. Once we hit DEFCON 1, restart the MC.
+	var/defcon = 5
+	//the world.time of the last check, so the mc can restart US if we hang.
+	//	(Real friends look out for *eachother*)
+	var/lasttick = 0
+
+	// Track the MC iteration to make sure its still on track.
+	var/master_iteration = 0
+	var/running = TRUE
 
 /datum/controller/failsafe/New()
-	. = ..()
+	// Highlander-style: there can only be one! Kill off the old and replace it with the new.
+	if(Failsafe != src)
+		if(istype(Failsafe))
+			qdel(Failsafe)
+	Failsafe = src
+	Initialize()
 
-	// There can be only one failsafe. Out with the old in with the new (that way we can restart the Failsafe by spawning a new one).
-	if(failsafe != src)
-		if(istype(failsafe))
-			recover()
-			qdel(failsafe)
+/datum/controller/failsafe/Initialize()
+	set waitfor = 0
+	Failsafe.Loop()
+	if(!qdeleted(src))
+		qdel(src) //when Loop() returns, we delete ourselves and let the mc recreate us
 
-		failsafe = src
+/datum/controller/failsafe/Destroy()
+	running = FALSE
+	..()
+	return QDEL_HINT_HARDDEL_NOW
 
-	//failsafe.process()
+/datum/controller/failsafe/proc/Loop()
+	while(running)
+		lasttick = world.time
+		if(!Master)
+			// Replace the missing Master! This should never, ever happen.
+			new /datum/controller/master()
+		// Only poke it if overrides are not in effect.
+		if(processing_interval > 0)
+			if(Master.processing && Master.iteration)
+				// Check if processing is done yet.
+				if(Master.iteration == master_iteration)
+					switch(defcon)
+						if(4,5)
+							--defcon
+						if(3)
+							message_admins("<span class='adminnotice'>Notice: DEFCON [defcon_pretty()]. The Master Controller has not fired in the last [(5-defcon) * processing_interval] ticks.</span>")
+							--defcon
+						if(2)
+							to_chat(admins, "<span class='boldannounce'>Warning: DEFCON [defcon_pretty()]. The Master Controller has not fired in the last [(5-defcon) * processing_interval] ticks. Automatic restart in [processing_interval] ticks.</span>")
+							--defcon
+						if(1)
 
-/datum/controller/failsafe/proc/process()
-	processing = 1
+							to_chat(admins, "<span class='boldannounce'>Warning: DEFCON [defcon_pretty()]. The Master Controller has still not fired within the last [(5-defcon) * processing_interval] ticks. Killing and restarting...</span>")
+							--defcon
+							var/rtn = Recreate_MC()
+							if(rtn > 0)
+								defcon = 4
+								master_iteration = 0
+								to_chat(admins, "<span class='adminnotice'>MC restarted successfully</span>")
+							else if(rtn < 0)
+								log_game("FailSafe: Could not restart MC, runtime encountered. Entering defcon 0")
+								to_chat(admins, "<span class='boldannounce'>ERROR: DEFCON [defcon_pretty()]. Could not restart MC, runtime encountered. I will silently keep retrying.</span>")
+							//if the return number was 0, it just means the mc was restarted too recently, and it just needs some time before we try again
+							//no need to handle that specially when defcon 0 can handle it
+						if(0) //DEFCON 0! (mc failed to restart)
+							var/rtn = Recreate_MC()
+							if(rtn > 0)
+								defcon = 4
+								master_iteration = 0
+								to_chat(admins, "<span class='adminnotice'>MC restarted successfully</span>")
+				else
+					defcon = min(defcon + 1,5)
+					master_iteration = Master.iteration
+			if (defcon <= 1)
+				sleep(processing_interval*2)
+			else
+				sleep(processing_interval)
+		else
+			defcon = 5
+			sleep(initial(processing_interval))
 
-	spawn(0)
-		set background = BACKGROUND_ENABLED
+/datum/controller/failsafe/proc/defcon_pretty()
+	return defcon
 
-		while(1) // More efficient than recursivly calling ourself over and over. background = 1 ensures we do not trigger an infinite loop.
-			iteration++
+/datum/controller/failsafe/stat_entry()
+	if(!statclick)
+		statclick = new/obj/effect/statclick/debug(src, "Initializing...")
 
-			sleep(processing_interval)
+	stat("Failsafe Controller:", statclick.update("Defcon: [defcon_pretty()] (Interval: [Failsafe.processing_interval] | Iteration: [Failsafe.master_iteration])"))

code/controllers/globals.dm

@@ -0,0 +1,69 @@
+GLOBAL_REAL(GLOB, /datum/controller/global_vars)
+
+/datum/controller/global_vars
+	name = "Global Variables"
+
+	var/list/gvars_datum_protected_varlist
+	var/list/gvars_datum_in_built_vars
+	var/list/gvars_datum_init_order
+
+/datum/controller/global_vars/New()
+	if(GLOB)
+		CRASH("Multiple instances of global variable controller created")
+	GLOB = src
+
+	var/datum/controller/exclude_these = new
+	gvars_datum_in_built_vars = exclude_these.vars + list("gvars_datum_protected_varlist", "gvars_datum_in_built_vars", "gvars_datum_init_order")
+	qdel(exclude_these)
+
+	log_to_dd("[vars.len - gvars_datum_in_built_vars.len] global variables")
+
+	Initialize()
+
+/datum/controller/global_vars/Destroy(force)
+	stack_trace("Some fucker qdel'd the global holder!")
+	if(!force)
+		return QDEL_HINT_LETMELIVE
+	
+	QDEL_NULL(statclick)
+	gvars_datum_protected_varlist.Cut()
+	gvars_datum_in_built_vars.Cut()
+	
+	GLOB = null
+
+	return ..()
+
+/datum/controller/global_vars/stat_entry()
+	if(!statclick)
+		statclick = new/obj/effect/statclick/debug(src, "Initializing...")
+	
+	stat("Globals:", statclick.update("Edit"))
+
+/datum/controller/global_vars/can_vv_get(var_name)
+	if(gvars_datum_protected_varlist[var_name])
+		return FALSE
+	return ..()
+
+/datum/controller/global_vars/vv_edit_var(var_name, var_value)
+	if(gvars_datum_protected_varlist[var_name])
+		return FALSE
+	return ..()
+
+/datum/controller/global_vars/Initialize()
+	gvars_datum_init_order = list()
+	gvars_datum_protected_varlist = list("gvars_datum_protected_varlist" = TRUE)
+	var/list/global_procs = typesof(/datum/controller/global_vars/proc)
+	var/expected_len = vars.len - gvars_datum_in_built_vars.len
+	if(global_procs.len != expected_len)
+		warning("Unable to detect all global initialization procs! Expected [expected_len] got [global_procs.len]!")
+		if(global_procs.len)
+			var/list/expected_global_procs = vars - gvars_datum_in_built_vars
+			for(var/I in global_procs)
+				expected_global_procs -= replacetext("[I]", "InitGlobal", "")
+			log_to_dd("Missing procs: [expected_global_procs.Join(", ")]")
+	for(var/I in global_procs)
+		var/start_tick = world.time
+		call(src, I)()
+		var/end_tick = world.time
+		if(end_tick - start_tick)
+			warning("Global [replacetext("[I]", "InitGlobal", "")] slept during initialization!")

code/controllers/master.dm

@@ -0,0 +1,611 @@
+ /**
+  * StonedMC
+  *
+  * Designed to properly split up a given tick among subsystems
+  * Note: if you read parts of this code and think "why is it doing it that way"
+  * Odds are, there is a reason
+  *
+ **/
+
+//This is the ABSOLUTE ONLY THING that should init globally like this
+GLOBAL_REAL(Master, /datum/controller/master) = new
+
+//THIS IS THE INIT ORDER
+//Master -> SSPreInit -> GLOB -> world -> config -> SSInit -> Failsafe
+//GOT IT MEMORIZED?
+
+/datum/controller/master
+	name = "Master"
+
+	// Are we processing (higher values increase the processing delay by n ticks)
+	var/processing = TRUE
+	// How many times have we ran
+	var/iteration = 0
+
+	// world.time of last fire, for tracking lag outside of the mc
+	var/last_run
+
+	// List of subsystems to process().
+	var/list/subsystems
+
+	// Vars for keeping track of tick drift.
+	var/init_timeofday
+	var/init_time
+	var/tickdrift = 0
+
+	var/sleep_delta = 1
+
+	var/make_runtime = 0
+
+	var/initializations_finished_with_no_players_logged_in	//I wonder what this could be?
+
+	// The type of the last subsystem to be process()'d.
+	var/last_type_processed
+
+	var/datum/controller/subsystem/queue_head //Start of queue linked list
+	var/datum/controller/subsystem/queue_tail //End of queue linked list (used for appending to the list)
+	var/queue_priority_count = 0 //Running total so that we don't have to loop thru the queue each run to split up the tick
+	var/queue_priority_count_bg = 0 //Same, but for background subsystems
+	var/map_loading = FALSE	//Are we loading in a new map?
+
+	var/current_runlevel	//for scheduling different subsystems for different stages of the round
+	var/sleep_offline_after_initializations = TRUE
+
+	var/static/restart_clear = 0
+	var/static/restart_timeout = 0
+	var/static/restart_count = 0
+	
+	var/static/random_seed
+
+	//current tick limit, assigned before running a subsystem.
+	//used by CHECK_TICK as well so that the procs subsystems call can obey that SS's tick limits
+	var/static/current_ticklimit = TICK_LIMIT_RUNNING
+
+/datum/controller/master/New()
+	makeDatumRefLists()
+	load_configuration()
+	// Highlander-style: there can only be one! Kill off the old and replace it with the new.
+
+	if(!random_seed)
+		random_seed = rand(1, 1e9)
+		rand_seed(random_seed)
+	
+	var/list/_subsystems = list()
+	subsystems = _subsystems
+	if (Master != src)
+		if (istype(Master))
+			Recover()
+			qdel(Master)
+		else
+			var/list/subsytem_types = subtypesof(/datum/controller/subsystem)
+			sortTim(subsytem_types, /proc/cmp_subsystem_init)
+			for(var/I in subsytem_types)
+				_subsystems += new I
+		Master = src
+
+	if(!GLOB)
+		new /datum/controller/global_vars
+
+/datum/controller/master/Destroy()
+	..()
+	// Tell qdel() to Del() this object.
+	return QDEL_HINT_HARDDEL_NOW
+
+/datum/controller/master/Shutdown()
+	processing = FALSE
+	sortTim(subsystems, /proc/cmp_subsystem_init)
+	reverseRange(subsystems)
+	for(var/datum/controller/subsystem/ss in subsystems)
+		log_to_dd("Shutting down [ss.name] subsystem...")
+		ss.Shutdown()
+	log_to_dd("Shutdown complete")
+
+// Returns 1 if we created a new mc, 0 if we couldn't due to a recent restart,
+//	-1 if we encountered a runtime trying to recreate it
+/proc/Recreate_MC()
+	. = -1 //so if we runtime, things know we failed
+	if (world.time < Master.restart_timeout)
+		return 0
+	if (world.time < Master.restart_clear)
+		Master.restart_count *= 0.5
+
+	var/delay = 50 * ++Master.restart_count
+	Master.restart_timeout = world.time + delay
+	Master.restart_clear = world.time + (delay * 2)
+	Master.processing = FALSE //stop ticking this one
+	try
+		new/datum/controller/master()
+	catch
+		return -1
+	return 1
+
+
+/datum/controller/master/Recover()
+	var/msg = "## DEBUG: [time2text(world.timeofday)] MC restarted. Reports:\n"
+	for (var/varname in Master.vars)
+		switch (varname)
+			if("name", "tag", "bestF", "type", "parent_type", "vars", "statclick") // Built-in junk.
+				continue
+			else
+				var/varval = Master.vars[varname]
+				if (istype(varval, /datum)) // Check if it has a type var.
+					var/datum/D = varval
+					msg += "\t [varname] = [D]([D.type])\n"
+				else
+					msg += "\t [varname] = [varval]\n"
+	log_to_dd(msg)
+
+	var/datum/controller/subsystem/BadBoy = Master.last_type_processed
+	var/FireHim = FALSE
+	if(istype(BadBoy))
+		msg = null
+		LAZYINITLIST(BadBoy.failure_strikes)
+		switch(++BadBoy.failure_strikes[BadBoy.type])
+			if(2)
+				msg = "The [BadBoy.name] subsystem was the last to fire for 2 controller restarts. It will be recovered now and disabled if it happens again."
+				FireHim = TRUE
+			if(3)
+				msg = "The [BadBoy.name] subsystem seems to be destabilizing the MC and will be offlined."
+				BadBoy.flags |= SS_NO_FIRE
+		if(msg)
+			to_chat(admins, "<span class='boldannounce'>[msg]</span>")
+			log_to_dd(msg)
+
+	if (istype(Master.subsystems))
+		if(FireHim)
+			Master.subsystems += new BadBoy.type	//NEW_SS_GLOBAL will remove the old one
+		subsystems = Master.subsystems
+		current_runlevel = Master.current_runlevel
+		StartProcessing(10)
+	else
+		to_chat(world, "<span class='boldannounce'>The Master Controller is having some issues, we will need to re-initialize EVERYTHING</span>")
+		Initialize(20, TRUE)
+
+
+// Please don't stuff random bullshit here,
+// 	Make a subsystem, give it the SS_NO_FIRE flag, and do your work in it's Initialize()
+/datum/controller/master/Initialize(delay, init_sss)
+	set waitfor = 0
+
+	if(delay)
+		sleep(delay)
+
+	if(init_sss)
+		init_subtypes(/datum/controller/subsystem, subsystems)
+
+	to_chat(world, "<span class='boldannounce'>Initializing subsystems...</span>")
+
+	// Sort subsystems by init_order, so they initialize in the correct order.
+	sortTim(subsystems, /proc/cmp_subsystem_init)
+
+	var/start_timeofday = REALTIMEOFDAY
+	// Initialize subsystems.
+	current_ticklimit = config.tick_limit_mc_init
+	for (var/datum/controller/subsystem/SS in subsystems)
+		if (SS.flags & SS_NO_INIT)
+			continue
+		SS.Initialize(REALTIMEOFDAY)
+		CHECK_TICK
+	current_ticklimit = TICK_LIMIT_RUNNING
+	var/time = (REALTIMEOFDAY - start_timeofday) / 10
+
+	var/msg = "Initializations complete within [time] second[time == 1 ? "" : "s"]!"
+	to_chat(world, "<span class='boldannounce'>[msg]</span>")
+	log_to_dd(msg)
+
+	if (!current_runlevel)
+		SetRunLevel(1)
+
+	// Sort subsystems by display setting for easy access.
+	sortTim(subsystems, /proc/cmp_subsystem_display)
+	// Set world options.
+	if(sleep_offline_after_initializations)
+		world.sleep_offline = TRUE
+	// world.fps = CONFIG_GET(number/fps) // TIGER TODO
+	world.tick_lag = config.Ticklag
+	var/initialized_tod = REALTIMEOFDAY
+	sleep(1)
+	initializations_finished_with_no_players_logged_in = initialized_tod < REALTIMEOFDAY - 10
+	// Loop.
+	Master.StartProcessing(0)
+
+/datum/controller/master/proc/SetRunLevel(new_runlevel)
+	var/old_runlevel = current_runlevel
+	if(isnull(old_runlevel))
+		old_runlevel = "NULL"
+
+	testing("MC: Runlevel changed from [old_runlevel] to [new_runlevel]")
+	current_runlevel = log(2, new_runlevel) + 1
+	if(current_runlevel < 1)
+		CRASH("Attempted to set invalid runlevel: [new_runlevel]")
+
+// Starts the mc, and sticks around to restart it if the loop ever ends.
+/datum/controller/master/proc/StartProcessing(delay)
+	set waitfor = 0
+	if(delay)
+		sleep(delay)
+	testing("Master starting processing")
+	var/rtn = Loop()
+	if (rtn > 0 || processing < 0)
+		return //this was suppose to happen.
+	//loop ended, restart the mc
+	log_game("MC crashed or runtimed, restarting")
+	message_admins("MC crashed or runtimed, restarting")
+	var/rtn2 = Recreate_MC()
+	if (rtn2 <= 0)
+		log_game("Failed to recreate MC (Error code: [rtn2]), it's up to the failsafe now")
+		message_admins("Failed to recreate MC (Error code: [rtn2]), it's up to the failsafe now")
+		Failsafe.defcon = 2
+
+// Main loop.
+/datum/controller/master/proc/Loop()
+	. = -1
+	//Prep the loop (most of this is because we want MC restarts to reset as much state as we can, and because
+	//	local vars rock
+
+	//all this shit is here so that flag edits can be refreshed by restarting the MC. (and for speed)
+	var/list/tickersubsystems = list()
+	var/list/runlevel_sorted_subsystems = list(list(), list(), list(), list(), list(), list(), list(), list())	//ensure we always have as many runlevels as we need to operate with no subsystems (8 currently)
+	var/timer = world.time
+	for (var/thing in subsystems)
+		var/datum/controller/subsystem/SS = thing
+		if (SS.flags & SS_NO_FIRE)
+			continue
+		SS.queued_time = 0
+		SS.queue_next = null
+		SS.queue_prev = null
+		SS.state = SS_IDLE
+		if (SS.flags & SS_TICKER)
+			tickersubsystems += SS
+			timer += world.tick_lag * rand(1, 5)
+			SS.next_fire = timer
+			continue
+
+		var/ss_runlevels = SS.runlevels
+		var/added_to_any = FALSE
+		for(var/I in 1 to GLOB.bitflags.len)
+			if(ss_runlevels & GLOB.bitflags[I])
+				while(runlevel_sorted_subsystems.len < I)
+					runlevel_sorted_subsystems += list(list())
+				runlevel_sorted_subsystems[I] += SS
+				added_to_any = TRUE
+		if(!added_to_any)
+			WARNING("[SS.name] subsystem is not SS_NO_FIRE but also does not have any runlevels set!")
+
+	queue_head = null
+	queue_tail = null
+	//these sort by lower priorities first to reduce the number of loops needed to add subsequent SS's to the queue
+	//(higher subsystems will be sooner in the queue, adding them later in the loop means we don't have to loop thru them next queue add)
+	sortTim(tickersubsystems, /proc/cmp_subsystem_priority)
+	for(var/I in runlevel_sorted_subsystems)
+		sortTim(runlevel_sorted_subsystems, /proc/cmp_subsystem_priority)
+		I += tickersubsystems
+
+	var/cached_runlevel = current_runlevel
+	var/list/current_runlevel_subsystems = runlevel_sorted_subsystems[cached_runlevel]
+
+	init_timeofday = REALTIMEOFDAY
+	init_time = world.time
+
+	iteration = 1
+	var/error_level = 0
+	var/sleep_delta = 1
+	var/list/subsystems_to_check
+	//the actual loop.
+
+	while (1)
+		tickdrift = max(0, MC_AVERAGE_FAST(tickdrift, (((REALTIMEOFDAY - init_timeofday) - (world.time - init_time)) / world.tick_lag)))
+		var/starting_tick_usage = TICK_USAGE
+		if (processing <= 0)
+			current_ticklimit = TICK_LIMIT_RUNNING
+			sleep(10)
+			continue
+
+		//Anti-tick-contention heuristics:
+		//if there are mutiple sleeping procs running before us hogging the cpu, we have to run later.
+		//	(because sleeps are processed in the order received, longer sleeps are more likely to run first)
+		if (starting_tick_usage > TICK_LIMIT_MC) //if there isn't enough time to bother doing anything this tick, sleep a bit.
+			sleep_delta *= 2
+			current_ticklimit = TICK_LIMIT_RUNNING * 0.5
+			sleep(world.tick_lag * (processing * sleep_delta))
+			continue
+
+		//Byond resumed us late. assume it might have to do the same next tick
+		if (last_run + CEILING(world.tick_lag * (processing * sleep_delta), world.tick_lag) < world.time)
+			sleep_delta += 1
+
+		sleep_delta = MC_AVERAGE_FAST(sleep_delta, 1) //decay sleep_delta
+
+		if (starting_tick_usage > (TICK_LIMIT_MC*0.75)) //we ran 3/4 of the way into the tick
+			sleep_delta += 1
+
+		//debug
+		if (make_runtime)
+			var/datum/controller/subsystem/SS
+			SS.can_fire = 0
+
+		if (!Failsafe || (Failsafe.processing_interval > 0 && (Failsafe.lasttick+(Failsafe.processing_interval*5)) < world.time))
+			new/datum/controller/failsafe() // (re)Start the failsafe.
+
+		//now do the actual stuff
+		if (!queue_head || !(iteration % 3))
+			var/checking_runlevel = current_runlevel
+			if(cached_runlevel != checking_runlevel)
+				//resechedule subsystems
+				cached_runlevel = checking_runlevel
+				current_runlevel_subsystems = runlevel_sorted_subsystems[cached_runlevel]
+				var/stagger = world.time
+				for(var/I in current_runlevel_subsystems)
+					var/datum/controller/subsystem/SS = I
+					if(SS.next_fire <= world.time)
+						stagger += world.tick_lag * rand(1, 5)
+						SS.next_fire = stagger
+
+			subsystems_to_check = current_runlevel_subsystems
+		else
+			subsystems_to_check = tickersubsystems
+
+		if (CheckQueue(subsystems_to_check) <= 0)
+			if (!SoftReset(tickersubsystems, runlevel_sorted_subsystems))
+				log_to_dd("MC: SoftReset() failed, crashing")
+				return
+			if (!error_level)
+				iteration++
+			error_level++
+			current_ticklimit = TICK_LIMIT_RUNNING
+			sleep(10)
+			continue
+
+		if (queue_head)
+			if (RunQueue() <= 0)
+				if (!SoftReset(tickersubsystems, runlevel_sorted_subsystems))
+					log_to_dd("MC: SoftReset() failed, crashing")
+					return
+				if (!error_level)
+					iteration++
+				error_level++
+				current_ticklimit = TICK_LIMIT_RUNNING
+				sleep(10)
+				continue
+		error_level--
+		if (!queue_head) //reset the counts if the queue is empty, in the off chance they get out of sync
+			queue_priority_count = 0
+			queue_priority_count_bg = 0
+
+		iteration++
+		last_run = world.time
+		src.sleep_delta = MC_AVERAGE_FAST(src.sleep_delta, sleep_delta)
+		current_ticklimit = TICK_LIMIT_RUNNING
+		if (processing * sleep_delta <= world.tick_lag)
+			current_ticklimit -= (TICK_LIMIT_RUNNING * 0.25) //reserve the tail 1/4 of the next tick for the mc if we plan on running next tick
+		sleep(world.tick_lag * (processing * sleep_delta))
+
+
+
+
+// This is what decides if something should run.
+/datum/controller/master/proc/CheckQueue(list/subsystemstocheck)
+	. = 0 //so the mc knows if we runtimed
+
+	//we create our variables outside of the loops to save on overhead
+	var/datum/controller/subsystem/SS
+	var/SS_flags
+
+	for (var/thing in subsystemstocheck)
+		if (!thing)
+			subsystemstocheck -= thing
+		SS = thing
+		if (SS.state != SS_IDLE)
+			continue
+		if (SS.can_fire <= 0)
+			continue
+		if (SS.next_fire > world.time)
+			continue
+		SS_flags = SS.flags
+		if (SS_flags & SS_NO_FIRE)
+			subsystemstocheck -= SS
+			continue
+		if (!(SS_flags & SS_TICKER) && (SS_flags & SS_KEEP_TIMING) && SS.last_fire + (SS.wait * 0.75) > world.time)
+			continue
+		SS.enqueue()
+	. = 1
+
+
+// Run thru the queue of subsystems to run, running them while balancing out their allocated tick precentage
+/datum/controller/master/proc/RunQueue()
+	. = 0
+	var/datum/controller/subsystem/queue_node
+	var/queue_node_flags
+	var/queue_node_priority
+	var/queue_node_paused
+
+	var/current_tick_budget
+	var/tick_precentage
+	var/tick_remaining
+	var/ran = TRUE //this is right
+	var/ran_non_ticker = FALSE
+	var/bg_calc //have we swtiched current_tick_budget to background mode yet?
+	var/tick_usage
+
+	//keep running while we have stuff to run and we haven't gone over a tick
+	//	this is so subsystems paused eariler can use tick time that later subsystems never used
+	while (ran && queue_head && TICK_USAGE < TICK_LIMIT_MC)
+		ran = FALSE
+		bg_calc = FALSE
+		current_tick_budget = queue_priority_count
+		queue_node = queue_head
+		while (queue_node)
+			if (ran && TICK_USAGE > TICK_LIMIT_RUNNING)
+				break
+
+			queue_node_flags = queue_node.flags
+			queue_node_priority = queue_node.queued_priority
+
+			//super special case, subsystems where we can't make them pause mid way through
+			//if we can't run them this tick (without going over a tick)
+			//we bump up their priority and attempt to run them next tick
+			//(unless we haven't even ran anything this tick, since its unlikely they will ever be able run
+			//	in those cases, so we just let them run)
+			if (queue_node_flags & SS_NO_TICK_CHECK)
+				if (queue_node.tick_usage > TICK_LIMIT_RUNNING - TICK_USAGE && ran_non_ticker)
+					queue_node.queued_priority += queue_priority_count * 0.1
+					queue_priority_count -= queue_node_priority
+					queue_priority_count += queue_node.queued_priority
+					current_tick_budget -= queue_node_priority
+					queue_node = queue_node.queue_next
+					continue
+
+			if ((queue_node_flags & SS_BACKGROUND) && !bg_calc)
+				current_tick_budget = queue_priority_count_bg
+				bg_calc = TRUE
+
+			tick_remaining = TICK_LIMIT_RUNNING - TICK_USAGE
+
+			if (current_tick_budget > 0 && queue_node_priority > 0)
+				tick_precentage = tick_remaining / (current_tick_budget / queue_node_priority)
+			else
+				tick_precentage = tick_remaining
+
+			tick_precentage = max(tick_precentage*0.5, tick_precentage-queue_node.tick_overrun)
+
+			current_ticklimit = round(TICK_USAGE + tick_precentage)
+
+			if (!(queue_node_flags & SS_TICKER))
+				ran_non_ticker = TRUE
+			ran = TRUE
+
+			queue_node_paused = (queue_node.state == SS_PAUSED || queue_node.state == SS_PAUSING)
+			last_type_processed = queue_node
+
+			queue_node.state = SS_RUNNING
+
+			tick_usage = TICK_USAGE
+			var/state = queue_node.ignite(queue_node_paused)
+			tick_usage = TICK_USAGE - tick_usage
+
+			if (state == SS_RUNNING)
+				state = SS_IDLE
+			current_tick_budget -= queue_node_priority
+
+
+			if (tick_usage < 0)
+				tick_usage = 0
+			queue_node.tick_overrun = max(0, MC_AVG_FAST_UP_SLOW_DOWN(queue_node.tick_overrun, tick_usage-tick_precentage))
+			queue_node.state = state
+
+			if (state == SS_PAUSED)
+				queue_node.paused_ticks++
+				queue_node.paused_tick_usage += tick_usage
+				queue_node = queue_node.queue_next
+				continue
+
+			queue_node.ticks = MC_AVERAGE(queue_node.ticks, queue_node.paused_ticks)
+			tick_usage += queue_node.paused_tick_usage
+
+			queue_node.tick_usage = MC_AVERAGE_FAST(queue_node.tick_usage, tick_usage)
+
+			queue_node.cost = MC_AVERAGE_FAST(queue_node.cost, TICK_DELTA_TO_MS(tick_usage))
+			queue_node.paused_ticks = 0
+			queue_node.paused_tick_usage = 0
+
+			if (queue_node_flags & SS_BACKGROUND) //update our running total
+				queue_priority_count_bg -= queue_node_priority
+			else
+				queue_priority_count -= queue_node_priority
+
+			queue_node.last_fire = world.time
+			queue_node.times_fired++
+
+			if (queue_node_flags & SS_TICKER)
+				queue_node.next_fire = world.time + (world.tick_lag * queue_node.wait)
+			else if (queue_node_flags & SS_POST_FIRE_TIMING)
+				queue_node.next_fire = world.time + queue_node.wait + (world.tick_lag * (queue_node.tick_overrun/100))
+			else if (queue_node_flags & SS_KEEP_TIMING)
+				queue_node.next_fire += queue_node.wait
+			else
+				queue_node.next_fire = queue_node.queued_time + queue_node.wait + (world.tick_lag * (queue_node.tick_overrun/100))
+
+			queue_node.queued_time = 0
+
+			//remove from queue
+			queue_node.dequeue()
+
+			queue_node = queue_node.queue_next
+
+	. = 1
+
+//resets the queue, and all subsystems, while filtering out the subsystem lists
+//	called if any mc's queue procs runtime or exit improperly.
+/datum/controller/master/proc/SoftReset(list/ticker_SS, list/runlevel_SS)
+	. = 0
+	log_to_dd("MC: SoftReset called, resetting MC queue state.")
+	if (!istype(subsystems) || !istype(ticker_SS) || !istype(runlevel_SS))
+		log_to_dd("MC: SoftReset: Bad list contents: '[subsystems]' '[ticker_SS]' '[runlevel_SS]'")
+		return
+	var/subsystemstocheck = subsystems + ticker_SS
+	for(var/I in runlevel_SS)
+		subsystemstocheck |= I
+
+	for (var/thing in subsystemstocheck)
+		var/datum/controller/subsystem/SS = thing
+		if (!SS || !istype(SS))
+			//list(SS) is so if a list makes it in the subsystem list, we remove the list, not the contents
+			subsystems -= list(SS)
+			ticker_SS -= list(SS)
+			for(var/I in runlevel_SS)
+				I -= list(SS)
+			log_to_dd("MC: SoftReset: Found bad entry in subsystem list, '[SS]'")
+			continue
+		if (SS.queue_next && !istype(SS.queue_next))
+			log_to_dd("MC: SoftReset: Found bad data in subsystem queue, queue_next = '[SS.queue_next]'")
+		SS.queue_next = null
+		if (SS.queue_prev && !istype(SS.queue_prev))
+			log_to_dd("MC: SoftReset: Found bad data in subsystem queue, queue_prev = '[SS.queue_prev]'")
+		SS.queue_prev = null
+		SS.queued_priority = 0
+		SS.queued_time = 0
+		SS.state = SS_IDLE
+	if (queue_head && !istype(queue_head))
+		log_to_dd("MC: SoftReset: Found bad data in subsystem queue, queue_head = '[queue_head]'")
+	queue_head = null
+	if (queue_tail && !istype(queue_tail))
+		log_to_dd("MC: SoftReset: Found bad data in subsystem queue, queue_tail = '[queue_tail]'")
+	queue_tail = null
+	queue_priority_count = 0
+	queue_priority_count_bg = 0
+	log_to_dd("MC: SoftReset: Finished.")
+	. = 1
+
+
+
+/datum/controller/master/stat_entry()
+	if(!statclick)
+		statclick = new/obj/effect/statclick/debug(src, "Initializing...")
+
+	stat("Byond:", "(FPS:[world.fps]) (TickCount:[world.time/world.tick_lag]) (TickDrift:[round(Master.tickdrift,1)]([round((Master.tickdrift/(world.time/world.tick_lag))*100,0.1)]%))")
+	stat("Master Controller:", statclick.update("(TickRate:[Master.processing]) (Iteration:[Master.iteration])"))
+
+/datum/controller/master/StartLoadingMap()
+	//disallow more than one map to load at once, multithreading it will just cause race conditions
+	while(map_loading)
+		stoplag()
+	for(var/S in subsystems)
+		var/datum/controller/subsystem/SS = S
+		SS.StartLoadingMap()
+	map_loading = TRUE
+
+/datum/controller/master/StopLoadingMap(bounds = null)
+	map_loading = FALSE
+	for(var/S in subsystems)
+		var/datum/controller/subsystem/SS = S
+		SS.StopLoadingMap()
+
+
+/datum/controller/master/proc/UpdateTickRate()
+	if (!processing)
+		return
+	var/client_count = length(clients)
+	if (client_count < config.disable_high_pop_mc_mode_amount)
+		processing = config.base_mc_tick_rate
+	else if (client_count > config.high_pop_mc_mode_amount)
+		processing = config.high_pop_mc_tick_rate

code/controllers/master_controller.dm

@@ -1,6 +1,6 @@
-//simplified MC that is designed to fail when procs 'break'. When it fails it's just replaced with a new one.
-//It ensures master_controller.process() is never doubled up by killing the MC (hence terminating any of its sleeping procs)
-//WIP, needs lots of work still
+// old deprecated rusted piece of shit MC
+// All this does now is misc. world init stuff because too lazy to put it somewhere else
+// It used to run all of the repeating processes controlling the game but now the SMC and Process Scheduler do that
 
 var/global/datum/controller/game_controller/master_controller //Set in world.New()
 
@@ -10,16 +10,6 @@ var/global/last_tick_duration = 0
 var/global/air_processing_killed = 0
 var/global/pipe_processing_killed = 0
 
-/datum/controller
-	var/processing = 0
-	var/iteration = 0
-	var/processing_interval = 0
-
-	// Dummy object to let us click it to debug while in the stat panel
-	var/obj/effect/statclick/debug/statclick
-
-/datum/controller/proc/recover() // If we are replacing an existing controller (due to a crash) we attempt to preserve as much as we can.
-
 /datum/controller/game_controller
 	var/list/shuttle_list											// For debugging and VV
 
@@ -46,8 +36,6 @@ var/global/pipe_processing_killed = 0
 	return QDEL_HINT_HARDDEL_NOW
 
 /datum/controller/game_controller/proc/setup()
-	world.tick_lag = config.Ticklag
-
 	preloadTemplates()
 	if(!config.disable_away_missions)
 		createRandomZlevel()

code/controllers/subsystem.dm

@@ -0,0 +1,215 @@
+
+/datum/controller/subsystem
+	// Metadata; you should define these.
+	name = "fire coderbus" //name of the subsystem
+	var/init_order = INIT_ORDER_DEFAULT		//order of initialization. Higher numbers are initialized first, lower numbers later. Use defines in __DEFINES/subsystems.dm for easy understanding of order.
+	var/wait = 20			//time to wait (in deciseconds) between each call to fire(). Must be a positive integer.
+	var/priority = FIRE_PRIORITY_DEFAULT	//When mutiple subsystems need to run in the same tick, higher priority subsystems will run first and be given a higher share of the tick before MC_TICK_CHECK triggers a sleep
+
+	var/flags = 0			//see MC.dm in __DEFINES Most flags must be set on world start to take full effect. (You can also restart the mc to force them to process again)
+
+	var/initialized = FALSE	//set to TRUE after it has been initialized, will obviously never be set if the subsystem doesn't initialize
+
+	//set to 0 to prevent fire() calls, mostly for admin use or subsystems that may be resumed later
+	//	use the SS_NO_FIRE flag instead for systems that never fire to keep it from even being added to the list
+	var/can_fire = TRUE
+
+	// Bookkeeping variables; probably shouldn't mess with these.
+	var/last_fire = 0		//last world.time we called fire()
+	var/next_fire = 0		//scheduled world.time for next fire()
+	var/cost = 0			//average time to execute
+	var/tick_usage = 0		//average tick usage
+	var/tick_overrun = 0	//average tick overrun
+	var/state = SS_IDLE		//tracks the current state of the ss, running, paused, etc.
+	var/paused_ticks = 0	//ticks this ss is taking to run right now.
+	var/paused_tick_usage	//total tick_usage of all of our runs while pausing this run
+	var/ticks = 1			//how many ticks does this ss take to run on avg.
+	var/times_fired = 0		//number of times we have called fire()
+	var/queued_time = 0		//time we entered the queue, (for timing and priority reasons)
+	var/queued_priority 	//we keep a running total to make the math easier, if priority changes mid-fire that would break our running total, so we store it here
+	//linked list stuff for the queue
+	var/datum/controller/subsystem/queue_next
+	var/datum/controller/subsystem/queue_prev
+
+	var/runlevels = RUNLEVELS_DEFAULT	//points of the game at which the SS can fire
+
+	var/static/list/failure_strikes //How many times we suspect a subsystem type has crashed the MC, 3 strikes and you're out!
+
+//Do not override
+///datum/controller/subsystem/New()
+
+// Used to initialize the subsystem BEFORE the map has loaded
+// Called AFTER Recover if that is called
+// Prefer to use Initialize if possible
+/datum/controller/subsystem/proc/PreInit()
+	return
+
+//This is used so the mc knows when the subsystem sleeps. do not override.
+/datum/controller/subsystem/proc/ignite(resumed = 0)
+	set waitfor = 0
+	. = SS_SLEEPING
+	fire(resumed)
+	. = state
+	if (state == SS_SLEEPING)
+		state = SS_IDLE
+	if (state == SS_PAUSING)
+		var/QT = queued_time
+		enqueue()
+		state = SS_PAUSED
+		queued_time = QT
+
+//previously, this would have been named 'process()' but that name is used everywhere for different things!
+//fire() seems more suitable. This is the procedure that gets called every 'wait' deciseconds.
+//Sleeping in here prevents future fires until returned.
+/datum/controller/subsystem/proc/fire(resumed = 0)
+	flags |= SS_NO_FIRE
+	throw EXCEPTION("Subsystem [src]([type]) does not fire() but did not set the SS_NO_FIRE flag. Please add the SS_NO_FIRE flag to any subsystem that doesn't fire so it doesn't get added to the processing list and waste cpu.")
+
+/datum/controller/subsystem/Destroy()
+	dequeue()
+	can_fire = 0
+	flags |= SS_NO_FIRE
+	Master.subsystems -= src
+	return ..()
+
+//Queue it to run.
+//	(we loop thru a linked list until we get to the end or find the right point)
+//	(this lets us sort our run order correctly without having to re-sort the entire already sorted list)
+/datum/controller/subsystem/proc/enqueue()
+	var/SS_priority = priority
+	var/SS_flags = flags
+	var/datum/controller/subsystem/queue_node
+	var/queue_node_priority
+	var/queue_node_flags
+
+	for (queue_node = Master.queue_head; queue_node; queue_node = queue_node.queue_next)
+		queue_node_priority = queue_node.queued_priority
+		queue_node_flags = queue_node.flags
+
+		if (queue_node_flags & SS_TICKER)
+			if (!(SS_flags & SS_TICKER))
+				continue
+			if (queue_node_priority < SS_priority)
+				break
+
+		else if (queue_node_flags & SS_BACKGROUND)
+			if (!(SS_flags & SS_BACKGROUND))
+				break
+			if (queue_node_priority < SS_priority)
+				break
+
+		else
+			if (SS_flags & SS_BACKGROUND)
+				continue
+			if (SS_flags & SS_TICKER)
+				break
+			if (queue_node_priority < SS_priority)
+				break
+
+	queued_time = world.time
+	queued_priority = SS_priority
+	state = SS_QUEUED
+	if (SS_flags & SS_BACKGROUND) //update our running total
+		Master.queue_priority_count_bg += SS_priority
+	else
+		Master.queue_priority_count += SS_priority
+
+	queue_next = queue_node
+	if (!queue_node)//we stopped at the end, add to tail
+		queue_prev = Master.queue_tail
+		if (Master.queue_tail)
+			Master.queue_tail.queue_next = src
+		else //empty queue, we also need to set the head
+			Master.queue_head = src
+		Master.queue_tail = src
+
+	else if (queue_node == Master.queue_head)//insert at start of list
+		Master.queue_head.queue_prev = src
+		Master.queue_head = src
+		queue_prev = null
+	else
+		queue_node.queue_prev.queue_next = src
+		queue_prev = queue_node.queue_prev
+		queue_node.queue_prev = src
+
+
+/datum/controller/subsystem/proc/dequeue()
+	if (queue_next)
+		queue_next.queue_prev = queue_prev
+	if (queue_prev)
+		queue_prev.queue_next = queue_next
+	if (src == Master.queue_tail)
+		Master.queue_tail = queue_prev
+	if (src == Master.queue_head)
+		Master.queue_head = queue_next
+	queued_time = 0
+	if (state == SS_QUEUED)
+		state = SS_IDLE
+
+
+/datum/controller/subsystem/proc/pause()
+	. = 1
+	switch(state)
+		if(SS_RUNNING)
+			state = SS_PAUSED
+		if(SS_SLEEPING)
+			state = SS_PAUSING
+
+
+//used to initialize the subsystem AFTER the map has loaded
+/datum/controller/subsystem/Initialize(start_timeofday)
+	initialized = TRUE
+	var/time = (REALTIMEOFDAY - start_timeofday) / 10
+	var/msg = "Initialized [name] subsystem within [time] second[time == 1 ? "" : "s"]!"
+	to_chat(world, "<span class='boldannounce'>[msg]</span>")
+	log_to_dd(msg)
+	return time
+
+//hook for printing stats to the "MC" statuspanel for admins to see performance and related stats etc.
+/datum/controller/subsystem/stat_entry(msg)
+	if(!statclick)
+		statclick = new/obj/effect/statclick/debug(src, "Initializing...")
+
+	if(can_fire && !(SS_NO_FIRE & flags))
+		msg = "[round(cost,1)]ms|[round(tick_usage,1)]%([round(tick_overrun,1)]%)|[round(ticks,0.1)]\t[msg]"
+	else
+		msg = "OFFLINE\t[msg]"
+
+	var/title = name
+	if (can_fire)
+		title = "\[[state_letter()]][title]"
+
+	stat(title, statclick.update(msg))
+
+/datum/controller/subsystem/proc/state_letter()
+	switch (state)
+		if (SS_RUNNING)
+			. = "R"
+		if (SS_QUEUED)
+			. = "Q"
+		if (SS_PAUSED, SS_PAUSING)
+			. = "P"
+		if (SS_SLEEPING)
+			. = "S"
+		if (SS_IDLE)
+			. = "  "
+
+//could be used to postpone a costly subsystem for (default one) var/cycles, cycles
+//for instance, during cpu intensive operations like explosions
+/datum/controller/subsystem/proc/postpone(cycles = 1)
+	if(next_fire - world.time < wait)
+		next_fire += (wait*cycles)
+
+//usually called via datum/controller/subsystem/New() when replacing a subsystem (i.e. due to a recurring crash)
+//should attempt to salvage what it can from the old instance of subsystem
+/datum/controller/subsystem/Recover()
+
+/datum/controller/subsystem/vv_edit_var(var_name, var_value)
+	switch (var_name)
+		if ("can_fire")
+			//this is so the subsystem doesn't rapid fire to make up missed ticks causing more lag
+			if (var_value)
+				next_fire = world.time + wait
+		if ("queued_priority") //editing this breaks things.
+			return 0
+	. = ..()

code/controllers/verbs.dm

@@ -17,7 +17,10 @@
 	message_admins("Admin [key_name_admin(usr)] has restarted the [controller] controller.")
 	return
 
-/client/proc/debug_controller(controller in list("Master","failsafe","Ticker","Air","Jobs","Sun","Radio","Configuration","pAI", "Cameras","Garbage", "Transfer Controller","Event","Alarm","Scheduler","Nano","Vote","Diseases","Fires","Mob","NPC AI","Shuttle","Timer","Weather","Space","Mob Hunt Server"))
+/client/proc/debug_controller(controller in list("Master",
+	"failsafe","Scheduler","StonedMaster","Ticker","Air","Jobs","Sun","Radio","Configuration","pAI",
+	"Cameras","Garbage", "Transfer Controller","Event","Alarm","Nano","Vote","Fires",
+	"Mob","NPC AI","Shuttle","Timer","Weather","Space","Mob Hunt Server"))
 	set category = "Debug"
 	set name = "Debug Controller"
 	set desc = "Debug the various periodic loop controllers for the game (be careful!)"
@@ -28,8 +31,14 @@
 			debug_variables(master_controller)
 			feedback_add_details("admin_verb","DMC")
 		if("failsafe")
-			debug_variables(failsafe)
+			debug_variables(Failsafe)
 			feedback_add_details("admin_verb", "dfailsafe")
+		if("Scheduler")
+			debug_variables(processScheduler)
+			feedback_add_details("admin_verb","DprocessScheduler")
+		if("StonedMaster")
+			debug_variables(Master)
+			feedback_add_details("admin_verb","Dsmc")
 		if("Ticker")
 			debug_variables(ticker)
 			feedback_add_details("admin_verb","DTicker")
@@ -63,9 +72,6 @@
 		if("Garbage")
 			debug_variables(garbageCollector)
 			feedback_add_details("admin_verb","DGarbage")
-		if("Scheduler")
-			debug_variables(processScheduler)
-			feedback_add_details("admin_verb","DprocessScheduler")
 		if("Nano")
 			debug_variables(nanomanager)
 			feedback_add_details("admin_verb","DNano")

code/datums/statclick.dm

@@ -5,8 +5,8 @@
 	var/target
 
 /obj/effect/statclick/New(ntarget, text)
-	name = text
 	target = ntarget
+	name = text
 
 /obj/effect/statclick/proc/update(text)
 	name = text
@@ -15,25 +15,22 @@
 /obj/effect/statclick/debug
 	var/class
 
-/obj/effect/statclick/debug/New(ntarget)
-	name = "Initializing..."
-	target = ntarget
-	if(istype(target, /datum/controller/process))
-		class = "process"
-	else if(istype(target, /datum/controller/processScheduler))
-		class = "scheduler"
-	else if(istype(target, /datum/controller))
-		class = "controller"
-	else if(istype(target, /datum))
-		class = "datum"
-	else
-		class = "unknown"
-
-// This bit is called when clicked in the stat panel
 /obj/effect/statclick/debug/Click()
-	if(!is_admin(usr))
+	if(!is_admin(usr) || !target)
 		return
+	if(!class)
+		if(istype(target, /datum/controller/process))
+			class = "process"
+		else if(istype(target, /datum/controller/processScheduler))
+			class = "scheduler"
+		if(istype(target, /datum/controller/subsystem))
+			class = "subsystem"
+		else if(istype(target, /datum/controller))
+			class = "controller"
+		else if(istype(target, /datum))
+			class = "datum"
+		else
+			class = "unknown"
 
 	usr.client.debug_variables(target)
-
-	message_admins("Admin [key_name_admin(usr)] is debugging the [target] [class].")
+	message_admins("Admin [key_name_admin(usr)] is debugging the [target] [class].")

code/game/gamemodes/gameticker.dm

@@ -55,6 +55,7 @@ var/round_start_time = 0
 
 			if(pregame_timeleft <= 0)
 				current_state = GAME_STATE_SETTING_UP
+				Master.SetRunLevel(RUNLEVEL_SETUP)
 	while(!setup())
 
 /datum/controller/gameticker/proc/votetimer()
@@ -77,6 +78,7 @@ var/round_start_time = 0
 		runnable_modes = config.get_runnable_modes()
 		if(runnable_modes.len==0)
 			current_state = GAME_STATE_PREGAME
+			Master.SetRunLevel(RUNLEVEL_LOBBY)
 			to_chat(world, "<B>Unable to choose playable game mode.</B> Reverting to pre-game lobby.")
 			return 0
 		if(secret_force_mode != "secret")
@@ -96,6 +98,7 @@ var/round_start_time = 0
 		mode = null
 		current_state = GAME_STATE_PREGAME
 		job_master.ResetOccupations()
+		Master.SetRunLevel(RUNLEVEL_LOBBY)
 		return 0
 
 	//Configure mode and assign player to special mode stuff
@@ -108,6 +111,7 @@ var/round_start_time = 0
 		current_state = GAME_STATE_PREGAME
 		to_chat(world, "<B>Error setting up [master_mode].</B> Reverting to pre-game lobby.")
 		job_master.ResetOccupations()
+		Master.SetRunLevel(RUNLEVEL_LOBBY)
 		return 0
 
 	if(hide_mode)
@@ -125,6 +129,7 @@ var/round_start_time = 0
 	equip_characters()
 	data_core.manifest()
 	current_state = GAME_STATE_PLAYING
+	Master.SetRunLevel(RUNLEVEL_GAME)
 
 	callHook("roundstart")
 
@@ -385,6 +390,7 @@ var/round_start_time = 0
 
 	if((!mode.explosion_in_progress && game_finished) || force_ending)
 		current_state = GAME_STATE_FINISHED
+		Master.SetRunLevel(RUNLEVEL_POSTGAME)
 		auto_toggle_ooc(1) // Turn it on
 		spawn
 			declare_completion()

code/modules/mob/mob.dm

@@ -946,6 +946,25 @@ var/list/slot_equipment_priority = list( \
 
 			if(processScheduler)
 				processScheduler.statProcesses()
+		if(statpanel("MC")) //looking at that panel
+			var/turf/T = get_turf(client.eye)
+			stat("Location:", COORD(T))
+			stat("CPU:", "[world.cpu]")
+			stat("Instances:", "[num2text(world.contents.len, 10)]")
+			GLOB.stat_entry()
+			stat(null)
+			if(Master)
+				Master.stat_entry()
+			else
+				stat("Master Controller:", "ERROR")
+			if(Failsafe)
+				Failsafe.stat_entry()
+			else
+				stat("Failsafe Controller:", "ERROR")
+			if(Master)
+				stat(null)
+				for(var/datum/controller/subsystem/SS in Master.subsystems)
+					SS.stat_entry()
 
 	statpanel("Status") // Switch to the Status panel again, for the sake of the lazy Stat procs
 

code/world.dm

@@ -4,9 +4,6 @@ var/global/datum/global_init/init = new ()
 	Pre-map initialization stuff should go here.
 */
 /datum/global_init/New()
-
-	makeDatumRefLists()
-	load_configuration()
 	setLog()
 	del(src)
 
@@ -37,6 +34,7 @@ var/global/list/map_transition_config = MAP_TRANSITION_CONFIG
 
 	timezoneOffset = text2num(time2text(0,"hh")) * 36000
 
+
 	callHook("startup")
 
 	src.update_status()
@@ -48,6 +46,8 @@ var/global/list/map_transition_config = MAP_TRANSITION_CONFIG
 
 	space_manager.initialize() //Before the MC starts up
 
+	Master.Initialize(10, FALSE)
+
 	processScheduler = new
 	master_controller = new /datum/controller/game_controller()
 	spawn(1)

paradise.dme

@@ -15,6 +15,7 @@
 #include "code\_compile_options.dm"
 #include "code\hub.dm"
 #include "code\world.dm"
+#include "code\__DEFINES\_globals.dm"
 #include "code\__DEFINES\_readme.dm"
 #include "code\__DEFINES\admin.dm"
 #include "code\__DEFINES\atmospherics.dm"
@@ -38,6 +39,7 @@
 #include "code\__DEFINES\lighting.dm"
 #include "code\__DEFINES\machines.dm"
 #include "code\__DEFINES\math.dm"
+#include "code\__DEFINES\MC.dm"
 #include "code\__DEFINES\misc.dm"
 #include "code\__DEFINES\mob.dm"
 #include "code\__DEFINES\pda.dm"
@@ -52,12 +54,14 @@
 #include "code\__DEFINES\sound.dm"
 #include "code\__DEFINES\stat.dm"
 #include "code\__DEFINES\status_effects.dm"
+#include "code\__DEFINES\subsystems.dm"
 #include "code\__DEFINES\tick.dm"
 #include "code\__DEFINES\typeids.dm"
 #include "code\__DEFINES\vv.dm"
 #include "code\__DEFINES\zlevel.dm"
 #include "code\__HELPERS\_string_lists.dm"
 #include "code\__HELPERS\AnimationLibrary.dm"
+#include "code\__HELPERS\cmp.dm"
 #include "code\__HELPERS\constants.dm"
 #include "code\__HELPERS\experimental.dm"
 #include "code\__HELPERS\files.dm"
@@ -78,6 +82,10 @@
 #include "code\__HELPERS\type2type.dm"
 #include "code\__HELPERS\unique_ids.dm"
 #include "code\__HELPERS\unsorted.dm"
+#include "code\__HELPERS\sorts\__main.dm"
+#include "code\__HELPERS\sorts\InsertSort.dm"
+#include "code\__HELPERS\sorts\MergeSort.dm"
+#include "code\__HELPERS\sorts\TimSort.dm"
 #include "code\_DATASTRUCTURES\heap.dm"
 #include "code\_DATASTRUCTURES\linked_lists.dm"
 #include "code\_DATASTRUCTURES\priority_queue.dm"
@@ -169,10 +177,14 @@
 #include "code\ATMOSPHERICS\pipes\simple\pipe_simple_visible.dm"
 #include "code\controllers\communications.dm"
 #include "code\controllers\configuration.dm"
+#include "code\controllers\controller.dm"
 #include "code\controllers\failsafe.dm"
+#include "code\controllers\globals.dm"
 #include "code\controllers\hooks-defs.dm"
 #include "code\controllers\hooks.dm"
+#include "code\controllers\master.dm"
 #include "code\controllers\master_controller.dm"
+#include "code\controllers\subsystem.dm"
 #include "code\controllers\verbs.dm"
 #include "code\controllers\voting.dm"
 #include "code\controllers\Processes\air.dm"