Uploading all files.

code/controllers/subsystem/acid.dm

@@ -0,0 +1,36 @@
+SUBSYSTEM_DEF(acid)
+	name = "Acid"
+	priority = FIRE_PRIORITY_ACID
+	flags = SS_NO_INIT|SS_BACKGROUND
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+	var/list/processing = list()
+
+/datum/controller/subsystem/acid/stat_entry()
+	..("P:[processing.len]")
+
+
+/datum/controller/subsystem/acid/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = processing.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while (currentrun.len)
+		var/obj/O = currentrun[currentrun.len]
+		currentrun.len--
+		if (!O || QDELETED(O))
+			processing -= O
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		if(O.acid_level && O.acid_processing())
+		else
+			O.cut_overlay(GLOB.acid_overlay, TRUE)
+			processing -= O
+
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/air.dm

@@ -0,0 +1,411 @@
+#define SSAIR_PIPENETS 1
+#define SSAIR_ATMOSMACHINERY 2
+#define SSAIR_REACTQUEUE 3
+#define SSAIR_EXCITEDGROUPS 4
+#define SSAIR_HIGHPRESSURE 5
+#define SSAIR_HOTSPOTS 6
+#define SSAIR_SUPERCONDUCTIVITY 7
+
+SUBSYSTEM_DEF(air)
+	name = "Atmospherics"
+	init_order = INIT_ORDER_AIR
+	priority = FIRE_PRIORITY_AIR
+	wait = 5
+	flags = SS_BACKGROUND
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/cost_turf_reactions = 0
+	var/cost_groups = 0
+	var/cost_highpressure = 0
+	var/cost_hotspots = 0
+	var/cost_superconductivity = 0
+	var/cost_pipenets = 0
+	var/cost_atmos_machinery = 0
+
+	var/list/excited_groups = list()
+	var/list/active_turfs = list()
+	var/list/turf_react_queue = list()
+	var/list/hotspots = list()
+	var/list/networks = list()
+	var/list/obj/machinery/atmos_machinery = list()
+	var/list/pipe_init_dirs_cache = list()
+
+	//atmos singletons
+	var/list/gas_reactions = list()
+
+	//Special functions lists
+	var/list/turf/active_super_conductivity = list()
+	var/list/turf/open/high_pressure_delta = list()
+
+
+	var/list/currentrun = list()
+	var/currentpart = SSAIR_PIPENETS
+
+	var/map_loading = TRUE
+	var/list/queued_for_activation
+
+/datum/controller/subsystem/air/stat_entry(msg)
+	msg += "C:{"
+	msg += "RQ:[round(cost_turf_reactions,1)]|"
+	msg += "EG:[round(cost_groups,1)]|"
+	msg += "HP:[round(cost_highpressure,1)]|"
+	msg += "HS:[round(cost_hotspots,1)]|"
+	msg += "SC:[round(cost_superconductivity,1)]|"
+	msg += "PN:[round(cost_pipenets,1)]|"
+	msg += "AM:[round(cost_atmos_machinery,1)]"
+	msg += "} "
+	msg += "AT:[active_turfs.len]|"
+	msg += "RQ:[turf_react_queue.len]|"
+	msg += "EG:[excited_groups.len]|"
+	msg += "HS:[hotspots.len]|"
+	msg += "PN:[networks.len]|"
+	msg += "HP:[high_pressure_delta.len]|"
+	msg += "AS:[active_super_conductivity.len]|"
+	msg += "AT/MS:[round((cost ? active_turfs.len/cost : 0),0.1)]"
+	..(msg)
+
+
+/datum/controller/subsystem/air/Initialize(timeofday)
+	map_loading = FALSE
+	setup_allturfs()
+	setup_atmos_machinery()
+	setup_pipenets()
+	gas_reactions = init_gas_reactions()
+	return ..()
+
+
+/datum/controller/subsystem/air/fire(resumed = 0)
+	var/timer = TICK_USAGE_REAL
+
+	if(currentpart == SSAIR_PIPENETS || !resumed)
+		process_pipenets(resumed)
+		cost_pipenets = MC_AVERAGE(cost_pipenets, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_ATMOSMACHINERY
+
+	if(currentpart == SSAIR_ATMOSMACHINERY)
+		timer = TICK_USAGE_REAL
+		process_atmos_machinery(resumed)
+		cost_atmos_machinery = MC_AVERAGE(cost_atmos_machinery, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_REACTQUEUE
+
+	if(currentpart == SSAIR_REACTQUEUE)
+		timer = TICK_USAGE_REAL
+		process_react_queue(resumed)
+		cost_turf_reactions = MC_AVERAGE(cost_turf_reactions, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_EXCITEDGROUPS
+
+	if(currentpart == SSAIR_EXCITEDGROUPS)
+		timer = TICK_USAGE_REAL
+		process_excited_groups(resumed)
+		cost_groups = MC_AVERAGE(cost_groups, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_HIGHPRESSURE
+
+	if(currentpart == SSAIR_HIGHPRESSURE)
+		timer = TICK_USAGE_REAL
+		process_high_pressure_delta(resumed)
+		cost_highpressure = MC_AVERAGE(cost_highpressure, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_HOTSPOTS
+
+	if(currentpart == SSAIR_HOTSPOTS)
+		timer = TICK_USAGE_REAL
+		process_hotspots(resumed)
+		cost_hotspots = MC_AVERAGE(cost_hotspots, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+		currentpart = SSAIR_SUPERCONDUCTIVITY
+
+	if(currentpart == SSAIR_SUPERCONDUCTIVITY)
+		timer = TICK_USAGE_REAL
+		process_super_conductivity(resumed)
+		cost_superconductivity = MC_AVERAGE(cost_superconductivity, TICK_DELTA_TO_MS(TICK_USAGE_REAL - timer))
+		if(state != SS_RUNNING)
+			return
+		resumed = 0
+	currentpart = SSAIR_PIPENETS
+
+
+
+/datum/controller/subsystem/air/proc/process_pipenets(resumed = 0)
+	if (!resumed)
+		src.currentrun = networks.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/datum/thing = currentrun[currentrun.len]
+		currentrun.len--
+		if(thing)
+			thing.process()
+		else
+			networks.Remove(thing)
+		if(MC_TICK_CHECK)
+			return
+
+
+/datum/controller/subsystem/air/proc/process_atmos_machinery(resumed = 0)
+	var/seconds = wait * 0.1
+	if (!resumed)
+		src.currentrun = atmos_machinery.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/obj/machinery/M = currentrun[currentrun.len]
+		currentrun.len--
+		if(!M || (M.process_atmos(seconds) == PROCESS_KILL))
+			atmos_machinery.Remove(M)
+		if(MC_TICK_CHECK)
+			return
+
+
+/datum/controller/subsystem/air/proc/process_react_queue(resumed = 0)
+	if(!resumed)
+		src.currentrun = turf_react_queue.Copy()
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/turf/open/T = currentrun[currentrun.len]
+		currentrun.len--
+		if(T)
+			T.process_cell_reaction()
+		if(MC_TICK_CHECK)
+			return
+
+
+/datum/controller/subsystem/air/proc/process_super_conductivity(resumed = 0)
+	if (!resumed)
+		src.currentrun = active_super_conductivity.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/turf/T = currentrun[currentrun.len]
+		currentrun.len--
+		T.super_conduct()
+		if(MC_TICK_CHECK)
+			return
+
+/datum/controller/subsystem/air/proc/process_hotspots(resumed = 0)
+	if (!resumed)
+		src.currentrun = hotspots.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/obj/effect/hotspot/H = currentrun[currentrun.len]
+		currentrun.len--
+		if (H)
+			H.process()
+		else
+			hotspots -= H
+		if(MC_TICK_CHECK)
+			return
+
+
+/datum/controller/subsystem/air/proc/process_high_pressure_delta(resumed = 0)
+	while (high_pressure_delta.len)
+		var/turf/open/T = high_pressure_delta[high_pressure_delta.len]
+		high_pressure_delta.len--
+		T.high_pressure_movements()
+		T.pressure_difference = 0
+		if(MC_TICK_CHECK)
+			return
+
+/datum/controller/subsystem/air/proc/process_excited_groups(resumed = 0)
+	if (!resumed)
+		src.currentrun = excited_groups.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/datum/excited_group/EG = currentrun[currentrun.len]
+		currentrun.len--
+		EG.breakdown_cooldown++
+		EG.dismantle_cooldown++
+		if(EG.breakdown_cooldown >= EXCITED_GROUP_BREAKDOWN_CYCLES)
+			EG.self_breakdown()
+		else if(EG.dismantle_cooldown >= EXCITED_GROUP_DISMANTLE_CYCLES)
+			EG.dismantle()
+		if (MC_TICK_CHECK)
+			return
+
+
+/datum/controller/subsystem/air/proc/remove_from_active(turf/open/T)
+	active_turfs -= T
+	SSair_turfs.currentrun -= T
+	#ifdef VISUALIZE_ACTIVE_TURFS
+	T.remove_atom_colour(TEMPORARY_COLOUR_PRIORITY, "#00ff00")
+	#endif
+	if(istype(T))
+		T.excited = 0
+		if(T.excited_group)
+			T.excited_group.garbage_collect()
+	remove_from_react_queue(T)
+
+/datum/controller/subsystem/air/proc/add_to_active(turf/open/T, blockchanges = 1)
+	if(istype(T) && T.air)
+		#ifdef VISUALIZE_ACTIVE_TURFS
+		T.add_atom_colour("#00ff00", TEMPORARY_COLOUR_PRIORITY)
+		#endif
+		T.excited = 1
+		active_turfs |= T
+		SSair_turfs.currentrun |= T
+		if(blockchanges && T.excited_group)
+			T.excited_group.garbage_collect()
+		add_to_react_queue(T)
+	else if(T.flags_1 & INITIALIZED_1)
+		for(var/turf/S in T.atmos_adjacent_turfs)
+			add_to_active(S)
+	else if(map_loading)
+		if(queued_for_activation)
+			queued_for_activation[T] = T
+		return
+	else
+		T.requires_activation = TRUE
+
+/datum/controller/subsystem/air/proc/add_to_react_queue(turf/open/T)
+	if(istype(T) && T.air)
+		turf_react_queue |= T
+		if(currentpart == SSAIR_REACTQUEUE)
+			currentrun |= T
+	return
+
+/datum/controller/subsystem/air/proc/remove_from_react_queue(turf/open/T)
+	turf_react_queue -= T
+	if(currentpart == SSAIR_REACTQUEUE)
+		currentrun -= T
+
+/datum/controller/subsystem/air/StartLoadingMap()
+	LAZYINITLIST(queued_for_activation)
+	map_loading = TRUE
+
+/datum/controller/subsystem/air/StopLoadingMap()
+	map_loading = FALSE
+	for(var/T in queued_for_activation)
+		add_to_active(T)
+	queued_for_activation.Cut()
+
+/datum/controller/subsystem/air/proc/setup_allturfs()
+	var/list/turfs_to_init = block(locate(1, 1, 1), locate(world.maxx, world.maxy, world.maxz))
+	var/list/active_turfs = src.active_turfs
+	var/times_fired = ++src.times_fired
+
+	// Clear active turfs - faster than removing every single turf in the world
+	// one-by-one, and Initalize_Atmos only ever adds `src` back in.
+	active_turfs.Cut()
+
+	for(var/thing in turfs_to_init)
+		var/turf/T = thing
+		if (T.blocks_air)
+			continue
+		T.Initalize_Atmos(times_fired)
+		CHECK_TICK
+
+	if(active_turfs.len)
+		var/starting_ats = active_turfs.len
+		sleep(world.tick_lag)
+		var/timer = world.timeofday
+		warning("There are [starting_ats] active turfs at roundstart, this is a mapping error caused by a difference of the air between the adjacent turfs. You can see its coordinates using \"Mapping -> Show roundstart AT list\" verb (debug verbs required)")
+		for(var/turf/T in active_turfs)
+			GLOB.active_turfs_startlist += T
+
+		//now lets clear out these active turfs
+		var/list/turfs_to_check = active_turfs.Copy()
+		do
+			var/list/new_turfs_to_check = list()
+			for(var/turf/open/T in turfs_to_check)
+				new_turfs_to_check += T.resolve_active_graph()
+			CHECK_TICK
+
+			active_turfs += new_turfs_to_check
+			turfs_to_check = new_turfs_to_check
+
+		while (turfs_to_check.len)
+		var/ending_ats = active_turfs.len
+		for(var/thing in excited_groups)
+			var/datum/excited_group/EG = thing
+			EG.self_breakdown(space_is_all_consuming = 1)
+			EG.dismantle()
+			CHECK_TICK
+
+		var/msg = "HEY! LISTEN! [DisplayTimeText(world.timeofday - timer)] were wasted processing [starting_ats] turf(s) (connected to [ending_ats] other turfs) with atmos differences at round start."
+		to_chat(world, "<span class='boldannounce'>[msg]</span>")
+		warning(msg)
+
+/turf/open/proc/resolve_active_graph()
+	. = list()
+	var/datum/excited_group/EG = excited_group
+	if (blocks_air || !air)
+		return
+	if (!EG)
+		EG = new
+		EG.add_turf(src)
+
+	for (var/turf/open/ET in atmos_adjacent_turfs)
+		if ( ET.blocks_air || !ET.air)
+			continue
+
+		var/ET_EG = ET.excited_group
+		if (ET_EG)
+			if (ET_EG != EG)
+				EG.merge_groups(ET_EG)
+				EG = excited_group //merge_groups() may decide to replace our current EG
+		else
+			EG.add_turf(ET)
+		if (!ET.excited)
+			ET.excited = 1
+			. += ET
+/turf/open/space/resolve_active_graph()
+	return list()
+
+/datum/controller/subsystem/air/proc/setup_atmos_machinery()
+	for (var/obj/machinery/atmospherics/AM in atmos_machinery)
+		AM.atmosinit()
+		CHECK_TICK
+
+//this can't be done with setup_atmos_machinery() because
+//	all atmos machinery has to initalize before the first
+//	pipenet can be built.
+/datum/controller/subsystem/air/proc/setup_pipenets()
+	for (var/obj/machinery/atmospherics/AM in atmos_machinery)
+		AM.build_network()
+		CHECK_TICK
+
+/datum/controller/subsystem/air/proc/setup_template_machinery(list/atmos_machines)
+	for(var/A in atmos_machines)
+		var/obj/machinery/atmospherics/AM = A
+		AM.atmosinit()
+		CHECK_TICK
+
+	for(var/A in atmos_machines)
+		var/obj/machinery/atmospherics/AM = A
+		AM.build_network()
+		CHECK_TICK
+
+/datum/controller/subsystem/air/proc/get_init_dirs(type, dir)
+	if(!pipe_init_dirs_cache[type])
+		pipe_init_dirs_cache[type] = list()
+
+	if(!pipe_init_dirs_cache[type]["[dir]"])
+		var/obj/machinery/atmospherics/temp = new type(null, FALSE, dir)
+		pipe_init_dirs_cache[type]["[dir]"] = temp.GetInitDirections()
+		qdel(temp)
+
+	return pipe_init_dirs_cache[type]["[dir]"]
+
+#undef SSAIR_PIPENETS
+#undef SSAIR_ATMOSMACHINERY
+#undef SSAIR_EXCITEDGROUPS
+#undef SSAIR_HIGHPRESSURE
+#undef SSAIR_HOTSPOTS
+#undef SSAIR_SUPERCONDUCTIVITY

code/controllers/subsystem/air_turfs.dm

@@ -0,0 +1,27 @@
+//WHAT IF WE TAKE THE ACTIVE TURF PROCESSING AND PUSH IT SOMEWHERE ELSE!!!
+
+SUBSYSTEM_DEF(air_turfs)
+	name = "Atmospherics - Turfs"
+	init_order = INIT_ORDER_AIR_TURFS
+	priority = FIRE_PRIORITY_AIR_TURFS
+	wait = 2
+	flags = SS_BACKGROUND
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+	var/list/currentrun = list()
+
+/datum/controller/subsystem/air_turfs/fire(resumed = 0)
+	var/fire_count = times_fired
+	//cache for sanic speed
+	if (!resumed)
+		src.currentrun = SSair.active_turfs.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	while(currentrun.len)
+		var/turf/open/T = currentrun[currentrun.len]
+		currentrun.len--
+		if (T)
+			T.process_cell(fire_count)
+		if (MC_TICK_CHECK)
+			return
+	resumed = 0
+	return

code/controllers/subsystem/assets.dm

@@ -0,0 +1,18 @@
+SUBSYSTEM_DEF(assets)
+	name = "Assets"
+	init_order = INIT_ORDER_ASSETS
+	flags = SS_NO_FIRE
+	var/list/cache = list()
+	var/list/preload = list()
+
+/datum/controller/subsystem/assets/Initialize(timeofday)
+	for(var/type in typesof(/datum/asset))
+		var/datum/asset/A = type
+		if (type != initial(A._abstract))
+			get_asset_datum(type)
+
+	preload = cache.Copy() //don't preload assets generated during the round
+
+	for(var/client/C in GLOB.clients)
+		addtimer(CALLBACK(GLOBAL_PROC, .proc/getFilesSlow, C, preload, FALSE), 10)
+	..()

code/controllers/subsystem/atoms.dm

@@ -0,0 +1,151 @@
+#define BAD_INIT_QDEL_BEFORE 1
+#define BAD_INIT_DIDNT_INIT 2
+#define BAD_INIT_SLEPT 4
+#define BAD_INIT_NO_HINT 8
+
+SUBSYSTEM_DEF(atoms)
+	name = "Atoms"
+	init_order = INIT_ORDER_ATOMS
+	flags = SS_NO_FIRE
+
+	var/old_initialized
+
+	var/list/late_loaders
+
+	var/list/BadInitializeCalls = list()
+
+/datum/controller/subsystem/atoms/Initialize(timeofday)
+	GLOB.fire_overlay.appearance_flags = RESET_COLOR
+	setupGenetics() //to set the mutations' place in structural enzymes, so monkey.initialize() knows where to put the monkey mutation.
+	initialized = INITIALIZATION_INNEW_MAPLOAD
+	InitializeAtoms()
+	return ..()
+
+/datum/controller/subsystem/atoms/proc/InitializeAtoms(list/atoms)
+	if(initialized == INITIALIZATION_INSSATOMS)
+		return
+
+	initialized = INITIALIZATION_INNEW_MAPLOAD
+
+	LAZYINITLIST(late_loaders)
+
+	var/count
+	var/list/mapload_arg = list(TRUE)
+	if(atoms)
+		count = atoms.len
+		for(var/I in atoms)
+			var/atom/A = I
+			if(!(A.flags_1 & INITIALIZED_1))
+				InitAtom(I, mapload_arg)
+				CHECK_TICK
+	else
+		count = 0
+		for(var/atom/A in world)
+			if(!(A.flags_1 & INITIALIZED_1))
+				InitAtom(A, mapload_arg)
+				++count
+				CHECK_TICK
+
+	testing("Initialized [count] atoms")
+	pass(count)
+
+	initialized = INITIALIZATION_INNEW_REGULAR
+
+	if(late_loaders.len)
+		for(var/I in late_loaders)
+			var/atom/A = I
+			A.LateInitialize()
+		testing("Late initialized [late_loaders.len] atoms")
+		late_loaders.Cut()
+
+/datum/controller/subsystem/atoms/proc/InitAtom(atom/A, list/arguments)
+	var/the_type = A.type
+	if(QDELING(A))
+		BadInitializeCalls[the_type] |= BAD_INIT_QDEL_BEFORE
+		return TRUE
+
+	var/start_tick = world.time
+
+	var/result = A.Initialize(arglist(arguments))
+
+	if(start_tick != world.time)
+		BadInitializeCalls[the_type] |= BAD_INIT_SLEPT
+
+	var/qdeleted = FALSE
+
+	if(result != INITIALIZE_HINT_NORMAL)
+		switch(result)
+			if(INITIALIZE_HINT_LATELOAD)
+				if(arguments[1])	//mapload
+					late_loaders += A
+				else
+					A.LateInitialize()
+			if(INITIALIZE_HINT_QDEL)
+				qdel(A)
+				qdeleted = TRUE
+			else
+				BadInitializeCalls[the_type] |= BAD_INIT_NO_HINT
+
+	if(!A)	//possible harddel
+		qdeleted = TRUE
+	else if(!(A.flags_1 & INITIALIZED_1))
+		BadInitializeCalls[the_type] |= BAD_INIT_DIDNT_INIT
+
+	return qdeleted || QDELING(A)
+
+/datum/controller/subsystem/atoms/proc/map_loader_begin()
+	old_initialized = initialized
+	initialized = INITIALIZATION_INSSATOMS
+
+/datum/controller/subsystem/atoms/proc/map_loader_stop()
+	initialized = old_initialized
+
+/datum/controller/subsystem/atoms/Recover()
+	initialized = SSatoms.initialized
+	if(initialized == INITIALIZATION_INNEW_MAPLOAD)
+		InitializeAtoms()
+	old_initialized = SSatoms.old_initialized
+	BadInitializeCalls = SSatoms.BadInitializeCalls
+
+/datum/controller/subsystem/atoms/proc/setupGenetics()
+	var/list/avnums = new /list(DNA_STRUC_ENZYMES_BLOCKS)
+	for(var/i=1, i<=DNA_STRUC_ENZYMES_BLOCKS, i++)
+		avnums[i] = i
+		CHECK_TICK
+
+	for(var/A in subtypesof(/datum/mutation/human))
+		var/datum/mutation/human/B = new A()
+		if(B.dna_block == NON_SCANNABLE)
+			continue
+		B.dna_block = pick_n_take(avnums)
+		if(B.quality == POSITIVE)
+			GLOB.good_mutations |= B
+		else if(B.quality == NEGATIVE)
+			GLOB.bad_mutations |= B
+		else if(B.quality == MINOR_NEGATIVE)
+			GLOB.not_good_mutations |= B
+		CHECK_TICK
+
+/datum/controller/subsystem/atoms/proc/InitLog()
+	. = ""
+	for(var/path in BadInitializeCalls)
+		. += "Path : [path] \n"
+		var/fails = BadInitializeCalls[path]
+		if(fails & BAD_INIT_DIDNT_INIT)
+			. += "- Didn't call atom/Initialize()\n"
+		if(fails & BAD_INIT_NO_HINT)
+			. += "- Didn't return an Initialize hint\n"
+		if(fails & BAD_INIT_QDEL_BEFORE)
+			. += "- Qdel'd in New()\n"
+		if(fails & BAD_INIT_SLEPT)
+			. += "- Slept during Initialize()\n"
+
+/datum/controller/subsystem/atoms/Shutdown()
+	var/initlog = InitLog()
+	if(initlog)
+		text2file(initlog, "[GLOB.log_directory]/initialize.log")
+
+#undef BAD_INIT_QDEL_BEFORE
+#undef BAD_INIT_DIDNT_INIT
+#undef BAD_INIT_SLEPT
+#undef BAD_INIT_NO_HINT

code/controllers/subsystem/augury.dm

@@ -0,0 +1,84 @@
+SUBSYSTEM_DEF(augury)
+	name = "Augury"
+	flags = SS_NO_INIT
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/watchers = list()
+	var/list/doombringers = list()
+
+	var/list/observers_given_action = list()
+
+/datum/controller/subsystem/augury/stat_entry(msg)
+	..("W:[watchers.len]|D:[doombringers.len]")
+
+/datum/controller/subsystem/augury/proc/register_doom(atom/A, severity)
+	doombringers[A] = severity
+
+/datum/controller/subsystem/augury/proc/unregister_doom(atom/A)
+	doombringers -= A
+
+/datum/controller/subsystem/augury/fire()
+	var/biggest_doom = null
+	var/biggest_threat = null
+
+	for(var/db in doombringers)
+		var/datum/d = db
+		if(!d || QDELETED(d))
+			doombringers -= d
+			continue
+		var/threat = doombringers[d]
+		if((biggest_threat == null) || (biggest_threat < threat))
+			biggest_doom = d
+			biggest_threat = threat
+
+	if(doombringers.len)
+		for(var/i in GLOB.player_list)
+			if(isobserver(i) && (!(observers_given_action[i])))
+				var/datum/action/innate/augury/A = new
+				A.Grant(i)
+				observers_given_action[i] = TRUE
+	else
+		for(var/i in observers_given_action)
+			if(observers_given_action[i] && isobserver(i))
+				var/mob/dead/observer/O = i
+				for(var/datum/action/innate/augury/A in O.actions)
+					qdel(A)
+			observers_given_action -= i
+
+	for(var/w in watchers)
+		if(!w)
+			watchers -= w
+			continue
+		var/mob/dead/observer/O = w
+		if(biggest_doom && (!O.orbiting || O.orbiting.parent != biggest_doom))
+			O.ManualFollow(biggest_doom)
+
+/datum/action/innate/augury
+	name = "Auto Follow Debris"
+	icon_icon = 'icons/obj/meteor.dmi'
+	button_icon_state = "flaming"
+	background_icon_state = ACTION_BUTTON_DEFAULT_BACKGROUND
+
+/datum/action/innate/augury/Destroy()
+	if(owner)
+		SSaugury.watchers -= owner
+	return ..()
+
+/datum/action/innate/augury/Activate()
+	SSaugury.watchers += owner
+	to_chat(owner, "<span class='notice'>You are now auto-following debris.</span>")
+	active = TRUE
+	UpdateButtonIcon()
+
+/datum/action/innate/augury/Deactivate()
+	SSaugury.watchers -= owner
+	to_chat(owner, "<span class='notice'>You are no longer auto-following debris.</span>")
+	active = FALSE
+	UpdateButtonIcon()
+
+/datum/action/innate/augury/UpdateButtonIcon(status_only = FALSE, force)
+	..()
+	if(active)
+		button.icon_state = "template_active"
+	else
+		button.icon_state = "template"

code/controllers/subsystem/blackbox.dm

@@ -0,0 +1,335 @@
+SUBSYSTEM_DEF(blackbox)
+	name = "Blackbox"
+	wait = 6000
+	flags = SS_NO_TICK_CHECK
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+	init_order = INIT_ORDER_BLACKBOX
+
+	var/list/feedback = list()	//list of datum/feedback_variable
+	var/list/first_death = list() //the first death of this round, assoc. vars keep track of different things
+	var/triggertime = 0
+	var/sealed = FALSE	//time to stop tracking stats?
+	var/list/versions = list("antagonists" = 3,
+							"admin_secrets_fun_used" = 2,
+							"explosion" = 2,
+							"time_dilation_current" = 3,
+							"science_techweb_unlock" = 2,
+							"round_end_stats" = 2) //associative list of any feedback variables that have had their format changed since creation and their current version, remember to update this
+
+/datum/controller/subsystem/blackbox/Initialize()
+	triggertime = world.time
+	record_feedback("amount", "random_seed", Master.random_seed)
+	record_feedback("amount", "dm_version", DM_VERSION)
+	record_feedback("amount", "byond_version", world.byond_version)
+	record_feedback("amount", "byond_build", world.byond_build)
+	. = ..()
+
+//poll population
+/datum/controller/subsystem/blackbox/fire()
+	set waitfor = FALSE	//for population query
+
+	CheckPlayerCount()
+
+	if(CONFIG_GET(flag/use_exp_tracking))
+		if((triggertime < 0) || (world.time > (triggertime +3000)))	//subsystem fires once at roundstart then once every 10 minutes. a 5 min check skips the first fire. The <0 is midnight rollover check
+			update_exp(10,FALSE)
+
+/datum/controller/subsystem/blackbox/proc/CheckPlayerCount()
+	set waitfor = FALSE
+
+	if(!SSdbcore.Connect())
+		return
+	var/playercount = 0
+	for(var/mob/M in GLOB.player_list)
+		if(M.client)
+			playercount += 1
+	var/admincount = GLOB.admins.len
+	var/datum/DBQuery/query_record_playercount = SSdbcore.NewQuery("INSERT INTO [format_table_name("legacy_population")] (playercount, admincount, time, server_ip, server_port, round_id) VALUES ([playercount], [admincount], '[SQLtime()]', INET_ATON(IF('[world.internet_address]' LIKE '', '0', '[world.internet_address]')), '[world.port]', '[GLOB.round_id]')")
+	query_record_playercount.Execute()
+	qdel(query_record_playercount)
+
+/datum/controller/subsystem/blackbox/Recover()
+	feedback = SSblackbox.feedback
+	sealed = SSblackbox.sealed
+
+//no touchie
+/datum/controller/subsystem/blackbox/vv_get_var(var_name)
+	if(var_name == "feedback")
+		return debug_variable(var_name, deepCopyList(feedback), 0, src)
+	return ..()
+
+/datum/controller/subsystem/blackbox/vv_edit_var(var_name, var_value)
+	switch(var_name)
+		if("feedback")
+			return FALSE
+		if("sealed")
+			if(var_value)
+				return Seal()
+			return FALSE
+	return ..()
+
+//Recorded on subsystem shutdown
+/datum/controller/subsystem/blackbox/proc/FinalFeedback()
+	record_feedback("tally", "ahelp_stats", GLOB.ahelp_tickets.active_tickets.len, "unresolved")
+	for (var/obj/machinery/telecomms/message_server/MS in GLOB.telecomms_list)
+		if (MS.pda_msgs.len)
+			record_feedback("tally", "radio_usage", MS.pda_msgs.len, "PDA")
+		if (MS.rc_msgs.len)
+			record_feedback("tally", "radio_usage", MS.rc_msgs.len, "request console")
+
+	for(var/player_key in GLOB.player_details)
+		var/datum/player_details/PD = GLOB.player_details[player_key]
+		record_feedback("tally", "client_byond_version", 1, PD.byond_version)
+
+/datum/controller/subsystem/blackbox/Shutdown()
+	sealed = FALSE
+	FinalFeedback()
+
+	if (!SSdbcore.Connect())
+		return
+
+	var/list/sqlrowlist = list()
+
+	for (var/datum/feedback_variable/FV in feedback)
+		var/sqlversion = 1
+		if(FV.key in versions)
+			sqlversion = versions[FV.key]
+		sqlrowlist += list(list("datetime" = "Now()", "round_id" = GLOB.round_id, "key_name" =  "'[sanitizeSQL(FV.key)]'", "key_type" = "'[FV.key_type]'", "version" = "[sqlversion]", "json" = "'[sanitizeSQL(json_encode(FV.json))]'"))
+
+	if (!length(sqlrowlist))
+		return
+
+	SSdbcore.MassInsert(format_table_name("feedback"), sqlrowlist, ignore_errors = TRUE, delayed = TRUE)
+
+/datum/controller/subsystem/blackbox/proc/Seal()
+	if(sealed)
+		return FALSE
+	if(IsAdminAdvancedProcCall())
+		message_admins("[key_name_admin(usr)] sealed the blackbox!")
+	log_game("Blackbox sealed[IsAdminAdvancedProcCall() ? " by [key_name(usr)]" : ""].")
+	sealed = TRUE
+	return TRUE
+
+/datum/controller/subsystem/blackbox/proc/LogBroadcast(freq)
+	if(sealed)
+		return
+	switch(freq)
+		if(FREQ_COMMON)
+			record_feedback("tally", "radio_usage", 1, "common")
+		if(FREQ_SCIENCE)
+			record_feedback("tally", "radio_usage", 1, "science")
+		if(FREQ_COMMAND)
+			record_feedback("tally", "radio_usage", 1, "command")
+		if(FREQ_MEDICAL)
+			record_feedback("tally", "radio_usage", 1, "medical")
+		if(FREQ_ENGINEERING)
+			record_feedback("tally", "radio_usage", 1, "engineering")
+		if(FREQ_SECURITY)
+			record_feedback("tally", "radio_usage", 1, "security")
+		if(FREQ_SYNDICATE)
+			record_feedback("tally", "radio_usage", 1, "syndicate")
+		if(FREQ_SERVICE)
+			record_feedback("tally", "radio_usage", 1, "service")
+		if(FREQ_SUPPLY)
+			record_feedback("tally", "radio_usage", 1, "supply")
+		if(FREQ_CENTCOM)
+			record_feedback("tally", "radio_usage", 1, "centcom")
+		if(FREQ_AI_PRIVATE)
+			record_feedback("tally", "radio_usage", 1, "ai private")
+		if(FREQ_CTF_RED)
+			record_feedback("tally", "radio_usage", 1, "CTF red team")
+		if(FREQ_CTF_BLUE)
+			record_feedback("tally", "radio_usage", 1, "CTF blue team")
+		else
+			record_feedback("tally", "radio_usage", 1, "other")
+
+/datum/controller/subsystem/blackbox/proc/find_feedback_datum(key, key_type)
+	for(var/datum/feedback_variable/FV in feedback)
+		if(FV.key == key)
+			return FV
+
+	var/datum/feedback_variable/FV = new(key, key_type)
+	feedback += FV
+	return FV
+/*
+feedback data can be recorded in 5 formats:
+"text"
+	used for simple single-string records i.e. the current map
+	further calls to the same key will append saved data unless the overwrite argument is true or it already exists
+	when encoded calls made with overwrite will lack square brackets
+	calls: 	SSblackbox.record_feedback("text", "example", 1, "sample text")
+			SSblackbox.record_feedback("text", "example", 1, "other text")
+	json: {"data":["sample text","other text"]}
+"amount"
+	used to record simple counts of data i.e. the number of ahelps received
+	further calls to the same key will add or subtract (if increment argument is a negative) from the saved amount
+	calls:	SSblackbox.record_feedback("amount", "example", 8)
+			SSblackbox.record_feedback("amount", "example", 2)
+	json: {"data":10}
+"tally"
+	used to track the number of occurances of multiple related values i.e. how many times each type of gun is fired
+	further calls to the same key will:
+	 	add or subtract from the saved value of the data key if it already exists
+		append the key and it's value if it doesn't exist
+	calls:	SSblackbox.record_feedback("tally", "example", 1, "sample data")
+			SSblackbox.record_feedback("tally", "example", 4, "sample data")
+			SSblackbox.record_feedback("tally", "example", 2, "other data")
+	json: {"data":{"sample data":5,"other data":2}}
+"nested tally"
+	used to track the number of occurances of structured semi-relational values i.e. the results of arcade machines
+	similar to running total, but related values are nested in a multi-dimensional array built
+	the final element in the data list is used as the tracking key, all prior elements are used for nesting
+	all data list elements must be strings
+	further calls to the same key will:
+	 	add or subtract from the saved value of the data key if it already exists in the same multi-dimensional position
+		append the key and it's value if it doesn't exist
+	calls: 	SSblackbox.record_feedback("nested tally", "example", 1, list("fruit", "orange", "apricot"))
+			SSblackbox.record_feedback("nested tally", "example", 2, list("fruit", "orange", "orange"))
+			SSblackbox.record_feedback("nested tally", "example", 3, list("fruit", "orange", "apricot"))
+			SSblackbox.record_feedback("nested tally", "example", 10, list("fruit", "red", "apple"))
+			SSblackbox.record_feedback("nested tally", "example", 1, list("vegetable", "orange", "carrot"))
+	json: {"data":{"fruit":{"orange":{"apricot":4,"orange":2},"red":{"apple":10}},"vegetable":{"orange":{"carrot":1}}}}
+	tracking values associated with a number can't merge with a nesting value, trying to do so will append the list
+	call:	SSblackbox.record_feedback("nested tally", "example", 3, list("fruit", "orange"))
+	json: {"data":{"fruit":{"orange":{"apricot":4,"orange":2},"red":{"apple":10},"orange":3},"vegetable":{"orange":{"carrot":1}}}}
+"associative"
+	used to record text that's associated with a value i.e. coordinates
+	further calls to the same key will append a new list to existing data
+	calls:	SSblackbox.record_feedback("associative", "example", 1, list("text" = "example", "path" = /obj/item, "number" = 4))
+			SSblackbox.record_feedback("associative", "example", 1, list("number" = 7, "text" = "example", "other text" = "sample"))
+	json: {"data":{"1":{"text":"example","path":"/obj/item","number":"4"},"2":{"number":"7","text":"example","other text":"sample"}}}
+
+Versioning
+	If the format of a feedback variable is ever changed, i.e. how many levels of nesting are used or a new type of data is added to it, add it to the versions list
+	When feedback is being saved if a key is in the versions list the value specified there will be used, otherwise all keys are assumed to be version = 1
+	versions is an associative list, remember to use the same string in it as defined on a feedback variable, example:
+	list/versions = list("round_end_stats" = 4,
+						"admin_toggle" = 2,
+						"gun_fired" = 2)
+*/
+/datum/controller/subsystem/blackbox/proc/record_feedback(key_type, key, increment, data, overwrite)
+	if(sealed || !key_type || !istext(key) || !isnum(increment || !data))
+		return
+	var/datum/feedback_variable/FV = find_feedback_datum(key, key_type)
+	switch(key_type)
+		if("text")
+			if(!istext(data))
+				return
+			if(!islist(FV.json["data"]))
+				FV.json["data"] = list()
+			if(overwrite)
+				FV.json["data"] = data
+			else
+				FV.json["data"] |= data
+		if("amount")
+			FV.json["data"] += increment
+		if("tally")
+			if(!islist(FV.json["data"]))
+				FV.json["data"] = list()
+			FV.json["data"]["[data]"] += increment
+		if("nested tally")
+			if(!islist(data))
+				return
+			if(!islist(FV.json["data"]))
+				FV.json["data"] = list()
+			FV.json["data"] = record_feedback_recurse_list(FV.json["data"], data, increment)
+		if("associative")
+			if(!islist(data))
+				return
+			if(!islist(FV.json["data"]))
+				FV.json["data"] = list()
+			var/pos = length(FV.json["data"]) + 1
+			FV.json["data"]["[pos]"] = list() //in 512 "pos" can be replaced with "[FV.json["data"].len+1]"
+			for(var/i in data)
+				if(islist(data[i]))
+					FV.json["data"]["[pos]"]["[i]"] = data[i] //and here with "[FV.json["data"].len]"
+				else
+					FV.json["data"]["[pos]"]["[i]"] = "[data[i]]"
+		else
+			CRASH("Invalid feedback key_type: [key_type]")
+
+/datum/controller/subsystem/blackbox/proc/record_feedback_recurse_list(list/L, list/key_list, increment, depth = 1)
+	if(depth == key_list.len)
+		if(L.Find(key_list[depth]))
+			L["[key_list[depth]]"] += increment
+		else
+			var/list/LFI = list(key_list[depth] = increment)
+			L += LFI
+	else
+		if(!L.Find(key_list[depth]))
+			var/list/LGD = list(key_list[depth] = list())
+			L += LGD
+		L["[key_list[depth-1]]"] = .(L["[key_list[depth]]"], key_list, increment, ++depth)
+	return L
+
+/datum/feedback_variable
+	var/key
+	var/key_type
+	var/list/json = list()
+
+/datum/feedback_variable/New(new_key, new_key_type)
+	key = new_key
+	key_type = new_key_type
+
+/datum/controller/subsystem/blackbox/proc/ReportDeath(mob/living/L)
+	set waitfor = FALSE
+	if(sealed)
+		return
+	if(!L || !L.key || !L.mind)
+		return
+	if(!L.suiciding && !first_death.len)
+		first_death["name"] = "[(L.real_name == L.name) ? L.real_name : "[L.real_name] as [L.name]"]"
+		first_death["role"] = null
+		if(L.mind.assigned_role)
+			first_death["role"] = L.mind.assigned_role
+		first_death["area"] = "[AREACOORD(L)]"
+		first_death["damage"] = "<font color='#FF5555'>[L.getBruteLoss()]</font>/<font color='orange'>[L.getFireLoss()]</font>/<font color='lightgreen'>[L.getToxLoss()]</font>/<font color='lightblue'>[L.getOxyLoss()]</font>/<font color='pink'>[L.getCloneLoss()]</font>"
+		first_death["last_words"] = L.last_words
+	var/sqlname = L.real_name
+	var/sqlkey = L.ckey
+	var/sqljob = L.mind.assigned_role
+	var/sqlspecial = L.mind.special_role
+	var/sqlpod = get_area_name(L, TRUE)
+	var/laname = L.lastattacker
+	var/lakey = L.lastattackerckey
+	var/sqlbrute = L.getBruteLoss()
+	var/sqlfire = L.getFireLoss()
+	var/sqlbrain = L.getBrainLoss()
+	var/sqloxy = L.getOxyLoss()
+	var/sqltox = L.getToxLoss()
+	var/sqlclone = L.getCloneLoss()
+	var/sqlstamina = L.getStaminaLoss()
+	var/x_coord = L.x
+	var/y_coord = L.y
+	var/z_coord = L.z
+	var/last_words = L.last_words
+	var/suicide = L.suiciding
+	var/map = SSmapping.config.map_name
+
+	if(!SSdbcore.Connect())
+		return
+	
+	sqlname = sanitizeSQL(sqlname)
+	sqlkey = sanitizeSQL(sqlkey)
+	sqljob = sanitizeSQL(sqljob)
+	sqlspecial = sanitizeSQL(sqlspecial)
+	sqlpod = sanitizeSQL(sqlpod)
+	laname = sanitizeSQL(laname)
+	lakey = sanitizeSQL(lakey)
+	sqlbrute = sanitizeSQL(sqlbrute)
+	sqlfire = sanitizeSQL(sqlfire)
+	sqlbrain = sanitizeSQL(sqlbrain)
+	sqloxy = sanitizeSQL(sqloxy)
+	sqltox = sanitizeSQL(sqltox)
+	sqlclone = sanitizeSQL(sqlclone)
+	sqlstamina = sanitizeSQL(sqlstamina)
+	x_coord = sanitizeSQL(x_coord)
+	y_coord = sanitizeSQL(y_coord)
+	z_coord = sanitizeSQL(z_coord)
+	last_words = sanitizeSQL(last_words)
+	suicide = sanitizeSQL(suicide)
+	map = sanitizeSQL(map)
+	var/datum/DBQuery/query_report_death = SSdbcore.NewQuery("INSERT INTO [format_table_name("death")] (pod, x_coord, y_coord, z_coord, mapname, server_ip, server_port, round_id, tod, job, special, name, byondkey, laname, lakey, bruteloss, fireloss, brainloss, oxyloss, toxloss, cloneloss, staminaloss, last_words, suicide) VALUES ('[sqlpod]', '[x_coord]', '[y_coord]', '[z_coord]', '[map]', INET_ATON(IF('[world.internet_address]' LIKE '', '0', '[world.internet_address]')), '[world.port]', [GLOB.round_id], '[SQLtime()]', '[sqljob]', '[sqlspecial]', '[sqlname]', '[sqlkey]', '[laname]', '[lakey]', [sqlbrute], [sqlfire], [sqlbrain], [sqloxy], [sqltox], [sqlclone], [sqlstamina], '[last_words]', [suicide])")
+	if(query_report_death)
+		query_report_death.Execute(async = TRUE)
+		qdel(query_report_death)

code/controllers/subsystem/communications.dm

@@ -0,0 +1,46 @@
+#define COMMUNICATION_COOLDOWN 300
+#define COMMUNICATION_COOLDOWN_AI 300
+
+SUBSYSTEM_DEF(communications)
+	name = "Communications"
+	flags = SS_NO_INIT | SS_NO_FIRE
+
+	var/silicon_message_cooldown
+	var/nonsilicon_message_cooldown
+
+/datum/controller/subsystem/communications/proc/can_announce(mob/living/user, is_silicon)
+	if(is_silicon && silicon_message_cooldown > world.time)
+		. = FALSE
+	else if(!is_silicon && nonsilicon_message_cooldown > world.time)
+		. = FALSE
+	else
+		. = TRUE
+
+/datum/controller/subsystem/communications/proc/make_announcement(mob/living/user, is_silicon, input)
+	if(!can_announce(user, is_silicon))
+		return FALSE
+	if(is_silicon)
+		minor_announce(html_decode(input),"[user.name] Announces:")
+		silicon_message_cooldown = world.time + COMMUNICATION_COOLDOWN_AI
+	else
+		priority_announce(html_decode(user.treat_message(input)), null, 'sound/misc/announce.ogg', "Captain")
+		nonsilicon_message_cooldown = world.time + COMMUNICATION_COOLDOWN
+	user.log_talk(input, LOG_SAY, tag="priority announcement")
+	message_admins("[ADMIN_LOOKUPFLW(user)] has made a priority announcement.")
+
+/datum/controller/subsystem/communications/proc/send_message(datum/comm_message/sending,print = TRUE,unique = FALSE)
+	for(var/obj/machinery/computer/communications/C in GLOB.machines)
+		if(!(C.stat & (BROKEN|NOPOWER)) && is_station_level(C.z))
+			if(unique)
+				C.add_message(sending)
+			else //We copy the message for each console, answers and deletions won't be shared
+				var/datum/comm_message/M = new(sending.title,sending.content,sending.possible_answers.Copy())
+				C.add_message(M)
+			if(print)
+				var/obj/item/paper/P = new /obj/item/paper(C.loc)
+				P.name = "paper - '[sending.title]'"
+				P.info = sending.content
+				P.update_icon()
+
+#undef COMMUNICATION_COOLDOWN
+#undef COMMUNICATION_COOLDOWN_AI

code/controllers/subsystem/dbcore.dm

@@ -0,0 +1,365 @@
+SUBSYSTEM_DEF(dbcore)
+	name = "Database"
+	flags = SS_BACKGROUND
+	wait = 1 MINUTES
+	init_order = INIT_ORDER_DBCORE
+	var/const/FAILED_DB_CONNECTION_CUTOFF = 5
+
+	var/schema_mismatch = 0
+	var/db_minor = 0
+	var/db_major = 0
+	var/failed_connections = 0
+
+	var/last_error
+	var/list/active_queries = list()
+
+	var/datum/BSQL_Connection/connection
+	var/datum/BSQL_Operation/connectOperation
+
+/datum/controller/subsystem/dbcore/Initialize()
+	//We send warnings to the admins during subsystem init, as the clients will be New'd and messages
+	//will queue properly with goonchat
+	switch(schema_mismatch)
+		if(1)
+			message_admins("Database schema ([db_major].[db_minor]) doesn't match the latest schema version ([DB_MAJOR_VERSION].[DB_MINOR_VERSION]), this may lead to undefined behaviour or errors")
+		if(2)
+			message_admins("Could not get schema version from database")
+
+	return ..()
+
+/datum/controller/subsystem/dbcore/fire()
+	for(var/I in active_queries)
+		var/datum/DBQuery/Q = I
+		if(world.time - Q.last_activity_time > (5 MINUTES))
+			message_admins("Found undeleted query, please check the server logs and notify coders.")
+			log_sql("Undeleted query: \"[Q.sql]\" LA: [Q.last_activity] LAT: [Q.last_activity_time]")
+			qdel(Q)
+		if(MC_TICK_CHECK)
+			return
+
+/datum/controller/subsystem/dbcore/Recover()
+	connection = SSdbcore.connection
+	connectOperation = SSdbcore.connectOperation
+
+/datum/controller/subsystem/dbcore/Shutdown()
+	//This is as close as we can get to the true round end before Disconnect() without changing where it's called, defeating the reason this is a subsystem
+	if(SSdbcore.Connect())
+		var/datum/DBQuery/query_round_shutdown = SSdbcore.NewQuery("UPDATE [format_table_name("round")] SET shutdown_datetime = Now(), end_state = '[sanitizeSQL(SSticker.end_state)]' WHERE id = [GLOB.round_id]")
+		query_round_shutdown.Execute()
+		qdel(query_round_shutdown)
+	if(IsConnected())
+		Disconnect()
+	world.BSQL_Shutdown()
+
+//nu
+/datum/controller/subsystem/dbcore/can_vv_get(var_name)
+	return var_name != NAMEOF(src, connection) && var_name != NAMEOF(src, active_queries) && var_name != NAMEOF(src, connectOperation) && ..()
+
+/datum/controller/subsystem/dbcore/vv_edit_var(var_name, var_value)
+	if(var_name == NAMEOF(src, connection) || var_name == NAMEOF(src, connectOperation))
+		return FALSE
+	return ..()
+
+/datum/controller/subsystem/dbcore/proc/Connect()
+	if(IsConnected())
+		return TRUE
+
+	if(failed_connections > FAILED_DB_CONNECTION_CUTOFF)	//If it failed to establish a connection more than 5 times in a row, don't bother attempting to connect anymore.
+		return FALSE
+
+	if(!CONFIG_GET(flag/sql_enabled))
+		return FALSE
+
+	var/user = CONFIG_GET(string/feedback_login)
+	var/pass = CONFIG_GET(string/feedback_password)
+	var/db = CONFIG_GET(string/feedback_database)
+	var/address = CONFIG_GET(string/address)
+	var/port = CONFIG_GET(number/port)
+
+	connection = new /datum/BSQL_Connection(BSQL_CONNECTION_TYPE_MARIADB, CONFIG_GET(number/async_query_timeout), CONFIG_GET(number/blocking_query_timeout), CONFIG_GET(number/bsql_thread_limit))
+	var/error
+	if(QDELETED(connection))
+		connection = null
+		error = last_error
+	else
+		SSdbcore.last_error = null
+		connectOperation = connection.BeginConnect(address, port, user, pass, db)
+		if(SSdbcore.last_error)
+			CRASH(SSdbcore.last_error)
+		UNTIL(connectOperation.IsComplete())
+		error = connectOperation.GetError()
+	. = !error
+	if (!.)
+		last_error = error
+		log_sql("Connect() failed | [error]")
+		++failed_connections
+		QDEL_NULL(connection)
+		QDEL_NULL(connectOperation)
+
+/datum/controller/subsystem/dbcore/proc/CheckSchemaVersion()
+	if(CONFIG_GET(flag/sql_enabled))
+		if(Connect())
+			log_world("Database connection established.")
+			var/datum/DBQuery/query_db_version = NewQuery("SELECT major, minor FROM [format_table_name("schema_revision")] ORDER BY date DESC LIMIT 1")
+			query_db_version.Execute()
+			if(query_db_version.NextRow())
+				db_major = text2num(query_db_version.item[1])
+				db_minor = text2num(query_db_version.item[2])
+				if(db_major != DB_MAJOR_VERSION || db_minor != DB_MINOR_VERSION)
+					schema_mismatch = 1 // flag admin message about mismatch
+					log_sql("Database schema ([db_major].[db_minor]) doesn't match the latest schema version ([DB_MAJOR_VERSION].[DB_MINOR_VERSION]), this may lead to undefined behaviour or errors")
+			else
+				schema_mismatch = 2 //flag admin message about no schema version
+				log_sql("Could not get schema version from database")
+			qdel(query_db_version)
+		else
+			log_sql("Your server failed to establish a connection with the database.")
+	else
+		log_sql("Database is not enabled in configuration.")
+
+/datum/controller/subsystem/dbcore/proc/SetRoundID()
+	if(!Connect())
+		return
+	var/datum/DBQuery/query_round_initialize = SSdbcore.NewQuery("INSERT INTO [format_table_name("round")] (initialize_datetime, server_ip, server_port) VALUES (Now(), INET_ATON(IF('[world.internet_address]' LIKE '', '0', '[world.internet_address]')), '[world.port]')")
+	query_round_initialize.Execute()
+	qdel(query_round_initialize)
+	var/datum/DBQuery/query_round_last_id = SSdbcore.NewQuery("SELECT LAST_INSERT_ID()")
+	query_round_last_id.Execute()
+	if(query_round_last_id.NextRow())
+		GLOB.round_id = query_round_last_id.item[1]
+	qdel(query_round_last_id)
+
+/datum/controller/subsystem/dbcore/proc/SetRoundStart()
+	if(!Connect())
+		return
+	var/datum/DBQuery/query_round_start = SSdbcore.NewQuery("UPDATE [format_table_name("round")] SET start_datetime = Now() WHERE id = [GLOB.round_id]")
+	query_round_start.Execute()
+	qdel(query_round_start)
+
+/datum/controller/subsystem/dbcore/proc/SetRoundEnd()
+	if(!Connect())
+		return
+	var/sql_station_name = sanitizeSQL(station_name())
+	var/datum/DBQuery/query_round_end = SSdbcore.NewQuery("UPDATE [format_table_name("round")] SET end_datetime = Now(), game_mode_result = '[sanitizeSQL(SSticker.mode_result)]', station_name = '[sql_station_name]' WHERE id = [GLOB.round_id]")
+	query_round_end.Execute()
+	qdel(query_round_end)
+
+/datum/controller/subsystem/dbcore/proc/Disconnect()
+	failed_connections = 0
+	QDEL_NULL(connectOperation)
+	QDEL_NULL(connection)
+
+/datum/controller/subsystem/dbcore/proc/IsConnected()
+	if(!CONFIG_GET(flag/sql_enabled))
+		return FALSE
+	//block until any connect operations finish
+	var/datum/BSQL_Connection/_connection = connection
+	var/datum/BSQL_Operation/op = connectOperation
+	UNTIL(QDELETED(_connection) || op.IsComplete())
+	return !QDELETED(connection) && !op.GetError()
+
+/datum/controller/subsystem/dbcore/proc/Quote(str)
+	if(connection)
+		return connection.Quote(str)
+
+/datum/controller/subsystem/dbcore/proc/ErrorMsg()
+	if(!CONFIG_GET(flag/sql_enabled))
+		return "Database disabled by configuration"
+	return last_error
+
+/datum/controller/subsystem/dbcore/proc/ReportError(error)
+	last_error = error
+
+/datum/controller/subsystem/dbcore/proc/NewQuery(sql_query)
+	if(IsAdminAdvancedProcCall())
+		log_admin_private("ERROR: Advanced admin proc call led to sql query: [sql_query]. Query has been blocked")
+		message_admins("ERROR: Advanced admin proc call led to sql query. Query has been blocked")
+		return FALSE
+	return new /datum/DBQuery(sql_query, connection)
+
+/*
+Takes a list of rows (each row being an associated list of column => value) and inserts them via a single mass query.
+Rows missing columns present in other rows will resolve to SQL NULL
+You are expected to do your own escaping of the data, and expected to provide your own quotes for strings.
+The duplicate_key arg can be true to automatically generate this part of the query
+	or set to a string that is appended to the end of the query
+Ignore_errors instructes mysql to continue inserting rows if some of them have errors.
+	 the erroneous row(s) aren't inserted and there isn't really any way to know why or why errored
+Delayed insert mode was removed in mysql 7 and only works with MyISAM type tables,
+	It was included because it is still supported in mariadb.
+	It does not work with duplicate_key and the mysql server ignores it in those cases
+*/
+/datum/controller/subsystem/dbcore/proc/MassInsert(table, list/rows, duplicate_key = FALSE, ignore_errors = FALSE, delayed = FALSE, warn = FALSE, async = TRUE)
+	if (!table || !rows || !istype(rows))
+		return
+	var/list/columns = list()
+	var/list/sorted_rows = list()
+
+	for (var/list/row in rows)
+		var/list/sorted_row = list()
+		sorted_row.len = columns.len
+		for (var/column in row)
+			var/idx = columns[column]
+			if (!idx)
+				idx = columns.len + 1
+				columns[column] = idx
+				sorted_row.len = columns.len
+
+			sorted_row[idx] = row[column]
+		sorted_rows[++sorted_rows.len] = sorted_row
+
+	if (duplicate_key == TRUE)
+		var/list/column_list = list()
+		for (var/column in columns)
+			column_list += "[column] = VALUES([column])"
+		duplicate_key = "ON DUPLICATE KEY UPDATE [column_list.Join(", ")]\n"
+	else if (duplicate_key == FALSE)
+		duplicate_key = null
+
+	if (ignore_errors)
+		ignore_errors = " IGNORE"
+	else
+		ignore_errors = null
+
+	if (delayed)
+		delayed = " DELAYED"
+	else
+		delayed = null
+
+	var/list/sqlrowlist = list()
+	var/len = columns.len
+	for (var/list/row in sorted_rows)
+		if (length(row) != len)
+			row.len = len
+		for (var/value in row)
+			if (value == null)
+				value = "NULL"
+		sqlrowlist += "([row.Join(", ")])"
+
+	sqlrowlist = "	[sqlrowlist.Join(",\n	")]"
+	var/datum/DBQuery/Query = NewQuery("INSERT[delayed][ignore_errors] INTO [table]\n([columns.Join(", ")])\nVALUES\n[sqlrowlist]\n[duplicate_key]")
+	if (warn)
+		. = Query.warn_execute(async)
+	else
+		. = Query.Execute(async)
+	qdel(Query)
+
+/datum/DBQuery
+	var/sql // The sql query being executed.
+	var/list/item  //list of data values populated by NextRow()
+
+	var/last_activity
+	var/last_activity_time
+
+	var/last_error
+	var/skip_next_is_complete
+	var/in_progress
+	var/datum/BSQL_Connection/connection
+	var/datum/BSQL_Operation/Query/query
+
+/datum/DBQuery/New(sql_query, datum/BSQL_Connection/connection)
+	SSdbcore.active_queries[src] = TRUE
+	Activity("Created")
+	item = list()
+	src.connection = connection
+	sql = sql_query
+
+/datum/DBQuery/Destroy()
+	Close()
+	SSdbcore.active_queries -= src
+	return ..()
+
+/datum/DBQuery/CanProcCall(proc_name)
+	//fuck off kevinz
+	return FALSE
+
+/datum/DBQuery/proc/SetQuery(new_sql)
+	if(in_progress)
+		CRASH("Attempted to set new sql while waiting on active query")
+	Close()
+	sql = new_sql
+
+/datum/DBQuery/proc/Activity(activity)
+	last_activity = activity
+	last_activity_time = world.time
+
+/datum/DBQuery/proc/warn_execute(async = FALSE)
+	. = Execute(async)
+	if(!.)
+		to_chat(usr, "<span class='danger'>A SQL error occurred during this operation, check the server logs.</span>")
+
+/datum/DBQuery/proc/Execute(async = FALSE, log_error = TRUE)
+	Activity("Execute")
+	if(in_progress)
+		CRASH("Attempted to start a new query while waiting on the old one")
+
+	if(QDELETED(connection))
+		last_error = "No connection!"
+		return FALSE
+
+	var/start_time
+	var/timed_out
+	if(!async)
+		start_time = REALTIMEOFDAY
+	Close()
+	query = connection.BeginQuery(sql)
+	if(!async)
+		timed_out = !query.WaitForCompletion()
+	else
+		in_progress = TRUE
+		UNTIL(query.IsComplete())
+		in_progress = FALSE
+	skip_next_is_complete = TRUE
+	var/error = QDELETED(query) ? "Query object deleted!" : query.GetError()
+	last_error = error
+	. = !error
+	if(!. && log_error)
+		log_sql("[error] | Query used: [sql]")
+	if(!async && timed_out)
+		log_query_debug("Query execution started at [start_time]")
+		log_query_debug("Query execution ended at [REALTIMEOFDAY]")
+		log_query_debug("Slow query timeout detected.")
+		log_query_debug("Query used: [sql]")
+		slow_query_check()
+
+/datum/DBQuery/proc/slow_query_check()
+	message_admins("HEY! A database query timed out. Did the server just hang? <a href='?_src_=holder;[HrefToken()];slowquery=yes'>\[YES\]</a>|<a href='?_src_=holder;[HrefToken()];slowquery=no'>\[NO\]</a>")
+
+/datum/DBQuery/proc/NextRow(async)
+	Activity("NextRow")
+	UNTIL(!in_progress)
+	if(!skip_next_is_complete)
+		if(!async)
+			query.WaitForCompletion()
+		else
+			in_progress = TRUE
+			UNTIL(query.IsComplete())
+			in_progress = FALSE
+	else
+		skip_next_is_complete = FALSE
+
+	last_error = query.GetError()
+	var/list/results = query.CurrentRow()
+	. = results != null
+
+	item.Cut()
+	//populate item array
+	for(var/I in results)
+		item += results[I]
+
+/datum/DBQuery/proc/ErrorMsg()
+	return last_error
+
+/datum/DBQuery/proc/Close()
+	item.Cut()
+	QDEL_NULL(query)
+
+/world/BSQL_Debug(message)
+	if(!CONFIG_GET(flag/bsql_debug))
+		return
+
+	//strip sensitive stuff
+	if(findtext(message, ": CreateConnection("))
+		message = "CreateConnection CENSORED"
+	
+	log_sql("BSQL_DEBUG: [message]")

code/controllers/subsystem/dcs.dm

@@ -0,0 +1,6 @@
+SUBSYSTEM_DEF(dcs)
+	name = "Datum Component System"
+	flags = SS_NO_INIT | SS_NO_FIRE
+
+/datum/controller/subsystem/dcs/Recover()
+	comp_lookup = SSdcs.comp_lookup

code/controllers/subsystem/disease.dm

@@ -0,0 +1,30 @@
+SUBSYSTEM_DEF(disease)
+	name = "Disease"
+	flags = SS_NO_FIRE
+
+	var/list/active_diseases = list() //List of Active disease in all mobs; purely for quick referencing.
+	var/list/diseases
+	var/list/archive_diseases = list()
+
+	var/static/list/list_symptoms = subtypesof(/datum/symptom)
+
+/datum/controller/subsystem/disease/PreInit()
+	if(!diseases)
+		diseases = subtypesof(/datum/disease)
+
+/datum/controller/subsystem/disease/Initialize(timeofday)
+	var/list/all_common_diseases = diseases - typesof(/datum/disease/advance)
+	for(var/common_disease_type in all_common_diseases)
+		var/datum/disease/prototype = new common_disease_type()
+		archive_diseases[prototype.GetDiseaseID()] = prototype
+	return ..()
+
+/datum/controller/subsystem/disease/stat_entry(msg)
+	..("P:[active_diseases.len]")
+
+/datum/controller/subsystem/disease/proc/get_disease_name(id)
+	var/datum/disease/advance/A = archive_diseases[id]
+	if(A.name)
+		return A.name
+	else
+		return "Unknown"

code/controllers/subsystem/events.dm

@@ -0,0 +1,186 @@
+SUBSYSTEM_DEF(events)
+	name = "Events"
+	init_order = INIT_ORDER_EVENTS
+	runlevels = RUNLEVEL_GAME
+
+	var/list/control = list()	//list of all datum/round_event_control. Used for selecting events based on weight and occurrences.
+	var/list/running = list()	//list of all existing /datum/round_event
+	var/list/currentrun = list()
+
+	var/scheduled = 0			//The next world.time that a naturally occuring random event can be selected.
+	var/frequency_lower = 1800	//3 minutes lower bound.
+	var/frequency_upper = 6000	//10 minutes upper bound. Basically an event will happen every 3 to 10 minutes.
+
+	var/list/holidays			//List of all holidays occuring today or null if no holidays
+	var/wizardmode = 0
+
+/datum/controller/subsystem/events/Initialize(time, zlevel)
+	for(var/type in typesof(/datum/round_event_control))
+		var/datum/round_event_control/E = new type()
+		if(!E.typepath)
+			continue				//don't want this one! leave it for the garbage collector
+		control += E				//add it to the list of all events (controls)
+	reschedule()
+	getHoliday()
+	return ..()
+
+
+/datum/controller/subsystem/events/fire(resumed = 0)
+	if(!resumed)
+		checkEvent() //only check these if we aren't resuming a paused fire
+		src.currentrun = running.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(currentrun.len)
+		var/datum/thing = currentrun[currentrun.len]
+		currentrun.len--
+		if(thing)
+			thing.process()
+		else
+			running.Remove(thing)
+		if (MC_TICK_CHECK)
+			return
+
+//checks if we should select a random event yet, and reschedules if necessary
+/datum/controller/subsystem/events/proc/checkEvent()
+	if(scheduled <= world.time)
+		spawnEvent()
+		reschedule()
+
+//decides which world.time we should select another random event at.
+/datum/controller/subsystem/events/proc/reschedule()
+	scheduled = world.time + rand(frequency_lower, max(frequency_lower,frequency_upper))
+
+//selects a random event based on whether it can occur and it's 'weight'(probability)
+/datum/controller/subsystem/events/proc/spawnEvent()
+	set waitfor = FALSE	//for the admin prompt
+	if(!CONFIG_GET(flag/allow_random_events))
+		return
+
+	var/gamemode = SSticker.mode.config_tag
+	var/players_amt = get_active_player_count(alive_check = 1, afk_check = 1, human_check = 1)
+	// Only alive, non-AFK human players count towards this.
+
+	var/sum_of_weights = 0
+	for(var/datum/round_event_control/E in control)
+		if(!E.canSpawnEvent(players_amt, gamemode))
+			continue
+		if(E.weight < 0)						//for round-start events etc.
+			var/res = TriggerEvent(E)
+			if(res == EVENT_INTERRUPTED)
+				continue	//like it never happened
+			if(res == EVENT_CANT_RUN)
+				return
+		sum_of_weights += E.weight
+
+	sum_of_weights = rand(0,sum_of_weights)	//reusing this variable. It now represents the 'weight' we want to select
+
+	for(var/datum/round_event_control/E in control)
+		if(!E.canSpawnEvent(players_amt, gamemode))
+			continue
+		sum_of_weights -= E.weight
+
+		if(sum_of_weights <= 0)				//we've hit our goal
+			if(TriggerEvent(E))
+				return
+
+/datum/controller/subsystem/events/proc/TriggerEvent(datum/round_event_control/E)
+	. = E.preRunEvent()
+	if(. == EVENT_CANT_RUN)//we couldn't run this event for some reason, set its max_occurrences to 0
+		E.max_occurrences = 0
+	else if(. == EVENT_READY)
+		E.runEvent(TRUE)
+
+//allows a client to trigger an event
+//aka Badmin Central
+// > Not in modules/admin
+// REEEEEEEEE
+/client/proc/forceEvent()
+	set name = "Trigger Event"
+	set category = "Fun"
+
+	if(!holder ||!check_rights(R_FUN))
+		return
+
+	holder.forceEvent()
+
+/datum/admins/proc/forceEvent()
+	var/dat 	= ""
+	var/normal 	= ""
+	var/magic 	= ""
+	var/holiday = ""
+	for(var/datum/round_event_control/E in SSevents.control)
+		dat = "<BR><A href='?src=[REF(src)];[HrefToken()];forceevent=[REF(E)]'>[E]</A>"
+		if(E.holidayID)
+			holiday	+= dat
+		else if(E.wizardevent)
+			magic 	+= dat
+		else
+			normal 	+= dat
+
+	dat = normal + "<BR>" + magic + "<BR>" + holiday
+
+	var/datum/browser/popup = new(usr, "forceevent", "Force Random Event", 300, 750)
+	popup.set_content(dat)
+	popup.open()
+
+
+/*
+//////////////
+// HOLIDAYS //
+//////////////
+//Uncommenting ALLOW_HOLIDAYS in config.txt will enable holidays
+
+//It's easy to add stuff. Just add a holiday datum in code/modules/holiday/holidays.dm
+//You can then check if it's a special day in any code in the game by doing if(SSevents.holidays["Groundhog Day"])
+
+//You can also make holiday random events easily thanks to Pete/Gia's system.
+//simply make a random event normally, then assign it a holidayID string which matches the holiday's name.
+//Anything with a holidayID, which isn't in the holidays list, will never occur.
+
+//Please, Don't spam stuff up with stupid stuff (key example being april-fools Pooh/ERP/etc),
+//And don't forget: CHECK YOUR CODE!!!! We don't want any zero-day bugs which happen only on holidays and never get found/fixed!
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ALSO, MOST IMPORTANTLY: Don't add stupid stuff! Discuss bonus content with Project-Heads first please!//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+*/
+
+//sets up the holidays and holidays list
+/datum/controller/subsystem/events/proc/getHoliday()
+	if(!CONFIG_GET(flag/allow_holidays))
+		return		// Holiday stuff was not enabled in the config!
+
+	var/YY = text2num(time2text(world.timeofday, "YY")) 	// get the current year
+	var/MM = text2num(time2text(world.timeofday, "MM")) 	// get the current month
+	var/DD = text2num(time2text(world.timeofday, "DD")) 	// get the current day
+	var/DDD = time2text(world.timeofday, "DDD")	// get the current weekday
+	var/W = weekdayofthemonth()	// is this the first monday? second? etc.
+
+	for(var/H in subtypesof(/datum/holiday))
+		var/datum/holiday/holiday = new H()
+		if(holiday.shouldCelebrate(DD, MM, YY, W, DDD))
+			holiday.celebrate()
+			if(!holidays)
+				holidays = list()
+			holidays[holiday.name] = holiday
+		else
+			qdel(holiday)
+
+	if(holidays)
+		holidays = shuffle(holidays)
+		// regenerate station name because holiday prefixes.
+		set_station_name(new_station_name())
+		world.update_status()
+
+/datum/controller/subsystem/events/proc/toggleWizardmode()
+	wizardmode = !wizardmode
+	message_admins("Summon Events has been [wizardmode ? "enabled, events will occur every [SSevents.frequency_lower / 600] to [SSevents.frequency_upper / 600] minutes" : "disabled"]!")
+	log_game("Summon Events was [wizardmode ? "enabled" : "disabled"]!")
+
+
+/datum/controller/subsystem/events/proc/resetFrequency()
+	frequency_lower = initial(frequency_lower)
+	frequency_upper = initial(frequency_upper)

code/controllers/subsystem/fire_burning.dm

@@ -0,0 +1,37 @@
+SUBSYSTEM_DEF(fire_burning)
+	name = "Fire Burning"
+	priority = FIRE_PRIOTITY_BURNING
+	flags = SS_NO_INIT|SS_BACKGROUND
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+	var/list/processing = list()
+
+/datum/controller/subsystem/fire_burning/stat_entry()
+	..("P:[processing.len]")
+
+
+/datum/controller/subsystem/fire_burning/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = processing.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(currentrun.len)
+		var/obj/O = currentrun[currentrun.len]
+		currentrun.len--
+		if (!O || QDELETED(O))
+			processing -= O
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		if(O.resistance_flags & ON_FIRE)
+			O.take_damage(20, BURN, "fire", 0)
+		else
+			processing -= O
+
+		if (MC_TICK_CHECK)
+			return
+

code/controllers/subsystem/garbage.dm

@@ -0,0 +1,435 @@
+SUBSYSTEM_DEF(garbage)
+	name = "Garbage"
+	priority = FIRE_PRIORITY_GARBAGE
+	wait = 2 SECONDS
+	flags = SS_POST_FIRE_TIMING|SS_BACKGROUND|SS_NO_INIT
+	runlevels = RUNLEVELS_DEFAULT | RUNLEVEL_LOBBY
+	init_order = INIT_ORDER_GARBAGE
+
+	var/list/collection_timeout = list(0, 2 MINUTES, 10 SECONDS)	// deciseconds to wait before moving something up in the queue to the next level
+
+	//Stat tracking
+	var/delslasttick = 0			// number of del()'s we've done this tick
+	var/gcedlasttick = 0			// number of things that gc'ed last tick
+	var/totaldels = 0
+	var/totalgcs = 0
+
+	var/highest_del_time = 0
+	var/highest_del_tickusage = 0
+
+	var/list/pass_counts
+	var/list/fail_counts
+
+	var/list/items = list()			// Holds our qdel_item statistics datums
+
+	//Queue
+	var/list/queues
+
+	#ifdef TESTING
+	var/list/reference_find_on_fail = list()
+	#endif
+
+
+/datum/controller/subsystem/garbage/PreInit()
+	queues = new(GC_QUEUE_COUNT)
+	pass_counts = new(GC_QUEUE_COUNT)
+	fail_counts = new(GC_QUEUE_COUNT)
+	for(var/i in 1 to GC_QUEUE_COUNT)
+		queues[i] = list()
+		pass_counts[i] = 0
+		fail_counts[i] = 0
+
+/datum/controller/subsystem/garbage/stat_entry(msg)
+	var/list/counts = list()
+	for (var/list/L in queues)
+		counts += length(L)
+	msg += "Q:[counts.Join(",")]|D:[delslasttick]|G:[gcedlasttick]|"
+	msg += "GR:"
+	if (!(delslasttick+gcedlasttick))
+		msg += "n/a|"
+	else
+		msg += "[round((gcedlasttick/(delslasttick+gcedlasttick))*100, 0.01)]%|"
+
+	msg += "TD:[totaldels]|TG:[totalgcs]|"
+	if (!(totaldels+totalgcs))
+		msg += "n/a|"
+	else
+		msg += "TGR:[round((totalgcs/(totaldels+totalgcs))*100, 0.01)]%"
+	msg += " P:[pass_counts.Join(",")]"
+	msg += "|F:[fail_counts.Join(",")]"
+	..(msg)
+
+/datum/controller/subsystem/garbage/Shutdown()
+	//Adds the del() log to the qdel log file
+	var/list/dellog = list()
+
+	//sort by how long it's wasted hard deleting
+	sortTim(items, cmp=/proc/cmp_qdel_item_time, associative = TRUE)
+	for(var/path in items)
+		var/datum/qdel_item/I = items[path]
+		dellog += "Path: [path]"
+		if (I.failures)
+			dellog += "\tFailures: [I.failures]"
+		dellog += "\tqdel() Count: [I.qdels]"
+		dellog += "\tDestroy() Cost: [I.destroy_time]ms"
+		if (I.hard_deletes)
+			dellog += "\tTotal Hard Deletes [I.hard_deletes]"
+			dellog += "\tTime Spent Hard Deleting: [I.hard_delete_time]ms"
+		if (I.slept_destroy)
+			dellog += "\tSleeps: [I.slept_destroy]"
+		if (I.no_respect_force)
+			dellog += "\tIgnored force: [I.no_respect_force] times"
+		if (I.no_hint)
+			dellog += "\tNo hint: [I.no_hint] times"
+	log_qdel(dellog.Join("\n"))
+
+/datum/controller/subsystem/garbage/fire()
+	//the fact that this resets its processing each fire (rather then resume where it left off) is intentional.
+	var/queue = GC_QUEUE_CHECK
+
+	while (state == SS_RUNNING)
+		switch (queue)
+			if (GC_QUEUE_CHECK)
+				HandleQueue(GC_QUEUE_CHECK)
+				queue = GC_QUEUE_CHECK+1
+			if (GC_QUEUE_HARDDELETE)
+				HandleQueue(GC_QUEUE_HARDDELETE)
+				if (state == SS_PAUSED) //make us wait again before the next run.
+					state = SS_RUNNING
+				break
+
+	
+
+
+/datum/controller/subsystem/garbage/proc/HandleQueue(level = GC_QUEUE_CHECK)
+	if (level == GC_QUEUE_CHECK)
+		delslasttick = 0
+		gcedlasttick = 0
+	var/cut_off_time = world.time - collection_timeout[level] //ignore entries newer then this
+	var/list/queue = queues[level]
+	var/static/lastlevel
+	var/static/count = 0
+	if (count) //runtime last run before we could do this.
+		var/c = count
+		count = 0 //so if we runtime on the Cut, we don't try again.
+		var/list/lastqueue = queues[lastlevel]
+		lastqueue.Cut(1, c+1)
+
+	lastlevel = level
+
+	for (var/refID in queue)
+		if (!refID)
+			count++
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		var/GCd_at_time = queue[refID]
+		if(GCd_at_time > cut_off_time)
+			break // Everything else is newer, skip them
+		count++
+
+		var/datum/D
+		D = locate(refID)
+
+		if (!D || D.gc_destroyed != GCd_at_time) // So if something else coincidently gets the same ref, it's not deleted by mistake
+			++gcedlasttick
+			++totalgcs
+			pass_counts[level]++
+			#ifdef TESTING
+			reference_find_on_fail -= refID		//It's deleted we don't care anymore.
+			#endif
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		// Something's still referring to the qdel'd object.
+		fail_counts[level]++
+		switch (level)
+			if (GC_QUEUE_CHECK)
+				#ifdef TESTING
+				if(reference_find_on_fail[refID])
+					D.find_references()
+				#ifdef GC_FAILURE_HARD_LOOKUP
+				else
+					D.find_references()
+				#endif
+				reference_find_on_fail -= refID
+				#endif
+				var/type = D.type
+				var/datum/qdel_item/I = items[type]
+				testing("GC: -- \ref[src] | [type] was unable to be GC'd --")
+				I.failures++
+			if (GC_QUEUE_HARDDELETE)
+				HardDelete(D)
+				if (MC_TICK_CHECK)
+					return
+				continue
+
+		Queue(D, level+1)
+
+		if (MC_TICK_CHECK)
+			return
+	if (count)
+		queue.Cut(1,count+1)
+		count = 0
+
+/datum/controller/subsystem/garbage/proc/Queue(datum/D, level = GC_QUEUE_CHECK)
+	if (isnull(D))
+		return
+	if (level > GC_QUEUE_COUNT)
+		HardDelete(D)
+		return
+	var/gctime = world.time
+	var/refid = "\ref[D]"
+
+	D.gc_destroyed = gctime
+	var/list/queue = queues[level]
+	if (queue[refid])
+		queue -= refid // Removing any previous references that were GC'd so that the current object will be at the end of the list.
+
+	queue[refid] = gctime
+
+//this is mainly to separate things profile wise.
+/datum/controller/subsystem/garbage/proc/HardDelete(datum/D)
+	var/time = world.timeofday
+	var/tick = TICK_USAGE
+	var/ticktime = world.time
+	++delslasttick
+	++totaldels
+	var/type = D.type
+	var/refID = "\ref[D]"
+
+	del(D)
+
+	tick = (TICK_USAGE-tick+((world.time-ticktime)/world.tick_lag*100))
+
+	var/datum/qdel_item/I = items[type]
+
+	I.hard_deletes++
+	I.hard_delete_time += TICK_DELTA_TO_MS(tick)
+
+
+	if (tick > highest_del_tickusage)
+		highest_del_tickusage = tick
+	time = world.timeofday - time
+	if (!time && TICK_DELTA_TO_MS(tick) > 1)
+		time = TICK_DELTA_TO_MS(tick)/100
+	if (time > highest_del_time)
+		highest_del_time = time
+	if (time > 10)
+		log_game("Error: [type]([refID]) took longer than 1 second to delete (took [time/10] seconds to delete)")
+		message_admins("Error: [type]([refID]) took longer than 1 second to delete (took [time/10] seconds to delete).")
+		postpone(time)
+
+/datum/controller/subsystem/garbage/Recover()
+	if (istype(SSgarbage.queues))
+		for (var/i in 1 to SSgarbage.queues.len)
+			queues[i] |= SSgarbage.queues[i]
+
+
+/datum/qdel_item
+	var/name = ""
+	var/qdels = 0			//Total number of times it's passed thru qdel.
+	var/destroy_time = 0	//Total amount of milliseconds spent processing this type's Destroy()
+	var/failures = 0		//Times it was queued for soft deletion but failed to soft delete.
+	var/hard_deletes = 0 	//Different from failures because it also includes QDEL_HINT_HARDDEL deletions
+	var/hard_delete_time = 0//Total amount of milliseconds spent hard deleting this type.
+	var/no_respect_force = 0//Number of times it's not respected force=TRUE
+	var/no_hint = 0			//Number of times it's not even bother to give a qdel hint
+	var/slept_destroy = 0	//Number of times it's slept in its destroy
+
+/datum/qdel_item/New(mytype)
+	name = "[mytype]"
+
+#ifdef TESTING
+/proc/qdel_and_find_ref_if_fail(datum/D, force = FALSE)
+	SSgarbage.reference_find_on_fail[REF(D)] = TRUE
+	qdel(D, force)
+#endif
+
+// Should be treated as a replacement for the 'del' keyword.
+// Datums passed to this will be given a chance to clean up references to allow the GC to collect them.
+/proc/qdel(datum/D, force=FALSE, ...)
+	if(!istype(D))
+		del(D)
+		return
+	var/datum/qdel_item/I = SSgarbage.items[D.type]
+	if (!I)
+		I = SSgarbage.items[D.type] = new /datum/qdel_item(D.type)
+	I.qdels++
+
+
+	if(isnull(D.gc_destroyed))
+		if (SEND_SIGNAL(D, COMSIG_PARENT_PREQDELETED, force)) // Give the components a chance to prevent their parent from being deleted
+			return
+		D.gc_destroyed = GC_CURRENTLY_BEING_QDELETED
+		var/start_time = world.time
+		var/start_tick = world.tick_usage
+		var/hint = D.Destroy(arglist(args.Copy(2))) // Let our friend know they're about to get fucked up.
+		SEND_SIGNAL(D, COMSIG_PARENT_QDELETED, force, hint) // Let the (remaining) components know about the result of Destroy
+		if(world.time != start_time)
+			I.slept_destroy++
+		else
+			I.destroy_time += TICK_USAGE_TO_MS(start_tick)
+		if(!D)
+			return
+		switch(hint)
+			if (QDEL_HINT_QUEUE)		//qdel should queue the object for deletion.
+				SSgarbage.Queue(D)
+			if (QDEL_HINT_IWILLGC)
+				D.gc_destroyed = world.time
+				return
+			if (QDEL_HINT_LETMELIVE)	//qdel should let the object live after calling destory.
+				if(!force)
+					D.gc_destroyed = null //clear the gc variable (important!)
+					return
+				// Returning LETMELIVE after being told to force destroy
+				// indicates the objects Destroy() does not respect force
+				#ifdef TESTING
+				if(!I.no_respect_force)
+					testing("WARNING: [D.type] has been force deleted, but is \
+						returning an immortal QDEL_HINT, indicating it does \
+						not respect the force flag for qdel(). It has been \
+						placed in the queue, further instances of this type \
+						will also be queued.")
+				#endif
+				I.no_respect_force++
+
+				SSgarbage.Queue(D)
+			if (QDEL_HINT_HARDDEL)		//qdel should assume this object won't gc, and queue a hard delete
+				SSgarbage.Queue(D, GC_QUEUE_HARDDELETE)
+			if (QDEL_HINT_HARDDEL_NOW)	//qdel should assume this object won't gc, and hard del it post haste.
+				SSgarbage.HardDelete(D)
+			if (QDEL_HINT_FINDREFERENCE)//qdel will, if TESTING is enabled, display all references to this object, then queue the object for deletion.
+				SSgarbage.Queue(D)
+				#ifdef TESTING
+				D.find_references()
+				#endif
+			if (QDEL_HINT_IFFAIL_FINDREFERENCE)
+				SSgarbage.Queue(D)
+				#ifdef TESTING
+				SSgarbage.reference_find_on_fail[REF(D)] = TRUE
+				#endif
+			else
+				#ifdef TESTING
+				if(!I.no_hint)
+					testing("WARNING: [D.type] is not returning a qdel hint. It is being placed in the queue. Further instances of this type will also be queued.")
+				#endif
+				I.no_hint++
+				SSgarbage.Queue(D)
+	else if(D.gc_destroyed == GC_CURRENTLY_BEING_QDELETED)
+		CRASH("[D.type] destroy proc was called multiple times, likely due to a qdel loop in the Destroy logic")
+
+#ifdef TESTING
+
+/datum/verb/find_refs()
+	set category = "Debug"
+	set name = "Find References"
+	set src in world
+
+	find_references(FALSE)
+
+/datum/proc/find_references(skip_alert)
+	running_find_references = type
+	if(usr && usr.client)
+		if(usr.client.running_find_references)
+			testing("CANCELLED search for references to a [usr.client.running_find_references].")
+			usr.client.running_find_references = null
+			running_find_references = null
+			//restart the garbage collector
+			SSgarbage.can_fire = 1
+			SSgarbage.next_fire = world.time + world.tick_lag
+			return
+
+		if(!skip_alert)
+			if(alert("Running this will lock everything up for about 5 minutes.  Would you like to begin the search?", "Find References", "Yes", "No") == "No")
+				running_find_references = null
+				return
+
+	//this keeps the garbage collector from failing to collect objects being searched for in here
+	SSgarbage.can_fire = 0
+
+	if(usr && usr.client)
+		usr.client.running_find_references = type
+
+	testing("Beginning search for references to a [type].")
+	last_find_references = world.time
+
+	DoSearchVar(GLOB) //globals
+	for(var/datum/thing in world) //atoms (don't beleive it's lies)
+		DoSearchVar(thing, "World -> [thing]")
+
+	for (var/datum/thing) //datums
+		DoSearchVar(thing, "World -> [thing]")
+
+	for (var/client/thing) //clients
+		DoSearchVar(thing, "World -> [thing]")
+
+	testing("Completed search for references to a [type].")
+	if(usr && usr.client)
+		usr.client.running_find_references = null
+	running_find_references = null
+
+	//restart the garbage collector
+	SSgarbage.can_fire = 1
+	SSgarbage.next_fire = world.time + world.tick_lag
+
+/datum/verb/qdel_then_find_references()
+	set category = "Debug"
+	set name = "qdel() then Find References"
+	set src in world
+
+	qdel(src, TRUE)		//Force.
+	if(!running_find_references)
+		find_references(TRUE)
+
+/datum/verb/qdel_then_if_fail_find_references()
+	set category = "Debug"
+	set name = "qdel() then Find References if GC failure"
+	set src in world
+
+	qdel_and_find_ref_if_fail(src, TRUE)
+
+/datum/proc/DoSearchVar(X, Xname, recursive_limit = 64)
+	if(usr && usr.client && !usr.client.running_find_references)
+		return
+	if (!recursive_limit)
+		return
+
+	if(istype(X, /datum))
+		var/datum/D = X
+		if(D.last_find_references == last_find_references)
+			return
+
+		D.last_find_references = last_find_references
+		var/list/L = D.vars
+
+		for(var/varname in L)
+			if (varname == "vars")
+				continue
+			var/variable = L[varname]
+
+			if(variable == src)
+				testing("Found [src.type] \ref[src] in [D.type]'s [varname] var. [Xname]")
+
+			else if(islist(variable))
+				DoSearchVar(variable, "[Xname] -> list", recursive_limit-1)
+
+	else if(islist(X))
+		var/normal = IS_NORMAL_LIST(X)
+		for(var/I in X)
+			if (I == src)
+				testing("Found [src.type] \ref[src] in list [Xname].")
+
+			else if (I && !isnum(I) && normal && X[I] == src)
+				testing("Found [src.type] \ref[src] in list [Xname]\[[I]\]")
+
+			else if (islist(I))
+				DoSearchVar(I, "[Xname] -> list", recursive_limit-1)
+
+#ifndef FIND_REF_NO_CHECK_TICK
+	CHECK_TICK
+#endif
+
+#endif

code/controllers/subsystem/icon_smooth.dm

@@ -0,0 +1,42 @@
+SUBSYSTEM_DEF(icon_smooth)
+	name = "Icon Smoothing"
+	init_order = INIT_ORDER_ICON_SMOOTHING
+	wait = 1
+	priority = FIRE_PRIOTITY_SMOOTHING
+	flags = SS_TICKER
+
+	var/list/smooth_queue = list()
+	var/list/deferred = list()
+
+/datum/controller/subsystem/icon_smooth/fire()
+	var/list/cached = smooth_queue
+	while(cached.len)
+		var/atom/A = cached[cached.len]
+		cached.len--
+		if (A.flags_1 & INITIALIZED_1)
+			smooth_icon(A)
+		else
+			deferred += A
+		if (MC_TICK_CHECK)
+			return
+
+	if (!cached.len)
+		if (deferred.len)
+			smooth_queue = deferred
+			deferred = cached
+		else
+			can_fire = 0
+
+/datum/controller/subsystem/icon_smooth/Initialize()
+	smooth_zlevel(1,TRUE)
+	smooth_zlevel(2,TRUE)
+	var/queue = smooth_queue
+	smooth_queue = list()
+	for(var/V in queue)
+		var/atom/A = V
+		if(!A || A.z <= 2)
+			continue
+		smooth_icon(A)
+		CHECK_TICK
+
+	return ..()

code/controllers/subsystem/idlenpcpool.dm

@@ -0,0 +1,45 @@
+SUBSYSTEM_DEF(idlenpcpool)
+	name = "Idling NPC Pool"
+	flags = SS_POST_FIRE_TIMING|SS_BACKGROUND|SS_NO_INIT
+	priority = FIRE_PRIORITY_IDLE_NPC
+	wait = 60
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+	var/static/list/idle_mobs_by_zlevel[][]
+
+/datum/controller/subsystem/idlenpcpool/stat_entry()
+	var/list/idlelist = GLOB.simple_animals[AI_IDLE]
+	var/list/zlist = GLOB.simple_animals[AI_Z_OFF]
+	..("IdleNPCS:[idlelist.len]|Z:[zlist.len]")
+
+/datum/controller/subsystem/idlenpcpool/proc/MaxZChanged()
+	if (!islist(idle_mobs_by_zlevel))
+		idle_mobs_by_zlevel = new /list(world.maxz,0)
+	while (SSidlenpcpool.idle_mobs_by_zlevel.len < world.maxz)
+		SSidlenpcpool.idle_mobs_by_zlevel.len++
+		SSidlenpcpool.idle_mobs_by_zlevel[idle_mobs_by_zlevel.len] = list()
+
+/datum/controller/subsystem/idlenpcpool/fire(resumed = FALSE)
+
+	if (!resumed)
+		var/list/idlelist = GLOB.simple_animals[AI_IDLE]
+		src.currentrun = idlelist.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(currentrun.len)
+		var/mob/living/simple_animal/SA = currentrun[currentrun.len]
+		--currentrun.len
+		if (!SA)
+			GLOB.simple_animals[AI_IDLE] -= SA
+			continue
+
+		if(!SA.ckey)
+			if(SA.stat != DEAD)
+				SA.handle_automated_movement()
+			if(SA.stat != DEAD)
+				SA.consider_wakeup()
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/input.dm

@@ -0,0 +1,118 @@
+SUBSYSTEM_DEF(input)
+	name = "Input"
+	wait = 1 //SS_TICKER means this runs every tick
+	init_order = INIT_ORDER_INPUT
+	flags = SS_TICKER
+	priority = FIRE_PRIORITY_INPUT
+	runlevels = RUNLEVELS_DEFAULT | RUNLEVEL_LOBBY
+
+	var/list/macro_sets
+	var/list/movement_keys
+
+/datum/controller/subsystem/input/Initialize()
+	setup_default_macro_sets()
+
+	setup_default_movement_keys()
+
+	initialized = TRUE
+
+	refresh_client_macro_sets()
+
+	return ..()
+
+// This is for when macro sets are eventualy datumized
+/datum/controller/subsystem/input/proc/setup_default_macro_sets()
+	var/list/static/default_macro_sets
+	
+	if(default_macro_sets)
+		macro_sets = default_macro_sets
+		return
+
+	default_macro_sets = list(
+		"default" = list(
+			"Tab" = "\".winset \\\"input.focus=true?map.focus=true input.background-color=[COLOR_INPUT_DISABLED]:input.focus=true input.background-color=[COLOR_INPUT_ENABLED]\\\"\"",
+			"O" = "ooc",
+			"Ctrl+O" = "looc",
+			"T" = "say",
+			"Ctrl+T" = "whisper",
+			"M" = "me",
+			"Ctrl+M" = "subtle",
+			"Back" = "\".winset \\\"input.text=\\\"\\\"\\\"\"", // This makes it so backspace can remove default inputs
+			"Any" = "\"KeyDown \[\[*\]\]\"",
+			"Any+UP" = "\"KeyUp \[\[*\]\]\"",
+			),
+		"old_default" = list(
+			"Tab" = "\".winset \\\"mainwindow.macro=old_hotkeys map.focus=true input.background-color=[COLOR_INPUT_DISABLED]\\\"\"",
+			"Ctrl+T" = "say",
+			"Ctrl+O" = "ooc",
+			),
+		"old_hotkeys" = list(
+			"Tab" = "\".winset \\\"mainwindow.macro=old_default input.focus=true input.background-color=[COLOR_INPUT_ENABLED]\\\"\"",
+			"O" = "ooc",
+			"T" = "say",
+			"M" = "me",
+			"Back" = "\".winset \\\"input.text=\\\"\\\"\\\"\"", // This makes it so backspace can remove default inputs
+			"Any" = "\"KeyDown \[\[*\]\]\"",
+			"Any+UP" = "\"KeyUp \[\[*\]\]\"",
+			),
+		)
+
+	// Because i'm lazy and don't want to type all these out twice
+	var/list/old_default = default_macro_sets["old_default"]
+
+	var/list/static/oldmode_keys = list(
+		"North", "East", "South", "West",
+		"Northeast", "Southeast", "Northwest", "Southwest",
+		"Insert", "Delete", "Ctrl", "Alt",
+		"F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+		)
+
+	for(var/i in 1 to oldmode_keys.len)
+		var/key = oldmode_keys[i]
+		old_default[key] = "\"KeyDown [key]\""
+		old_default["[key]+UP"] = "\"KeyUp [key]\""
+
+	var/list/static/oldmode_ctrl_override_keys = list(
+		"W" = "W", "A" = "A", "S" = "S", "D" = "D", // movement
+		"1" = "1", "2" = "2", "3" = "3", "4" = "4", // intent
+		"B" = "B", // resist
+		"E" = "E", // quick equip
+		"F" = "F", // intent left
+		"G" = "G", // intent right
+		"H" = "H", // stop pulling
+		"Q" = "Q", // drop
+		"R" = "R", // throw
+		"X" = "X", // switch hands
+		"Y" = "Y", // activate item
+		"Z" = "Z", // activate item
+		)
+
+	for(var/i in 1 to oldmode_ctrl_override_keys.len)
+		var/key = oldmode_ctrl_override_keys[i]
+		var/override = oldmode_ctrl_override_keys[key]
+		old_default["Ctrl+[key]"] = "\"KeyDown [override]\""
+		old_default["Ctrl+[key]+UP"] = "\"KeyUp [override]\""
+
+	macro_sets = default_macro_sets
+
+// For initially setting up or resetting to default the movement keys
+/datum/controller/subsystem/input/proc/setup_default_movement_keys()
+	var/static/list/default_movement_keys = list(
+		"W" = NORTH, "A" = WEST, "S" = SOUTH, "D" = EAST,				// WASD
+		"North" = NORTH, "West" = WEST, "South" = SOUTH, "East" = EAST,	// Arrow keys & Numpad
+		)
+
+	movement_keys = default_movement_keys.Copy()
+
+// Badmins just wanna have fun ♪
+/datum/controller/subsystem/input/proc/refresh_client_macro_sets()
+	var/list/clients = GLOB.clients
+	for(var/i in 1 to clients.len)
+		var/client/user = clients[i]
+		user.set_macros()
+
+/datum/controller/subsystem/input/fire()
+	var/list/clients = GLOB.clients // Let's sing the list cache song
+	for(var/i in 1 to clients.len)
+		var/client/C = clients[i]
+		C.keyLoop()

code/controllers/subsystem/ipintel.dm

@@ -0,0 +1,14 @@
+SUBSYSTEM_DEF(ipintel)
+	name = "XKeyScore"
+	init_order = INIT_ORDER_XKEYSCORE
+	flags = SS_NO_FIRE
+	var/enabled = 0 //disable at round start to avoid checking reconnects
+	var/throttle = 0
+	var/errors = 0
+
+	var/list/cache = list()
+
+/datum/controller/subsystem/ipintel/Initialize(timeofday, zlevel)
+	enabled = 1
+	. = ..()
+

code/controllers/subsystem/job.dm

@@ -0,0 +1,640 @@
+SUBSYSTEM_DEF(job)
+	name = "Jobs"
+	init_order = INIT_ORDER_JOBS
+	flags = SS_NO_FIRE
+
+	var/list/occupations = list()		//List of all jobs
+	var/list/name_occupations = list()	//Dict of all jobs, keys are titles
+	var/list/type_occupations = list()	//Dict of all jobs, keys are types
+	var/list/unassigned = list()		//Players who need jobs
+	var/initial_players_to_assign = 0 	//used for checking against population caps
+
+	var/list/prioritized_jobs = list()
+	var/list/latejoin_trackers = list()	//Don't read this list, use GetLateJoinTurfs() instead
+
+	var/overflow_role = "Assistant"
+
+/datum/controller/subsystem/job/Initialize(timeofday)
+	SSmapping.HACK_LoadMapConfig()
+	if(!occupations.len)
+		SetupOccupations()
+	if(CONFIG_GET(flag/load_jobs_from_txt))
+		LoadJobs()
+	generate_selectable_species()
+	set_overflow_role(CONFIG_GET(string/overflow_job))
+	return ..()
+
+/datum/controller/subsystem/job/proc/set_overflow_role(new_overflow_role)
+	var/datum/job/new_overflow = GetJob(new_overflow_role)
+	var/cap = CONFIG_GET(number/overflow_cap)
+
+	new_overflow.spawn_positions = cap
+	new_overflow.total_positions = cap
+
+	if(new_overflow_role != overflow_role)
+		var/datum/job/old_overflow = GetJob(overflow_role)
+		old_overflow.spawn_positions = initial(old_overflow.spawn_positions)
+		old_overflow.total_positions = initial(old_overflow.total_positions)
+		overflow_role = new_overflow_role
+		JobDebug("Overflow role set to : [new_overflow_role]")
+
+/datum/controller/subsystem/job/proc/SetupOccupations(faction = "Station")
+	occupations = list()
+	var/list/all_jobs = subtypesof(/datum/job)
+	if(!all_jobs.len)
+		to_chat(world, "<span class='boldannounce'>Error setting up jobs, no job datums found</span>")
+		return 0
+
+	for(var/J in all_jobs)
+		var/datum/job/job = new J()
+		if(!job)
+			continue
+		if(job.faction != faction)
+			continue
+		if(!job.config_check())
+			continue
+		if(!job.map_check())	//Even though we initialize before mapping, this is fine because the config is loaded at new
+			testing("Removed [job.type] due to map config");
+			continue
+		occupations += job
+		name_occupations[job.title] = job
+		type_occupations[J] = job
+
+	return 1
+
+
+/datum/controller/subsystem/job/proc/GetJob(rank)
+	if(!occupations.len)
+		SetupOccupations()
+	return name_occupations[rank]
+
+/datum/controller/subsystem/job/proc/GetJobType(jobtype)
+	if(!occupations.len)
+		SetupOccupations()
+	return type_occupations[jobtype]
+
+/datum/controller/subsystem/job/proc/AssignRole(mob/dead/new_player/player, rank, latejoin = FALSE)
+	JobDebug("Running AR, Player: [player], Rank: [rank], LJ: [latejoin]")
+	if(player && player.mind && rank)
+		var/datum/job/job = GetJob(rank)
+		if(!job)
+			return FALSE
+		if(jobban_isbanned(player, rank) || QDELETED(player))
+			return FALSE
+		if(!job.player_old_enough(player.client))
+			return FALSE
+		if(job.required_playtime_remaining(player.client))
+			return FALSE
+		var/position_limit = job.total_positions
+		if(!latejoin)
+			position_limit = job.spawn_positions
+		JobDebug("Player: [player] is now Rank: [rank], JCP:[job.current_positions], JPL:[position_limit]")
+		player.mind.assigned_role = rank
+		unassigned -= player
+		job.current_positions++
+		return TRUE
+	JobDebug("AR has failed, Player: [player], Rank: [rank]")
+	return FALSE
+
+
+/datum/controller/subsystem/job/proc/FindOccupationCandidates(datum/job/job, level, flag)
+	JobDebug("Running FOC, Job: [job], Level: [level], Flag: [flag]")
+	var/list/candidates = list()
+	for(var/mob/dead/new_player/player in unassigned)
+		if(jobban_isbanned(player, job.title) || QDELETED(player))
+			JobDebug("FOC isbanned failed, Player: [player]")
+			continue
+		if(!job.player_old_enough(player.client))
+			JobDebug("FOC player not old enough, Player: [player]")
+			continue
+		if(job.required_playtime_remaining(player.client))
+			JobDebug("FOC player not enough xp, Player: [player]")
+			continue
+		if(flag && (!(flag in player.client.prefs.be_special)))
+			JobDebug("FOC flag failed, Player: [player], Flag: [flag], ")
+			continue
+		if(player.mind && job.title in player.mind.restricted_roles)
+			JobDebug("FOC incompatible with antagonist role, Player: [player]")
+			continue
+		if(player.client.prefs.GetJobDepartment(job, level) & job.flag)
+			JobDebug("FOC pass, Player: [player], Level:[level]")
+			candidates += player
+	return candidates
+
+/datum/controller/subsystem/job/proc/GiveRandomJob(mob/dead/new_player/player)
+	JobDebug("GRJ Giving random job, Player: [player]")
+	. = FALSE
+	for(var/datum/job/job in shuffle(occupations))
+		if(!job)
+			continue
+
+		if(istype(job, GetJob(SSjob.overflow_role))) // We don't want to give him assistant, that's boring!
+			continue
+
+		if(job.title in GLOB.command_positions) //If you want a command position, select it!
+			continue
+
+		if(jobban_isbanned(player, job.title) || QDELETED(player))
+			if(QDELETED(player))
+				JobDebug("GRJ isbanned failed, Player deleted")
+				break
+			JobDebug("GRJ isbanned failed, Player: [player], Job: [job.title]")
+			continue
+
+		if(!job.player_old_enough(player.client))
+			JobDebug("GRJ player not old enough, Player: [player]")
+			continue
+
+		if(job.required_playtime_remaining(player.client))
+			JobDebug("GRJ player not enough xp, Player: [player]")
+			continue
+
+		if(player.mind && job.title in player.mind.restricted_roles)
+			JobDebug("GRJ incompatible with antagonist role, Player: [player], Job: [job.title]")
+			continue
+
+		if((job.current_positions < job.spawn_positions) || job.spawn_positions == -1)
+			JobDebug("GRJ Random job given, Player: [player], Job: [job]")
+			if(AssignRole(player, job.title))
+				return TRUE
+
+/datum/controller/subsystem/job/proc/ResetOccupations()
+	JobDebug("Occupations reset.")
+	for(var/mob/dead/new_player/player in GLOB.player_list)
+		if((player) && (player.mind))
+			player.mind.assigned_role = null
+			player.mind.special_role = null
+			SSpersistence.antag_rep_change[player.ckey] = 0
+	SetupOccupations()
+	unassigned = list()
+	return
+
+
+//This proc is called before the level loop of DivideOccupations() and will try to select a head, ignoring ALL non-head preferences for every level until
+//it locates a head or runs out of levels to check
+//This is basically to ensure that there's atleast a few heads in the round
+/datum/controller/subsystem/job/proc/FillHeadPosition()
+	for(var/level = 1 to 3)
+		for(var/command_position in GLOB.command_positions)
+			var/datum/job/job = GetJob(command_position)
+			if(!job)
+				continue
+			if((job.current_positions >= job.total_positions) && job.total_positions != -1)
+				continue
+			var/list/candidates = FindOccupationCandidates(job, level)
+			if(!candidates.len)
+				continue
+			var/mob/dead/new_player/candidate = pick(candidates)
+			if(AssignRole(candidate, command_position))
+				return 1
+	return 0
+
+
+//This proc is called at the start of the level loop of DivideOccupations() and will cause head jobs to be checked before any other jobs of the same level
+//This is also to ensure we get as many heads as possible
+/datum/controller/subsystem/job/proc/CheckHeadPositions(level)
+	for(var/command_position in GLOB.command_positions)
+		var/datum/job/job = GetJob(command_position)
+		if(!job)
+			continue
+		if((job.current_positions >= job.total_positions) && job.total_positions != -1)
+			continue
+		var/list/candidates = FindOccupationCandidates(job, level)
+		if(!candidates.len)
+			continue
+		var/mob/dead/new_player/candidate = pick(candidates)
+		AssignRole(candidate, command_position)
+
+/datum/controller/subsystem/job/proc/FillAIPosition()
+	var/ai_selected = 0
+	var/datum/job/job = GetJob("AI")
+	if(!job)
+		return 0
+	for(var/i = job.total_positions, i > 0, i--)
+		for(var/level = 1 to 3)
+			var/list/candidates = list()
+			candidates = FindOccupationCandidates(job, level)
+			if(candidates.len)
+				var/mob/dead/new_player/candidate = pick(candidates)
+				if(AssignRole(candidate, "AI"))
+					ai_selected++
+					break
+	if(ai_selected)
+		return 1
+	return 0
+
+
+/** Proc DivideOccupations
+ *  fills var "assigned_role" for all ready players.
+ *  This proc must not have any side effect besides of modifying "assigned_role".
+ **/
+/datum/controller/subsystem/job/proc/DivideOccupations()
+	//Setup new player list and get the jobs list
+	JobDebug("Running DO")
+
+	//Holder for Triumvirate is stored in the SSticker, this just processes it
+	if(SSticker.triai)
+		for(var/datum/job/ai/A in occupations)
+			A.spawn_positions = 3
+		for(var/obj/effect/landmark/start/ai/secondary/S in GLOB.start_landmarks_list)
+			S.latejoin_active = TRUE
+
+	//Get the players who are ready
+	for(var/mob/dead/new_player/player in GLOB.player_list)
+		if(player.ready == PLAYER_READY_TO_PLAY && player.mind && !player.mind.assigned_role)
+			unassigned += player
+
+	initial_players_to_assign = unassigned.len
+
+	JobDebug("DO, Len: [unassigned.len]")
+	if(unassigned.len == 0)
+		return 0
+
+	//Scale number of open security officer slots to population
+	setup_officer_positions()
+
+	//Jobs will have fewer access permissions if the number of players exceeds the threshold defined in game_options.txt
+	var/mat = CONFIG_GET(number/minimal_access_threshold)
+	if(mat)
+		if(mat > unassigned.len)
+			CONFIG_SET(flag/jobs_have_minimal_access, FALSE)
+		else
+			CONFIG_SET(flag/jobs_have_minimal_access, TRUE)
+
+	//Shuffle players and jobs
+	unassigned = shuffle(unassigned)
+
+	HandleFeedbackGathering()
+
+	//People who wants to be the overflow role, sure, go on.
+	JobDebug("DO, Running Overflow Check 1")
+	var/datum/job/overflow = GetJob(SSjob.overflow_role)
+	var/list/overflow_candidates = FindOccupationCandidates(overflow, 3)
+	JobDebug("AC1, Candidates: [overflow_candidates.len]")
+	for(var/mob/dead/new_player/player in overflow_candidates)
+		JobDebug("AC1 pass, Player: [player]")
+		AssignRole(player, SSjob.overflow_role)
+		overflow_candidates -= player
+	JobDebug("DO, AC1 end")
+
+	//Select one head
+	JobDebug("DO, Running Head Check")
+	FillHeadPosition()
+	JobDebug("DO, Head Check end")
+
+	//Check for an AI
+	JobDebug("DO, Running AI Check")
+	FillAIPosition()
+	JobDebug("DO, AI Check end")
+
+	//Other jobs are now checked
+	JobDebug("DO, Running Standard Check")
+
+
+	// New job giving system by Donkie
+	// This will cause lots of more loops, but since it's only done once it shouldn't really matter much at all.
+	// Hopefully this will add more randomness and fairness to job giving.
+
+	// Loop through all levels from high to low
+	var/list/shuffledoccupations = shuffle(occupations)
+	for(var/level = 1 to 3)
+		//Check the head jobs first each level
+		CheckHeadPositions(level)
+
+		// Loop through all unassigned players
+		for(var/mob/dead/new_player/player in unassigned)
+			if(PopcapReached())
+				RejectPlayer(player)
+
+			// Loop through all jobs
+			for(var/datum/job/job in shuffledoccupations) // SHUFFLE ME BABY
+				if(!job)
+					continue
+
+				if(jobban_isbanned(player, job.title))
+					JobDebug("DO isbanned failed, Player: [player], Job:[job.title]")
+					continue
+
+				if(QDELETED(player))
+					JobDebug("DO player deleted during job ban check")
+					break
+
+				if(!job.player_old_enough(player.client))
+					JobDebug("DO player not old enough, Player: [player], Job:[job.title]")
+					continue
+
+				if(job.required_playtime_remaining(player.client))
+					JobDebug("DO player not enough xp, Player: [player], Job:[job.title]")
+					continue
+
+				if(player.mind && job.title in player.mind.restricted_roles)
+					JobDebug("DO incompatible with antagonist role, Player: [player], Job:[job.title]")
+					continue
+
+				// If the player wants that job on this level, then try give it to him.
+				if(player.client.prefs.GetJobDepartment(job, level) & job.flag)
+					// If the job isn't filled
+					if((job.current_positions < job.spawn_positions) || job.spawn_positions == -1)
+						JobDebug("DO pass, Player: [player], Level:[level], Job:[job.title]")
+						AssignRole(player, job.title)
+						unassigned -= player
+						break
+
+
+	JobDebug("DO, Handling unassigned.")
+	// Hand out random jobs to the people who didn't get any in the last check
+	// Also makes sure that they got their preference correct
+	for(var/mob/dead/new_player/player in unassigned)
+		HandleUnassigned(player)
+
+	JobDebug("DO, Handling unrejectable unassigned")
+	//Mop up people who can't leave.
+	for(var/mob/dead/new_player/player in unassigned) //Players that wanted to back out but couldn't because they're antags (can you feel the edge case?)
+		if(!GiveRandomJob(player))
+			AssignRole(player, SSjob.overflow_role) //If everything is already filled, make them an assistant
+
+	return 1
+
+//We couldn't find a job from prefs for this guy.
+/datum/controller/subsystem/job/proc/HandleUnassigned(mob/dead/new_player/player)
+	if(PopcapReached())
+		RejectPlayer(player)
+	else if(player.client.prefs.joblessrole == BEOVERFLOW)
+		var/allowed_to_be_a_loser = !jobban_isbanned(player, SSjob.overflow_role)
+		if(QDELETED(player) || !allowed_to_be_a_loser)
+			RejectPlayer(player)
+		else
+			if(!AssignRole(player, SSjob.overflow_role))
+				RejectPlayer(player)
+	else if(player.client.prefs.joblessrole == BERANDOMJOB)
+		if(!GiveRandomJob(player))
+			RejectPlayer(player)
+	else if(player.client.prefs.joblessrole == RETURNTOLOBBY)
+		RejectPlayer(player)
+	else //Something gone wrong if we got here.
+		var/message = "DO: [player] fell through handling unassigned"
+		JobDebug(message)
+		log_game(message)
+		message_admins(message)
+		RejectPlayer(player)
+//Gives the player the stuff he should have with his rank
+/datum/controller/subsystem/job/proc/EquipRank(mob/M, rank, joined_late = FALSE)
+	var/mob/dead/new_player/N
+	var/mob/living/H
+	if(!joined_late)
+		N = M
+		H = N.new_character
+	else
+		H = M
+
+	var/datum/job/job = GetJob(rank)
+
+	H.job = rank
+
+	//If we joined at roundstart we should be positioned at our workstation
+	if(!joined_late)
+		var/obj/S = null
+		for(var/obj/effect/landmark/start/sloc in GLOB.start_landmarks_list)
+			if(sloc.name != rank)
+				S = sloc //so we can revert to spawning them on top of eachother if something goes wrong
+				continue
+			if(locate(/mob/living) in sloc.loc)
+				continue
+			S = sloc
+			sloc.used = TRUE
+			break
+		if(length(GLOB.jobspawn_overrides[rank]))
+			S = pick(GLOB.jobspawn_overrides[rank])
+		if(S)
+			SendToAtom(H, S, buckle = FALSE)
+		if(!S) //if there isn't a spawnpoint send them to latejoin, if there's no latejoin go yell at your mapper
+			log_world("Couldn't find a round start spawn point for [rank]")
+			SendToLateJoin(H)
+
+
+	if(H.mind)
+		H.mind.assigned_role = rank
+
+	if(job)
+		if(!job.dresscodecompliant)// CIT CHANGE - dress code compliance
+			equip_loadout(N, H) // CIT CHANGE - allows players to spawn with loadout items
+		var/new_mob = job.equip(H, null, null, joined_late)
+		if(ismob(new_mob))
+			H = new_mob
+			if(!joined_late)
+				N.new_character = H
+			else
+				M = H
+
+		SSpersistence.antag_rep_change[M.client.ckey] += job.GetAntagRep()
+
+	to_chat(M, "<b>You are the [rank].</b>")
+	if(job)
+		to_chat(M, "<b>As the [rank] you answer directly to [job.supervisors]. Special circumstances may change this.</b>")
+		to_chat(M, "<b>To speak on your departments radio, use the :h button. To see others, look closely at your headset.</b>")
+		if(job.req_admin_notify)
+			to_chat(M, "<b>You are playing a job that is important for Game Progression. If you have to disconnect, please notify the admins via adminhelp.</b>")
+		if(job.custom_spawn_text)
+			to_chat(M, "<b>[job.custom_spawn_text]</b>")
+		if(CONFIG_GET(number/minimal_access_threshold))
+			to_chat(M, "<span class='notice'><B>As this station was initially staffed with a [CONFIG_GET(flag/jobs_have_minimal_access) ? "full crew, only your job's necessities" : "skeleton crew, additional access may"] have been added to your ID card.</B></span>")
+
+	if(job && H)
+		if(job.dresscodecompliant)// CIT CHANGE - dress code compliance
+			equip_loadout(N, H) // CIT CHANGE - allows players to spawn with loadout items
+		job.after_spawn(H, M, joined_late) // note: this happens before the mob has a key! M will always have a client, H might not.
+		equip_loadout(N, H, TRUE)//CIT CHANGE - makes players spawn with in-backpack loadout items properly. A little hacky but it works
+
+	return H
+
+
+/datum/controller/subsystem/job/proc/setup_officer_positions()
+	var/datum/job/J = SSjob.GetJob("Security Officer")
+	if(!J)
+		throw EXCEPTION("setup_officer_positions(): Security officer job is missing")
+
+	var/ssc = CONFIG_GET(number/security_scaling_coeff)
+	if(ssc > 0)
+		if(J.spawn_positions > 0)
+			var/officer_positions = min(12, max(J.spawn_positions, round(unassigned.len / ssc))) //Scale between configured minimum and 12 officers
+			JobDebug("Setting open security officer positions to [officer_positions]")
+			J.total_positions = officer_positions
+			J.spawn_positions = officer_positions
+
+	//Spawn some extra eqipment lockers if we have more than 5 officers
+	var/equip_needed = J.total_positions
+	if(equip_needed < 0) // -1: infinite available slots
+		equip_needed = 12
+	for(var/i=equip_needed-5, i>0, i--)
+		if(GLOB.secequipment.len)
+			var/spawnloc = GLOB.secequipment[1]
+			new /obj/structure/closet/secure_closet/security/sec(spawnloc)
+			GLOB.secequipment -= spawnloc
+		else //We ran out of spare locker spawns!
+			break
+
+
+/datum/controller/subsystem/job/proc/LoadJobs()
+	var/jobstext = file2text("[global.config.directory]/jobs.txt")
+	for(var/datum/job/J in occupations)
+		var/regex/jobs = new("[J.title]=(-1|\\d+),(-1|\\d+)")
+		jobs.Find(jobstext)
+		J.total_positions = text2num(jobs.group[1])
+		J.spawn_positions = text2num(jobs.group[2])
+
+/datum/controller/subsystem/job/proc/HandleFeedbackGathering()
+	for(var/datum/job/job in occupations)
+		var/high = 0 //high
+		var/medium = 0 //medium
+		var/low = 0 //low
+		var/never = 0 //never
+		var/banned = 0 //banned
+		var/young = 0 //account too young
+		for(var/mob/dead/new_player/player in GLOB.player_list)
+			if(!(player.ready == PLAYER_READY_TO_PLAY && player.mind && !player.mind.assigned_role))
+				continue //This player is not ready
+			if(jobban_isbanned(player, job.title) || QDELETED(player))
+				banned++
+				continue
+			if(!job.player_old_enough(player.client))
+				young++
+				continue
+			if(job.required_playtime_remaining(player.client))
+				young++
+				continue
+			if(player.client.prefs.GetJobDepartment(job, 1) & job.flag)
+				high++
+			else if(player.client.prefs.GetJobDepartment(job, 2) & job.flag)
+				medium++
+			else if(player.client.prefs.GetJobDepartment(job, 3) & job.flag)
+				low++
+			else never++ //not selected
+		SSblackbox.record_feedback("nested tally", "job_preferences", high, list("[job.title]", "high"))
+		SSblackbox.record_feedback("nested tally", "job_preferences", medium, list("[job.title]", "medium"))
+		SSblackbox.record_feedback("nested tally", "job_preferences", low, list("[job.title]", "low"))
+		SSblackbox.record_feedback("nested tally", "job_preferences", never, list("[job.title]", "never"))
+		SSblackbox.record_feedback("nested tally", "job_preferences", banned, list("[job.title]", "banned"))
+		SSblackbox.record_feedback("nested tally", "job_preferences", young, list("[job.title]", "young"))
+
+/datum/controller/subsystem/job/proc/PopcapReached()
+	var/hpc = CONFIG_GET(number/hard_popcap)
+	var/epc = CONFIG_GET(number/extreme_popcap)
+	if(hpc || epc)
+		var/relevent_cap = max(hpc, epc)
+		if((initial_players_to_assign - unassigned.len) >= relevent_cap)
+			return 1
+	return 0
+
+/datum/controller/subsystem/job/proc/RejectPlayer(mob/dead/new_player/player)
+	if(player.mind && player.mind.special_role)
+		return
+	if(PopcapReached())
+		JobDebug("Popcap overflow Check observer located, Player: [player]")
+	JobDebug("Player rejected :[player]")
+	to_chat(player, "<b>You have failed to qualify for any job you desired.</b>")
+	unassigned -= player
+	player.ready = PLAYER_NOT_READY
+
+
+/datum/controller/subsystem/job/Recover()
+	set waitfor = FALSE
+	var/oldjobs = SSjob.occupations
+	sleep(20)
+	for (var/datum/job/J in oldjobs)
+		INVOKE_ASYNC(src, .proc/RecoverJob, J)
+
+/datum/controller/subsystem/job/proc/RecoverJob(datum/job/J)
+	var/datum/job/newjob = GetJob(J.title)
+	if (!istype(newjob))
+		return
+	newjob.total_positions = J.total_positions
+	newjob.spawn_positions = J.spawn_positions
+	newjob.current_positions = J.current_positions
+
+/datum/controller/subsystem/job/proc/SendToAtom(mob/M, atom/A, buckle)
+	if(buckle && isliving(M) && istype(A, /obj/structure/chair))
+		var/obj/structure/chair/C = A
+		if(C.buckle_mob(M, FALSE, FALSE))
+			return
+	M.forceMove(get_turf(A))
+
+/datum/controller/subsystem/job/proc/SendToLateJoin(mob/M, buckle = TRUE)
+	if(M.mind && M.mind.assigned_role && length(GLOB.jobspawn_overrides[M.mind.assigned_role])) //We're doing something special today.
+		SendToAtom(M,pick(GLOB.jobspawn_overrides[M.mind.assigned_role]),FALSE)
+		return
+
+	if(latejoin_trackers.len)
+		SendToAtom(M, pick(latejoin_trackers), buckle)
+	else
+		//bad mojo
+		var/area/shuttle/arrival/A = GLOB.areas_by_type[/area/shuttle/arrival]
+		if(A)
+			//first check if we can find a chair
+			var/obj/structure/chair/C = locate() in A
+			if(C)
+				SendToAtom(M, C, buckle)
+				return
+			else	//last hurrah
+				var/list/avail = list()
+				for(var/turf/T in A)
+					if(!is_blocked_turf(T, TRUE))
+						avail += T
+				if(avail.len)
+					SendToAtom(M, pick(avail), FALSE)
+					return
+
+		//pick an open spot on arrivals and dump em
+		var/list/arrivals_turfs = shuffle(get_area_turfs(/area/shuttle/arrival))
+		if(arrivals_turfs.len)
+			for(var/turf/T in arrivals_turfs)
+				if(!is_blocked_turf(T, TRUE))
+					SendToAtom(M, T, FALSE)
+					return
+			//last chance, pick ANY spot on arrivals and dump em
+			SendToAtom(M, arrivals_turfs[1], FALSE)
+		else
+			var/msg = "Unable to send mob [M] to late join!"
+			message_admins(msg)
+			CRASH(msg)
+
+
+///////////////////////////////////
+//Keeps track of all living heads//
+///////////////////////////////////
+/datum/controller/subsystem/job/proc/get_living_heads()
+	. = list()
+	for(var/mob/living/carbon/human/player in GLOB.alive_mob_list)
+		if(player.stat != DEAD && player.mind && (player.mind.assigned_role in GLOB.command_positions))
+			. |= player.mind
+
+
+////////////////////////////
+//Keeps track of all heads//
+////////////////////////////
+/datum/controller/subsystem/job/proc/get_all_heads()
+	. = list()
+	for(var/i in GLOB.mob_list)
+		var/mob/player = i
+		if(player.mind && (player.mind.assigned_role in GLOB.command_positions))
+			. |= player.mind
+
+//////////////////////////////////////////////
+//Keeps track of all living security members//
+//////////////////////////////////////////////
+/datum/controller/subsystem/job/proc/get_living_sec()
+	. = list()
+	for(var/mob/living/carbon/human/player in GLOB.carbon_list)
+		if(player.stat != DEAD && player.mind && (player.mind.assigned_role in GLOB.security_positions))
+			. |= player.mind
+
+////////////////////////////////////////
+//Keeps track of all  security members//
+////////////////////////////////////////
+/datum/controller/subsystem/job/proc/get_all_sec()
+	. = list()
+	for(var/mob/living/carbon/human/player in GLOB.carbon_list)
+		if(player.mind && (player.mind.assigned_role in GLOB.security_positions))
+			. |= player.mind
+
+/datum/controller/subsystem/job/proc/JobDebug(message)
+	log_job_debug(message)

code/controllers/subsystem/jukeboxes.dm

@@ -0,0 +1,102 @@
+SUBSYSTEM_DEF(jukeboxes)
+	name = "Jukeboxes"
+	wait = 5
+	var/list/songs = list()
+	var/list/activejukeboxes = list()
+
+/datum/track
+	var/song_name = "generic"
+	var/song_path = null
+	var/song_length = 0
+	var/song_beat = 0
+	var/song_associated_id = null
+
+/datum/track/New(name, path, length, beat, assocID)
+	song_name = name
+	song_path = path
+	song_length = length
+	song_beat = beat
+	song_associated_id = assocID
+
+/datum/controller/subsystem/jukeboxes/proc/addjukebox(obj/jukebox, datum/track/T, jukefalloff = 1)
+	if(!istype(T))
+		CRASH("[src] tried to play a song with a nonexistant track")
+	var/channeltoreserve = CHANNEL_JUKEBOX_START + activejukeboxes.len - 1
+	if(channeltoreserve > CHANNEL_JUKEBOX)
+		return FALSE
+	activejukeboxes.len++
+	activejukeboxes[activejukeboxes.len] = list(T, channeltoreserve, jukebox, jukefalloff)
+	return activejukeboxes.len
+
+/datum/controller/subsystem/jukeboxes/proc/removejukebox(IDtoremove)
+	if(islist(activejukeboxes[IDtoremove]))
+		for(var/mob/M in GLOB.player_list)
+			if(!M.client)
+				continue
+			M.stop_sound_channel(activejukeboxes[IDtoremove][2])
+		activejukeboxes.Cut(IDtoremove, IDtoremove+1)
+		return TRUE
+	else
+		to_chat(world, "<span class='warning'>If you see this, screenshot it and send it to a dev. Tried to remove jukebox with invalid ID</span>")
+
+/datum/controller/subsystem/jukeboxes/proc/findjukeboxindex(obj/jukebox)
+	if(activejukeboxes.len)
+		for(var/list/jukeinfo in activejukeboxes)
+			if(jukebox in jukeinfo)
+				return activejukeboxes.Find(jukeinfo)
+	return FALSE
+
+/datum/controller/subsystem/jukeboxes/Initialize()
+	var/list/tracks = flist("config/jukebox_music/sounds/")
+	for(var/S in tracks)
+		var/datum/track/T = new()
+		T.song_path = file("config/jukebox_music/sounds/[S]")
+		var/list/L = splittext(S,"+")
+		T.song_name = L[1]
+		T.song_length = text2num(L[2])
+		T.song_beat = text2num(L[3])
+		T.song_associated_id = L[4]
+		songs |= T
+	return ..()
+
+/datum/controller/subsystem/jukeboxes/fire()
+	if(!activejukeboxes.len)
+		return
+	for(var/list/jukeinfo in activejukeboxes)
+		if(!jukeinfo.len)
+			to_chat(world, "<span class='warning'>If you see this, screenshot it and send it to a dev. Active jukebox without any associated metadata</span>")
+		var/datum/track/juketrack = jukeinfo[1]
+		if(!istype(juketrack))
+			to_chat(world, "<span class='warning'>If you see this, screenshot it and send it to a dev. After jukebox track grabbing</span>")
+			continue
+		var/obj/jukebox = jukeinfo[3]
+		if(!istype(jukebox))
+			to_chat(world, "<span class='warning'>If you see this, screenshot it and send it to a dev. Nonexistant or invalid jukebox in active jukebox list")
+			continue
+		var/sound/song_played = sound(juketrack.song_path)
+		var/area/currentarea = get_area(jukebox)
+		var/turf/currentturf = get_turf(jukebox)
+		var/list/hearerscache = hearers(7, jukebox)
+
+		song_played.falloff = jukeinfo[4]
+
+		for(var/mob/M in GLOB.player_list)
+			if(!M.client)
+				continue
+			if(!(M.client.prefs.toggles & SOUND_INSTRUMENTS))
+				M.stop_sound_channel(jukeinfo[2])
+				continue
+
+			var/inrange = FALSE
+			if(jukebox.z == M.z)	//todo - expand this to work with mining planet z-levels when robust jukebox audio gets merged to master
+				song_played.status = SOUND_UPDATE
+				if(get_area(M) == currentarea)
+					inrange = TRUE
+				else if(M in hearerscache)
+					inrange = TRUE
+			else
+				song_played.status = SOUND_MUTE | SOUND_UPDATE	//Setting volume = 0 doesn't let the sound properties update at all, which is lame.
+
+			M.playsound_local(currentturf, null, 100, channel = jukeinfo[2], S = song_played, envwet = (inrange ? -250 : 0), envdry = (inrange ? 0 : -10000))
+			CHECK_TICK
+	return

code/controllers/subsystem/language.dm

@@ -0,0 +1,18 @@
+SUBSYSTEM_DEF(language)
+	name = "Language"
+	init_order = INIT_ORDER_LANGUAGE
+	flags = SS_NO_FIRE
+
+/datum/controller/subsystem/language/Initialize(timeofday)
+	for(var/L in subtypesof(/datum/language))
+		var/datum/language/language = L
+		if(!initial(language.key))
+			continue
+
+		GLOB.all_languages += language
+
+		var/datum/language/instance = new language
+
+		GLOB.language_datum_instances[language] = instance
+
+	return ..()

code/controllers/subsystem/lighting.dm

@@ -0,0 +1,88 @@
+GLOBAL_LIST_EMPTY(lighting_update_lights) // List of lighting sources  queued for update.
+GLOBAL_LIST_EMPTY(lighting_update_corners) // List of lighting corners  queued for update.
+GLOBAL_LIST_EMPTY(lighting_update_objects) // List of lighting objects queued for update.
+
+SUBSYSTEM_DEF(lighting)
+	name = "Lighting"
+	wait = 2
+	init_order = INIT_ORDER_LIGHTING
+	flags = SS_TICKER
+
+/datum/controller/subsystem/lighting/stat_entry()
+	..("L:[GLOB.lighting_update_lights.len]|C:[GLOB.lighting_update_corners.len]|O:[GLOB.lighting_update_objects.len]")
+
+
+/datum/controller/subsystem/lighting/Initialize(timeofday)
+	if(!initialized)
+		if (CONFIG_GET(flag/starlight))
+			for(var/I in GLOB.sortedAreas)
+				var/area/A = I
+				if (A.dynamic_lighting == DYNAMIC_LIGHTING_IFSTARLIGHT)
+					A.luminosity = 0
+
+		create_all_lighting_objects()
+		initialized = TRUE
+
+	fire(FALSE, TRUE)
+
+	return ..()
+
+/datum/controller/subsystem/lighting/fire(resumed, init_tick_checks)
+	MC_SPLIT_TICK_INIT(3)
+	if(!init_tick_checks)
+		MC_SPLIT_TICK
+	var/i = 0
+	for (i in 1 to GLOB.lighting_update_lights.len)
+		var/datum/light_source/L = GLOB.lighting_update_lights[i]
+
+		L.update_corners()
+
+		L.needs_update = LIGHTING_NO_UPDATE
+
+		if(init_tick_checks)
+			CHECK_TICK
+		else if (MC_TICK_CHECK)
+			break
+	if (i)
+		GLOB.lighting_update_lights.Cut(1, i+1)
+		i = 0
+
+	if(!init_tick_checks)
+		MC_SPLIT_TICK
+
+	for (i in 1 to GLOB.lighting_update_corners.len)
+		var/datum/lighting_corner/C = GLOB.lighting_update_corners[i]
+
+		C.update_objects()
+		C.needs_update = FALSE
+		if(init_tick_checks)
+			CHECK_TICK
+		else if (MC_TICK_CHECK)
+			break
+	if (i)
+		GLOB.lighting_update_corners.Cut(1, i+1)
+		i = 0
+
+
+	if(!init_tick_checks)
+		MC_SPLIT_TICK
+
+	for (i in 1 to GLOB.lighting_update_objects.len)
+		var/atom/movable/lighting_object/O = GLOB.lighting_update_objects[i]
+
+		if (QDELETED(O))
+			continue
+
+		O.update()
+		O.needs_update = FALSE
+		if(init_tick_checks)
+			CHECK_TICK
+		else if (MC_TICK_CHECK)
+			break
+	if (i)
+		GLOB.lighting_update_objects.Cut(1, i+1)
+
+
+/datum/controller/subsystem/lighting/Recover()
+	initialized = SSlighting.initialized
+	..()

code/controllers/subsystem/machines.dm

@@ -0,0 +1,64 @@
+SUBSYSTEM_DEF(machines)
+	name = "Machines"
+	init_order = INIT_ORDER_MACHINES
+	flags = SS_KEEP_TIMING
+	var/list/processing = list()
+	var/list/currentrun = list()
+	var/list/powernets = list()
+
+/datum/controller/subsystem/machines/Initialize()
+	makepowernets()
+	fire()
+	return ..()
+
+/datum/controller/subsystem/machines/proc/makepowernets()
+	for(var/datum/powernet/PN in powernets)
+		qdel(PN)
+	powernets.Cut()
+
+	for(var/obj/structure/cable/PC in GLOB.cable_list)
+		if(!PC.powernet)
+			var/datum/powernet/NewPN = new()
+			NewPN.add_cable(PC)
+			propagate_network(PC,PC.powernet)
+
+/datum/controller/subsystem/machines/stat_entry()
+	..("M:[processing.len]|PN:[powernets.len]")
+
+
+/datum/controller/subsystem/machines/fire(resumed = 0)
+	if (!resumed)
+		for(var/datum/powernet/Powernet in powernets)
+			Powernet.reset() //reset the power state.
+		src.currentrun = processing.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	var/seconds = wait * 0.1
+	while(currentrun.len)
+		var/obj/machinery/thing = currentrun[currentrun.len]
+		currentrun.len--
+		if(!QDELETED(thing) && thing.process(seconds) != PROCESS_KILL)
+			if(thing.use_power)
+				thing.auto_use_power() //add back the power state
+		else
+			processing -= thing
+			if (!QDELETED(thing))
+				thing.datum_flags &= ~DF_ISPROCESSING
+		if (MC_TICK_CHECK)
+			return
+
+/datum/controller/subsystem/machines/proc/setup_template_powernets(list/cables)
+	for(var/A in cables)
+		var/obj/structure/cable/PC = A
+		if(!PC.powernet)
+			var/datum/powernet/NewPN = new()
+			NewPN.add_cable(PC)
+			propagate_network(PC,PC.powernet)
+
+/datum/controller/subsystem/machines/Recover()
+	if (istype(SSmachines.processing))
+		processing = SSmachines.processing
+	if (istype(SSmachines.powernets))
+		powernets = SSmachines.powernets

code/controllers/subsystem/mapping.dm

@@ -0,0 +1,506 @@
+SUBSYSTEM_DEF(mapping)
+	name = "Mapping"
+	init_order = INIT_ORDER_MAPPING
+	flags = SS_NO_FIRE
+
+	var/list/nuke_tiles = list()
+	var/list/nuke_threats = list()
+
+	var/datum/map_config/config
+	var/datum/map_config/next_map_config
+
+	var/list/map_templates = list()
+
+	var/list/ruins_templates = list()
+	var/list/space_ruins_templates = list()
+	var/list/lava_ruins_templates = list()
+
+	var/list/shuttle_templates = list()
+	var/list/shelter_templates = list()
+
+	var/list/areas_in_z = list()
+
+	var/loading_ruins = FALSE
+	var/list/turf/unused_turfs = list()				//Not actually unused turfs they're unused but reserved for use for whatever requests them. "[zlevel_of_turf]" = list(turfs)
+	var/list/datum/turf_reservations		//list of turf reservations
+	var/list/used_turfs = list()				//list of turf = datum/turf_reservation
+
+	var/clearing_reserved_turfs = FALSE
+
+	// Z-manager stuff
+	var/station_start  // should only be used for maploading-related tasks
+	var/space_levels_so_far = 0
+	var/list/z_list
+	var/datum/space_level/transit
+	var/datum/space_level/empty_space
+
+//dlete dis once #39770 is resolved
+/datum/controller/subsystem/mapping/proc/HACK_LoadMapConfig()
+	if(!config)
+#ifdef FORCE_MAP
+		config = load_map_config(FORCE_MAP)
+#else
+		config = load_map_config(error_if_missing = FALSE)
+#endif
+
+/datum/controller/subsystem/mapping/Initialize(timeofday)
+	HACK_LoadMapConfig()
+	if(initialized)
+		return
+	if(config.defaulted)
+		var/old_config = config
+		config = global.config.defaultmap
+		if(!config || config.defaulted)
+			to_chat(world, "<span class='boldannounce'>Unable to load next or default map config, defaulting to Box Station</span>")
+			config = old_config
+	loadWorld()
+	repopulate_sorted_areas()
+	process_teleport_locs()			//Sets up the wizard teleport locations
+	preloadTemplates()
+#ifndef LOWMEMORYMODE
+	// Create space ruin levels
+	while (space_levels_so_far < config.space_ruin_levels)
+		++space_levels_so_far
+		add_new_zlevel("Empty Area [space_levels_so_far]", ZTRAITS_SPACE)
+	// and one level with no ruins
+	for (var/i in 1 to config.space_empty_levels)
+		++space_levels_so_far
+		empty_space = add_new_zlevel("Empty Area [space_levels_so_far]", list(ZTRAIT_LINKAGE = CROSSLINKED))
+	// and the transit level
+	transit = add_new_zlevel("Transit/Reserved", list(ZTRAIT_RESERVED = TRUE))
+
+	// Pick a random away mission.
+	if(CONFIG_GET(flag/roundstart_away))
+		createRandomZlevel()
+
+
+	// Generate mining ruins
+	loading_ruins = TRUE
+	var/list/lava_ruins = levels_by_trait(ZTRAIT_LAVA_RUINS)
+	if (lava_ruins.len)
+		seedRuins(lava_ruins, CONFIG_GET(number/lavaland_budget), /area/lavaland/surface/outdoors/unexplored, lava_ruins_templates)
+		for (var/lava_z in lava_ruins)
+			spawn_rivers(lava_z)
+
+	// Generate deep space ruins
+	var/list/space_ruins = levels_by_trait(ZTRAIT_SPACE_RUINS)
+	if (space_ruins.len)
+		seedRuins(space_ruins, CONFIG_GET(number/space_budget), /area/space, space_ruins_templates)
+	loading_ruins = FALSE
+#endif
+	repopulate_sorted_areas()
+	// Set up Z-level transitions.
+	setup_map_transitions()
+	generate_station_area_list()
+	initialize_reserved_level()
+	return ..()
+
+/* Nuke threats, for making the blue tiles on the station go RED
+   Used by the AI doomsday and the self destruct nuke.
+*/
+
+/datum/controller/subsystem/mapping/proc/wipe_reservations(wipe_safety_delay = 100)
+	if(clearing_reserved_turfs || !initialized)			//in either case this is just not needed.
+		return
+	clearing_reserved_turfs = TRUE
+	SSshuttle.transit_requesters.Cut()
+	message_admins("Clearing dynamic reservation space.")
+	var/list/obj/docking_port/mobile/in_transit = list()
+	for(var/i in SSshuttle.transit)
+		var/obj/docking_port/stationary/transit/T = i
+		if(!istype(T))
+			continue
+		in_transit[T] = T.get_docked()
+	var/go_ahead = world.time + wipe_safety_delay
+	if(in_transit.len)
+		message_admins("Shuttles in transit detected. Attempting to fast travel. Timeout is [wipe_safety_delay/10] seconds.")
+	var/list/cleared = list()
+	for(var/i in in_transit)
+		INVOKE_ASYNC(src, .proc/safety_clear_transit_dock, i, in_transit[i], cleared)
+	UNTIL((go_ahead < world.time) || (cleared.len == in_transit.len))
+	do_wipe_turf_reservations()
+	clearing_reserved_turfs = FALSE
+
+/datum/controller/subsystem/mapping/proc/safety_clear_transit_dock(obj/docking_port/stationary/transit/T, obj/docking_port/mobile/M, list/returning)
+	M.setTimer(0)
+	var/error = M.initiate_docking(M.destination, M.preferred_direction)
+	if(!error)
+		returning += M
+		qdel(T, TRUE)
+
+/datum/controller/subsystem/mapping/proc/add_nuke_threat(datum/nuke)
+	nuke_threats[nuke] = TRUE
+	check_nuke_threats()
+
+/datum/controller/subsystem/mapping/proc/remove_nuke_threat(datum/nuke)
+	nuke_threats -= nuke
+	check_nuke_threats()
+
+/datum/controller/subsystem/mapping/proc/check_nuke_threats()
+	for(var/datum/d in nuke_threats)
+		if(!istype(d) || QDELETED(d))
+			nuke_threats -= d
+
+	for(var/N in nuke_tiles)
+		var/turf/open/floor/circuit/C = N
+		C.update_icon()
+
+/datum/controller/subsystem/mapping/Recover()
+	flags |= SS_NO_INIT
+	initialized = SSmapping.initialized
+	map_templates = SSmapping.map_templates
+	ruins_templates = SSmapping.ruins_templates
+	space_ruins_templates = SSmapping.space_ruins_templates
+	lava_ruins_templates = SSmapping.lava_ruins_templates
+	shuttle_templates = SSmapping.shuttle_templates
+	shelter_templates = SSmapping.shelter_templates
+	unused_turfs = SSmapping.unused_turfs
+	turf_reservations = SSmapping.turf_reservations
+	used_turfs = SSmapping.used_turfs
+
+	config = SSmapping.config
+	next_map_config = SSmapping.next_map_config
+
+	clearing_reserved_turfs = SSmapping.clearing_reserved_turfs
+
+	z_list = SSmapping.z_list
+
+#define INIT_ANNOUNCE(X) to_chat(world, "<span class='boldannounce'>[X]</span>"); log_world(X)
+/datum/controller/subsystem/mapping/proc/LoadGroup(list/errorList, name, path, files, list/traits, list/default_traits, silent = FALSE)
+	. = list()
+	var/start_time = REALTIMEOFDAY
+
+	if (!islist(files))  // handle single-level maps
+		files = list(files)
+
+	// check that the total z count of all maps matches the list of traits
+	var/total_z = 0
+	var/list/parsed_maps = list()
+	for (var/file in files)
+		var/full_path = "_maps/[path]/[file]"
+		var/datum/parsed_map/pm = new(file(full_path))
+		var/bounds = pm?.bounds
+		if (!bounds)
+			errorList |= full_path
+			continue
+		parsed_maps[pm] = total_z  // save the start Z of this file
+		total_z += bounds[MAP_MAXZ] - bounds[MAP_MINZ] + 1
+
+	if (!length(traits))  // null or empty - default
+		for (var/i in 1 to total_z)
+			traits += list(default_traits)
+	else if (total_z != traits.len)  // mismatch
+		INIT_ANNOUNCE("WARNING: [traits.len] trait sets specified for [total_z] z-levels in [path]!")
+		if (total_z < traits.len)  // ignore extra traits
+			traits.Cut(total_z + 1)
+		while (total_z > traits.len)  // fall back to defaults on extra levels
+			traits += list(default_traits)
+
+	// preload the relevant space_level datums
+	var/start_z = world.maxz + 1
+	var/i = 0
+	for (var/level in traits)
+		add_new_zlevel("[name][i ? " [i + 1]" : ""]", level)
+		++i
+
+	// load the maps
+	for (var/P in parsed_maps)
+		var/datum/parsed_map/pm = P
+		if (!pm.load(1, 1, start_z + parsed_maps[P], no_changeturf = TRUE))
+			errorList |= pm.original_path
+	if(!silent)
+		INIT_ANNOUNCE("Loaded [name] in [(REALTIMEOFDAY - start_time)/10]s!")
+	return parsed_maps
+
+/datum/controller/subsystem/mapping/proc/loadWorld()
+	//if any of these fail, something has gone horribly, HORRIBLY, wrong
+	var/list/FailedZs = list()
+
+	// ensure we have space_level datums for compiled-in maps
+	InitializeDefaultZLevels()
+
+	// load the station
+	station_start = world.maxz + 1
+	INIT_ANNOUNCE("Loading [config.map_name]...")
+	LoadGroup(FailedZs, "Station", config.map_path, config.map_file, config.traits, ZTRAITS_STATION)
+
+	if(SSdbcore.Connect())
+		var/datum/DBQuery/query_round_map_name = SSdbcore.NewQuery("UPDATE [format_table_name("round")] SET map_name = '[config.map_name]' WHERE id = [GLOB.round_id]")
+		query_round_map_name.Execute()
+		qdel(query_round_map_name)
+
+#ifndef LOWMEMORYMODE
+	// TODO: remove this when the DB is prepared for the z-levels getting reordered
+	while (world.maxz < (5 - 1) && space_levels_so_far < config.space_ruin_levels)
+		++space_levels_so_far
+		add_new_zlevel("Empty Area [space_levels_so_far]", ZTRAITS_SPACE)
+
+	// load mining
+	if(config.minetype == "lavaland")
+		LoadGroup(FailedZs, "Lavaland", "map_files/Mining", "Lavaland.dmm", default_traits = ZTRAITS_LAVALAND)
+	else if (!isnull(config.minetype))
+		INIT_ANNOUNCE("WARNING: An unknown minetype '[config.minetype]' was set! This is being ignored! Update the maploader code!")
+#endif
+
+	if(LAZYLEN(FailedZs))	//but seriously, unless the server's filesystem is messed up this will never happen
+		var/msg = "RED ALERT! The following map files failed to load: [FailedZs[1]]"
+		if(FailedZs.len > 1)
+			for(var/I in 2 to FailedZs.len)
+				msg += ", [FailedZs[I]]"
+		msg += ". Yell at your server host!"
+		INIT_ANNOUNCE(msg)
+#undef INIT_ANNOUNCE
+
+GLOBAL_LIST_EMPTY(the_station_areas)
+
+/datum/controller/subsystem/mapping/proc/generate_station_area_list()
+	var/list/station_areas_blacklist = typecacheof(list(/area/space, /area/mine, /area/ruin, /area/asteroid/nearstation))
+	for(var/area/A in world)
+		if (is_type_in_typecache(A, station_areas_blacklist))
+			continue
+		if (!A.contents.len || !A.unique)
+			continue
+		var/turf/picked = A.contents[1]
+		if (is_station_level(picked.z))
+			GLOB.the_station_areas += A.type
+
+	if(!GLOB.the_station_areas.len)
+		log_world("ERROR: Station areas list failed to generate!")
+
+/datum/controller/subsystem/mapping/proc/maprotate()
+	var/players = GLOB.clients.len
+	var/list/mapvotes = list()
+	//count votes
+	var/amv = CONFIG_GET(flag/allow_map_voting)
+	if(amv)
+		for (var/client/c in GLOB.clients)
+			var/vote = c.prefs.preferred_map
+			if (!vote)
+				if (global.config.defaultmap)
+					mapvotes[global.config.defaultmap.map_name] += 1
+				continue
+			mapvotes[vote] += 1
+	else
+		for(var/M in global.config.maplist)
+			mapvotes[M] = 1
+
+	//filter votes
+	for (var/map in mapvotes)
+		if (!map)
+			mapvotes.Remove(map)
+		if (!(map in global.config.maplist))
+			mapvotes.Remove(map)
+			continue
+		var/datum/map_config/VM = global.config.maplist[map]
+		if (!VM)
+			mapvotes.Remove(map)
+			continue
+		if (VM.voteweight <= 0)
+			mapvotes.Remove(map)
+			continue
+		if (VM.config_min_users > 0 && players < VM.config_min_users)
+			mapvotes.Remove(map)
+			continue
+		if (VM.config_max_users > 0 && players > VM.config_max_users)
+			mapvotes.Remove(map)
+			continue
+
+		if(amv)
+			mapvotes[map] = mapvotes[map]*VM.voteweight
+
+	var/pickedmap = pickweight(mapvotes)
+	if (!pickedmap)
+		return
+	var/datum/map_config/VM = global.config.maplist[pickedmap]
+	message_admins("Randomly rotating map to [VM.map_name]")
+	. = changemap(VM)
+	if (. && VM.map_name != config.map_name)
+		to_chat(world, "<span class='boldannounce'>Map rotation has chosen [VM.map_name] for next round!</span>")
+
+/datum/controller/subsystem/mapping/proc/changemap(var/datum/map_config/VM)
+	if(!VM.MakeNextMap())
+		next_map_config = load_map_config(default_to_box = TRUE)
+		message_admins("Failed to set new map with next_map.json for [VM.map_name]! Using default as backup!")
+		return
+
+	next_map_config = VM
+	return TRUE
+
+/datum/controller/subsystem/mapping/proc/preloadTemplates(path = "_maps/templates/") //see master controller setup
+	var/list/filelist = flist(path)
+	for(var/map in filelist)
+		var/datum/map_template/T = new(path = "[path][map]", rename = "[map]")
+		map_templates[T.name] = T
+
+	preloadRuinTemplates()
+	preloadShuttleTemplates()
+	preloadShelterTemplates()
+
+/datum/controller/subsystem/mapping/proc/preloadRuinTemplates()
+	// Still supporting bans by filename
+	var/list/banned = generateMapList("[global.config.directory]/lavaruinblacklist.txt")
+	banned += generateMapList("[global.config.directory]/spaceruinblacklist.txt")
+
+	for(var/item in sortList(subtypesof(/datum/map_template/ruin), /proc/cmp_ruincost_priority))
+		var/datum/map_template/ruin/ruin_type = item
+		// screen out the abstract subtypes
+		if(!initial(ruin_type.id))
+			continue
+		var/datum/map_template/ruin/R = new ruin_type()
+
+		if(banned.Find(R.mappath))
+			continue
+
+		map_templates[R.name] = R
+		ruins_templates[R.name] = R
+
+		if(istype(R, /datum/map_template/ruin/lavaland))
+			lava_ruins_templates[R.name] = R
+		else if(istype(R, /datum/map_template/ruin/space))
+			space_ruins_templates[R.name] = R
+
+/datum/controller/subsystem/mapping/proc/preloadShuttleTemplates()
+	var/list/unbuyable = generateMapList("[global.config.directory]/unbuyableshuttles.txt")
+
+	for(var/item in subtypesof(/datum/map_template/shuttle))
+		var/datum/map_template/shuttle/shuttle_type = item
+		if(!(initial(shuttle_type.suffix)))
+			continue
+
+		var/datum/map_template/shuttle/S = new shuttle_type()
+		if(unbuyable.Find(S.mappath))
+			S.can_be_bought = FALSE
+
+		shuttle_templates[S.shuttle_id] = S
+		map_templates[S.shuttle_id] = S
+
+/datum/controller/subsystem/mapping/proc/preloadShelterTemplates()
+	for(var/item in subtypesof(/datum/map_template/shelter))
+		var/datum/map_template/shelter/shelter_type = item
+		if(!(initial(shelter_type.mappath)))
+			continue
+		var/datum/map_template/shelter/S = new shelter_type()
+
+		shelter_templates[S.shelter_id] = S
+		map_templates[S.shelter_id] = S
+
+//Manual loading of away missions.
+/client/proc/admin_away()
+	set name = "Load Away Mission"
+	set category = "Fun"
+
+	if(!holder ||!check_rights(R_FUN))
+		return
+
+
+	if(!GLOB.the_gateway)
+		if(alert("There's no home gateway on the station. You sure you want to continue ?", "Uh oh", "Yes", "No") != "Yes")
+			return
+
+	var/list/possible_options = GLOB.potentialRandomZlevels + "Custom"
+	var/away_name
+	var/datum/space_level/away_level
+
+	var/answer = input("What kind ? ","Away") as null|anything in possible_options
+	switch(answer)
+		if("Custom")
+			var/mapfile = input("Pick file:", "File") as null|file
+			if(!mapfile)
+				return
+			away_name = "[mapfile] custom"
+			to_chat(usr,"<span class='notice'>Loading [away_name]...</span>")
+			var/datum/map_template/template = new(mapfile, "Away Mission")
+			away_level = template.load_new_z()
+		else
+			if(answer in GLOB.potentialRandomZlevels)
+				away_name = answer
+				to_chat(usr,"<span class='notice'>Loading [away_name]...</span>")
+				var/datum/map_template/template = new(away_name, "Away Mission")
+				away_level = template.load_new_z()
+			else
+				return
+
+	message_admins("Admin [key_name_admin(usr)] has loaded [away_name] away mission.")
+	log_admin("Admin [key_name(usr)] has loaded [away_name] away mission.")
+	if(!away_level)
+		message_admins("Loading [away_name] failed!")
+		return
+
+
+	if(GLOB.the_gateway)
+		//Link any found away gate with station gate
+		var/obj/machinery/gateway/centeraway/new_gate
+		for(var/obj/machinery/gateway/centeraway/G in GLOB.machines)
+			if(G.z == away_level.z_value) //I'll have to refactor gateway shitcode before multi-away support.
+				new_gate = G
+				break
+		//Link station gate with away gate and remove wait time.
+		GLOB.the_gateway.awaygate = new_gate
+		GLOB.the_gateway.wait = world.time
+
+/datum/controller/subsystem/mapping/proc/RequestBlockReservation(width, height, z, type = /datum/turf_reservation, turf_type_override, border_type_override)
+	UNTIL(initialized && !clearing_reserved_turfs)
+	var/datum/turf_reservation/reserve = new type
+	if(turf_type_override)
+		reserve.turf_type = turf_type_override
+	if(border_type_override)
+		reserve.borderturf = border_type_override
+	if(!z)
+		for(var/i in levels_by_trait(ZTRAIT_RESERVED))
+			if(reserve.Reserve(width, height, i))
+				return reserve
+	else
+		if(!level_trait(z, ZTRAIT_RESERVED))
+			qdel(reserve)
+			return
+		else
+			if(reserve.Reserve(width, height, z))
+				return reserve
+	QDEL_NULL(reserve)
+
+//This is not for wiping reserved levels, use wipe_reservations() for that.
+/datum/controller/subsystem/mapping/proc/initialize_reserved_level()
+	UNTIL(!clearing_reserved_turfs)				//regardless, lets add a check just in case.
+	clearing_reserved_turfs = TRUE			//This operation will likely clear any existing reservations, so lets make sure nothing tries to make one while we're doing it.
+	for(var/i in levels_by_trait(ZTRAIT_RESERVED))
+		var/turf/A = get_turf(locate(SHUTTLE_TRANSIT_BORDER,SHUTTLE_TRANSIT_BORDER,i))
+		var/turf/B = get_turf(locate(world.maxx - SHUTTLE_TRANSIT_BORDER,world.maxy - SHUTTLE_TRANSIT_BORDER,i))
+		var/block = block(A, B)
+		for(var/t in block)
+			// No need to empty() these, because it's world init and they're
+			// already /turf/open/space/basic.
+			var/turf/T = t
+			T.flags_1 |= UNUSED_RESERVATION_TURF_1
+		unused_turfs["[i]"] = block
+	clearing_reserved_turfs = FALSE
+
+/datum/controller/subsystem/mapping/proc/reserve_turfs(list/turfs)
+	for(var/i in turfs)
+		var/turf/T = i
+		T.empty(RESERVED_TURF_TYPE, RESERVED_TURF_TYPE, null, TRUE)
+		LAZYINITLIST(unused_turfs["[T.z]"])
+		unused_turfs["[T.z]"] |= T
+		T.flags_1 |= UNUSED_RESERVATION_TURF_1
+		CHECK_TICK
+
+//DO NOT CALL THIS PROC DIRECTLY, CALL wipe_reservations().
+/datum/controller/subsystem/mapping/proc/do_wipe_turf_reservations()
+	UNTIL(initialized)							//This proc is for AFTER init, before init turf reservations won't even exist and using this will likely break things.
+	for(var/i in turf_reservations)
+		var/datum/turf_reservation/TR = i
+		if(!QDELETED(TR))
+			qdel(TR, TRUE)
+	UNSETEMPTY(turf_reservations)
+	var/list/clearing = list()
+	for(var/l in unused_turfs)			//unused_turfs is a assoc list by z = list(turfs)
+		if(islist(unused_turfs[l]))
+			clearing |= unused_turfs[l]
+	clearing |= used_turfs		//used turfs is an associative list, BUT, reserve_turfs() can still handle it. If the code above works properly, this won't even be needed as the turfs would be freed already.
+	unused_turfs.Cut()
+	used_turfs.Cut()
+	reserve_turfs(clearing)
+
+/datum/controller/subsystem/mapping/proc/reg_in_areas_in_z(list/areas)
+	for(var/B in areas)
+		var/area/A = B
+		A.reg_in_areas_in_z()

code/controllers/subsystem/medals.dm

@@ -0,0 +1,87 @@
+SUBSYSTEM_DEF(medals)
+	name = "Medals"
+	flags = SS_NO_FIRE
+	var/hub_enabled = FALSE
+
+/datum/controller/subsystem/medals/Initialize(timeofday)
+	if(CONFIG_GET(string/medal_hub_address) && CONFIG_GET(string/medal_hub_password))
+		hub_enabled = TRUE
+	return ..()
+
+/datum/controller/subsystem/medals/proc/UnlockMedal(medal, client/player)
+	set waitfor = FALSE
+	if(!medal || !hub_enabled)
+		return
+	if(isnull(world.SetMedal(medal, player, CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))))
+		hub_enabled = FALSE
+		log_game("MEDAL ERROR: Could not contact hub to award medal:[medal] player:[player.key]")
+		message_admins("Error! Failed to contact hub to award [medal] medal to [player.key]!")
+		return
+	to_chat(player, "<span class='greenannounce'><B>Achievement unlocked: [medal]!</B></span>")
+
+
+/datum/controller/subsystem/medals/proc/SetScore(score, client/player, increment, force)
+	set waitfor = FALSE
+	if(!score || !hub_enabled)
+		return
+
+	var/list/oldscore = GetScore(score, player, TRUE)
+	if(increment)
+		if(!oldscore[score])
+			oldscore[score] = 1
+		else
+			oldscore[score] = (text2num(oldscore[score]) + 1)
+	else
+		oldscore[score] = force
+
+	var/newscoreparam = list2params(oldscore)
+
+	if(isnull(world.SetScores(player.ckey, newscoreparam, CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))))
+		hub_enabled = FALSE
+		log_game("SCORE ERROR: Could not contact hub to set score. Score:[score] player:[player.key]")
+		message_admins("Error! Failed to contact hub to set [score] score for [player.key]!")
+
+/datum/controller/subsystem/medals/proc/GetScore(score, client/player, returnlist)
+	if(!score || !hub_enabled)
+		return
+
+	var/scoreget = world.GetScores(player.ckey, score, CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))
+	if(isnull(scoreget))
+		hub_enabled = FALSE
+		log_game("SCORE ERROR: Could not contact hub to get score. Score:[score] player:[player.key]")
+		message_admins("Error! Failed to contact hub to get score: [score] for [player.key]!")
+		return
+	. = params2list(scoreget)
+	if(!returnlist)
+		return .[score]
+
+/datum/controller/subsystem/medals/proc/CheckMedal(medal, client/player)
+	if(!medal || !hub_enabled)
+		return
+
+	if(isnull(world.GetMedal(medal, player, CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))))
+		hub_enabled = FALSE
+		log_game("MEDAL ERROR: Could not contact hub to get medal:[medal] player: [player.key]")
+		message_admins("Error! Failed to contact hub to get [medal] medal for [player.key]!")
+		return
+	to_chat(player, "[medal] is unlocked")
+
+/datum/controller/subsystem/medals/proc/LockMedal(medal, client/player)
+	if(!player || !medal || !hub_enabled)
+		return
+	var/result = world.ClearMedal(medal, player, CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))
+	switch(result)
+		if(null)
+			hub_enabled = FALSE
+			log_game("MEDAL ERROR: Could not contact hub to clear medal:[medal] player:[player.key]")
+			message_admins("Error! Failed to contact hub to clear [medal] medal for [player.key]!")
+		if(TRUE)
+			message_admins("Medal: [medal] removed for [player.key]")
+		if(FALSE)
+			message_admins("Medal: [medal] was not found for [player.key]. Unable to clear.")
+
+
+/datum/controller/subsystem/medals/proc/ClearScore(client/player)
+	if(isnull(world.SetScores(player.ckey, "", CONFIG_GET(string/medal_hub_address), CONFIG_GET(string/medal_hub_password))))
+		log_game("MEDAL ERROR: Could not contact hub to clear scores for [player.key]!")
+		message_admins("Error! Failed to contact hub to clear scores for [player.key]!")

code/controllers/subsystem/minor_mapping.dm

@@ -0,0 +1,38 @@
+SUBSYSTEM_DEF(minor_mapping)
+	name = "Minor Mapping"
+	init_order = INIT_ORDER_MINOR_MAPPING
+	flags = SS_NO_FIRE
+
+/datum/controller/subsystem/minor_mapping/Initialize(timeofday)
+	trigger_migration(CONFIG_GET(number/mice_roundstart))
+	return ..()
+
+/datum/controller/subsystem/minor_mapping/proc/trigger_migration(num_mice=10)
+	var/list/exposed_wires = find_exposed_wires()
+
+	var/mob/living/simple_animal/mouse/M
+	var/turf/proposed_turf
+
+	while((num_mice > 0) && exposed_wires.len)
+		proposed_turf = pick_n_take(exposed_wires)
+		if(!M)
+			M = new(proposed_turf)
+		else
+			M.forceMove(proposed_turf)
+		if(M.environment_is_safe())
+			num_mice -= 1
+			M = null
+
+/proc/find_exposed_wires()
+	var/list/exposed_wires = list()
+	exposed_wires.Cut()
+	var/list/all_turfs
+	for (var/z in SSmapping.levels_by_trait(ZTRAIT_STATION))
+		all_turfs += block(locate(1,1,z), locate(world.maxx,world.maxy,z))
+	for(var/turf/open/floor/plating/T in all_turfs)
+		if(is_blocked_turf(T))
+			continue
+		if(locate(/obj/structure/cable) in T)
+			exposed_wires += T
+
+	return shuffle(exposed_wires)

code/controllers/subsystem/mobs.dm

@@ -0,0 +1,43 @@
+SUBSYSTEM_DEF(mobs)
+	name = "Mobs"
+	priority = FIRE_PRIORITY_MOBS
+	flags = SS_KEEP_TIMING | SS_NO_INIT
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+	var/static/list/clients_by_zlevel[][]
+	var/static/list/dead_players_by_zlevel[][] = list(list()) // Needs to support zlevel 1 here, MaxZChanged only happens when z2 is created and new_players can login before that.
+	var/static/list/cubemonkeys = list()
+
+/datum/controller/subsystem/mobs/stat_entry()
+	..("P:[GLOB.mob_living_list.len]")
+
+/datum/controller/subsystem/mobs/proc/MaxZChanged()
+	if (!islist(clients_by_zlevel))
+		clients_by_zlevel = new /list(world.maxz,0)
+		dead_players_by_zlevel = new /list(world.maxz,0)
+	while (clients_by_zlevel.len < world.maxz)
+		clients_by_zlevel.len++
+		clients_by_zlevel[clients_by_zlevel.len] = list()
+		dead_players_by_zlevel.len++
+		dead_players_by_zlevel[dead_players_by_zlevel.len] = list()
+
+/datum/controller/subsystem/mobs/fire(resumed = 0)
+	var/seconds = wait * 0.1
+	if (!resumed)
+		src.currentrun = GLOB.mob_living_list.Copy()
+		if (GLOB.living_cameras.len)
+			src.currentrun += GLOB.living_cameras
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	var/times_fired = src.times_fired
+	while(currentrun.len)
+		var/mob/M = currentrun[currentrun.len]
+		currentrun.len--
+		if(M)
+			M.Life(seconds, times_fired)
+		else
+			GLOB.mob_living_list.Remove(M)
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/moods.dm

@@ -0,0 +1,4 @@
+PROCESSING_SUBSYSTEM_DEF(mood)
+	name = "Mood"
+	flags = SS_NO_INIT | SS_BACKGROUND
+	priority = 20

code/controllers/subsystem/nightshift.dm

@@ -0,0 +1,55 @@
+SUBSYSTEM_DEF(nightshift)
+	name = "Night Shift"
+	wait = 600
+	flags = SS_NO_TICK_CHECK
+
+	var/nightshift_active = FALSE
+	var/nightshift_start_time = 702000		//7:30 PM, station time
+	var/nightshift_end_time = 270000		//7:30 AM, station time
+	var/nightshift_first_check = 30 SECONDS
+
+	var/high_security_mode = FALSE
+
+/datum/controller/subsystem/nightshift/Initialize()
+	if(!CONFIG_GET(flag/enable_night_shifts))
+		can_fire = FALSE
+	return ..()
+
+/datum/controller/subsystem/nightshift/fire(resumed = FALSE)
+	if(world.time - SSticker.round_start_time < nightshift_first_check)
+		return
+	check_nightshift()
+
+/datum/controller/subsystem/nightshift/proc/announce(message)
+	priority_announce(message, sound='sound/misc/notice2.ogg', sender_override="Automated Lighting System Announcement")
+
+/datum/controller/subsystem/nightshift/proc/check_nightshift()
+	var/emergency = GLOB.security_level >= SEC_LEVEL_RED
+	var/announcing = TRUE
+	var/time = STATION_TIME(FALSE)
+	var/night_time = (time < nightshift_end_time) || (time > nightshift_start_time)
+	if(high_security_mode != emergency)
+		high_security_mode = emergency
+		if(night_time)
+			announcing = FALSE
+			if(!emergency)
+				announce("Restoring night lighting configuration to normal operation.")
+			else
+				announce("Disabling night lighting: Station is in a state of emergency.")  
+	if(emergency)
+		night_time = FALSE
+	if(nightshift_active != night_time)
+		update_nightshift(night_time, announcing)
+
+/datum/controller/subsystem/nightshift/proc/update_nightshift(active, announce = TRUE)
+	nightshift_active = active
+	if(announce)
+		if (active)
+			announce("Good evening, crew. To reduce power consumption and stimulate the circadian rhythms of some species, all of the lights aboard the station have been dimmed for the night.")
+		else
+			announce("Good morning, crew. As it is now day time, all of the lights aboard the station have been restored to their former brightness.")
+	for(var/A in GLOB.apcs_list)
+		var/obj/machinery/power/apc/APC = A
+		if (APC.area && (APC.area.type in GLOB.the_station_areas))
+			APC.set_nightshift(active)
+			CHECK_TICK

code/controllers/subsystem/npcpool.dm

@@ -0,0 +1,34 @@
+SUBSYSTEM_DEF(npcpool)
+	name = "NPC Pool"
+	flags = SS_POST_FIRE_TIMING|SS_NO_INIT|SS_BACKGROUND
+	priority = FIRE_PRIORITY_NPC
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+
+/datum/controller/subsystem/npcpool/stat_entry()
+	var/list/activelist = GLOB.simple_animals[AI_ON]
+	..("NPCS:[activelist.len]")
+
+/datum/controller/subsystem/npcpool/fire(resumed = FALSE)
+
+	if (!resumed)
+		var/list/activelist = GLOB.simple_animals[AI_ON]
+		src.currentrun = activelist.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(currentrun.len)
+		var/mob/living/simple_animal/SA = currentrun[currentrun.len]
+		--currentrun.len
+
+		if(!SA.ckey && !SA.notransform)
+			if(SA.stat != DEAD)
+				SA.handle_automated_movement()
+			if(SA.stat != DEAD)
+				SA.handle_automated_action()
+			if(SA.stat != DEAD)
+				SA.handle_automated_speech()
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/overlays.dm

@@ -0,0 +1,221 @@
+SUBSYSTEM_DEF(overlays)
+	name = "Overlay"
+	flags = SS_TICKER
+	wait = 1
+	priority = FIRE_PRIORITY_OVERLAYS
+	init_order = INIT_ORDER_OVERLAY
+
+	var/list/queue
+	var/list/stats
+	var/list/overlay_icon_state_caches
+	var/list/overlay_icon_cache
+
+/datum/controller/subsystem/overlays/PreInit()
+	overlay_icon_state_caches = list()
+	overlay_icon_cache = list()
+	queue = list()
+	stats = list()
+
+/datum/controller/subsystem/overlays/Initialize()
+	initialized = TRUE
+	fire(mc_check = FALSE)
+	return ..()
+
+
+/datum/controller/subsystem/overlays/stat_entry()
+	..("Ov:[length(queue)]")
+
+
+/datum/controller/subsystem/overlays/Shutdown()
+	text2file(render_stats(stats), "[GLOB.log_directory]/overlay.log")
+
+
+/datum/controller/subsystem/overlays/Recover()
+	overlay_icon_state_caches = SSoverlays.overlay_icon_state_caches
+	overlay_icon_cache = SSoverlays.overlay_icon_cache
+	queue = SSoverlays.queue
+
+
+/datum/controller/subsystem/overlays/fire(resumed = FALSE, mc_check = TRUE)
+	var/list/queue = src.queue
+	var/static/count = 0
+	if (count)
+		var/c = count
+		count = 0 //so if we runtime on the Cut, we don't try again.
+		queue.Cut(1,c+1)
+
+	for (var/thing in queue)
+		count++
+		if(thing)
+			STAT_START_STOPWATCH
+			var/atom/A = thing
+			COMPILE_OVERLAYS(A)
+			STAT_STOP_STOPWATCH
+			STAT_LOG_ENTRY(stats, A.type)
+		if(mc_check)
+			if(MC_TICK_CHECK)
+				break
+		else
+			CHECK_TICK
+
+	if (count)
+		queue.Cut(1,count+1)
+		count = 0
+
+/proc/iconstate2appearance(icon, iconstate)
+	var/static/image/stringbro = new()
+	var/list/icon_states_cache = SSoverlays.overlay_icon_state_caches
+	var/list/cached_icon = icon_states_cache[icon]
+	if (cached_icon)
+		var/cached_appearance = cached_icon["[iconstate]"]
+		if (cached_appearance)
+			return cached_appearance
+	stringbro.icon = icon
+	stringbro.icon_state = iconstate
+	if (!cached_icon) //not using the macro to save an associated lookup
+		cached_icon = list()
+		icon_states_cache[icon] = cached_icon
+	var/cached_appearance = stringbro.appearance
+	cached_icon["[iconstate]"] = cached_appearance
+	return cached_appearance
+
+/proc/icon2appearance(icon)
+	var/static/image/iconbro = new()
+	var/list/icon_cache = SSoverlays.overlay_icon_cache
+	. = icon_cache[icon]
+	if (!.)
+		iconbro.icon = icon
+		. = iconbro.appearance
+		icon_cache[icon] = .
+
+/atom/proc/build_appearance_list(old_overlays)
+	var/static/image/appearance_bro = new()
+	var/list/new_overlays = list()
+	if (!islist(old_overlays))
+		old_overlays = list(old_overlays)
+	for (var/overlay in old_overlays)
+		if(!overlay)
+			continue
+		if (istext(overlay))
+			new_overlays += iconstate2appearance(icon, overlay)
+		else if(isicon(overlay))
+			new_overlays += icon2appearance(overlay)
+		else
+			if(isloc(overlay))
+				var/atom/A = overlay
+				if (A.flags_1 & OVERLAY_QUEUED_1)
+					COMPILE_OVERLAYS(A)
+			appearance_bro.appearance = overlay //this works for images and atoms too!
+			if(!ispath(overlay))
+				var/image/I = overlay
+				appearance_bro.dir = I.dir
+			new_overlays += appearance_bro.appearance
+	return new_overlays
+
+#define NOT_QUEUED_ALREADY (!(flags_1 & OVERLAY_QUEUED_1))
+#define QUEUE_FOR_COMPILE flags_1 |= OVERLAY_QUEUED_1; SSoverlays.queue += src;
+/atom/proc/cut_overlays(priority = FALSE)
+	LAZYINITLIST(priority_overlays)
+	LAZYINITLIST(remove_overlays)
+	LAZYINITLIST(add_overlays)
+	remove_overlays = overlays.Copy()
+	add_overlays.Cut()
+
+	if(priority)
+		priority_overlays.Cut()
+
+	//If not already queued for work and there are overlays to remove
+	if(NOT_QUEUED_ALREADY && remove_overlays.len)
+		QUEUE_FOR_COMPILE
+
+/atom/proc/cut_overlay(list/overlays, priority)
+	if(!overlays)
+		return
+	overlays = build_appearance_list(overlays)
+	LAZYINITLIST(add_overlays) //always initialized after this point
+	LAZYINITLIST(priority_overlays)
+	LAZYINITLIST(remove_overlays)
+	var/a_len = add_overlays.len
+	var/r_len = remove_overlays.len
+	var/p_len = priority_overlays.len
+	remove_overlays += overlays
+	add_overlays -= overlays
+
+
+	if(priority)
+		var/list/cached_priority = priority_overlays
+		LAZYREMOVE(cached_priority, overlays)
+
+	var/fa_len = add_overlays.len
+	var/fr_len = remove_overlays.len
+	var/fp_len = priority_overlays.len
+
+	//If not already queued and there is work to be done
+	if(NOT_QUEUED_ALREADY && (fa_len != a_len || fr_len != r_len || fp_len != p_len))
+		QUEUE_FOR_COMPILE
+
+/atom/proc/add_overlay(list/overlays, priority = FALSE)
+	if(!overlays)
+		return
+
+	overlays = build_appearance_list(overlays)
+
+	LAZYINITLIST(add_overlays) //always initialized after this point
+	LAZYINITLIST(priority_overlays)
+	var/a_len = add_overlays.len
+	var/p_len = priority_overlays.len
+
+	if(priority)
+		priority_overlays += overlays  //or in the image. Can we use [image] = image?
+		var/fp_len = priority_overlays.len
+		if(NOT_QUEUED_ALREADY && fp_len != p_len)
+			QUEUE_FOR_COMPILE
+	else
+		add_overlays += overlays
+		var/fa_len = add_overlays.len
+		if(NOT_QUEUED_ALREADY && fa_len != a_len)
+			QUEUE_FOR_COMPILE
+
+/atom/proc/copy_overlays(atom/other, cut_old)	//copys our_overlays from another atom
+	if(!other)
+		if(cut_old)
+			cut_overlays()
+		return
+
+	var/list/cached_other = other.overlays.Copy()
+	if(cached_other)
+		if(cut_old || !LAZYLEN(overlays))
+			remove_overlays = overlays
+		add_overlays = cached_other
+		if(NOT_QUEUED_ALREADY)
+			QUEUE_FOR_COMPILE
+	else if(cut_old)
+		cut_overlays()
+
+#undef NOT_QUEUED_ALREADY
+#undef QUEUE_FOR_COMPILE
+
+//TODO: Better solution for these?
+/image/proc/add_overlay(x)
+	overlays |= x
+
+/image/proc/cut_overlay(x)
+	overlays -= x
+
+/image/proc/cut_overlays(x)
+	overlays.Cut()
+
+/image/proc/copy_overlays(atom/other, cut_old)
+	if(!other)
+		if(cut_old)
+			cut_overlays()
+		return
+
+	var/list/cached_other = other.overlays.Copy()
+	if(cached_other)
+		if(cut_old || !overlays.len)
+			overlays = cached_other
+		else
+			overlays |= cached_other
+	else if(cut_old)
+		cut_overlays()

code/controllers/subsystem/pai.dm

@@ -0,0 +1,197 @@
+SUBSYSTEM_DEF(pai)
+	name = "pAI"
+
+	flags = SS_NO_INIT|SS_NO_FIRE
+
+	var/list/candidates = list()
+	var/ghost_spam = FALSE
+	var/spam_delay = 100
+	var/list/pai_card_list = list()
+
+/datum/controller/subsystem/pai/Topic(href, href_list[])
+	if(href_list["download"])
+		var/datum/paiCandidate/candidate = locate(href_list["candidate"]) in candidates
+		var/obj/item/paicard/card = locate(href_list["device"]) in pai_card_list
+		if(card.pai)
+			return
+		if(istype(card, /obj/item/paicard) && istype(candidate, /datum/paiCandidate))
+			if(check_ready(candidate) != candidate)
+				return FALSE
+			var/mob/living/silicon/pai/pai = new(card)
+			if(!candidate.name)
+				pai.name = pick(GLOB.ninja_names)
+			else
+				pai.name = candidate.name
+			pai.real_name = pai.name
+			pai.key = candidate.key
+
+			card.setPersonality(pai)
+
+			SSticker.mode.update_cult_icons_removed(card.pai.mind)
+
+			candidates -= candidate
+			usr << browse(null, "window=findPai")
+
+	if(href_list["new"])
+		var/datum/paiCandidate/candidate = locate(href_list["candidate"]) in candidates
+		var/option = href_list["option"]
+		var/t = ""
+
+		switch(option)
+			if("name")
+				t = input("Enter a name for your pAI", "pAI Name", candidate.name) as text
+				if(t)
+					candidate.name = copytext(sanitize(t),1,MAX_NAME_LEN)
+			if("desc")
+				t = input("Enter a description for your pAI", "pAI Description", candidate.description) as message
+				if(t)
+					candidate.description = copytext(sanitize(t),1,MAX_MESSAGE_LEN)
+			if("role")
+				t = input("Enter a role for your pAI", "pAI Role", candidate.role) as text
+				if(t)
+					candidate.role = copytext(sanitize(t),1,MAX_MESSAGE_LEN)
+			if("ooc")
+				t = input("Enter any OOC comments", "pAI OOC Comments", candidate.comments) as message
+				if(t)
+					candidate.comments = copytext(sanitize(t),1,MAX_MESSAGE_LEN)
+			if("save")
+				candidate.savefile_save(usr)
+			if("load")
+				candidate.savefile_load(usr)
+				//In case people have saved unsanitized stuff.
+				if(candidate.name)
+					candidate.name = copytext(sanitize(candidate.name),1,MAX_NAME_LEN)
+				if(candidate.description)
+					candidate.description = copytext(sanitize(candidate.description),1,MAX_MESSAGE_LEN)
+				if(candidate.role)
+					candidate.role = copytext(sanitize(candidate.role),1,MAX_MESSAGE_LEN)
+				if(candidate.comments)
+					candidate.comments = copytext(sanitize(candidate.comments),1,MAX_MESSAGE_LEN)
+
+			if("submit")
+				if(candidate)
+					candidate.ready = 1
+					for(var/obj/item/paicard/p in pai_card_list)
+						if(!p.pai)
+							p.alertUpdate()
+				usr << browse(null, "window=paiRecruit")
+				return
+		recruitWindow(usr)
+
+/datum/controller/subsystem/pai/proc/recruitWindow(mob/M)
+	var/datum/paiCandidate/candidate
+	for(var/datum/paiCandidate/c in candidates)
+		if(c.key == M.key)
+			candidate = c
+	if(!candidate)
+		candidate = new /datum/paiCandidate()
+		candidate.key = M.key
+		candidates.Add(candidate)
+
+
+	var/dat = ""
+	dat += {"
+			<style type="text/css">
+
+			p.top {
+				background-color: #AAAAAA; color: black;
+			}
+
+			tr.d0 td {
+				background-color: #CC9999; color: black;
+			}
+			tr.d1 td {
+				background-color: #9999CC; color: black;
+			}
+			</style>
+			"}
+
+	dat += "<p class=\"top\">Please configure your pAI personality's options. Remember, what you enter here could determine whether or not the user requesting a personality chooses you!</p>"
+	dat += "<table>"
+	dat += "<tr class=\"d0\"><td>Name:</td><td>[candidate.name]</td></tr>"
+	dat += "<tr class=\"d1\"><td><a href='byond://?src=[REF(src)];option=name;new=1;candidate=[REF(candidate)]'>\[Edit\]</a></td><td>What you plan to call yourself. Suggestions: Any character name you would choose for a station character OR an AI.</td></tr>"
+
+	dat += "<tr class=\"d0\"><td>Description:</td><td>[candidate.description]</td></tr>"
+	dat += "<tr class=\"d1\"><td><a href='byond://?src=[REF(src)];option=desc;new=1;candidate=[REF(candidate)]'>\[Edit\]</a></td><td>What sort of pAI you typically play; your mannerisms, your quirks, etc. This can be as sparse or as detailed as you like.</td></tr>"
+
+	dat += "<tr class=\"d0\"><td>Preferred Role:</td><td>[candidate.role]</td></tr>"
+	dat += "<tr class=\"d1\"><td><a href='byond://?src=[REF(src)];option=role;new=1;candidate=[REF(candidate)]'>\[Edit\]</a></td><td>Do you like to partner with sneaky social ninjas? Like to help security hunt down thugs? Enjoy watching an engineer's back while he saves the station yet again? This doesn't have to be limited to just station jobs. Pretty much any general descriptor for what you'd like to be doing works here.</td></tr>"
+
+	dat += "<tr class=\"d0\"><td>OOC Comments:</td><td>[candidate.comments]</td></tr>"
+	dat += "<tr class=\"d1\"><td><a href='byond://?src=[REF(src)];option=ooc;new=1;candidate=[REF(candidate)]'>\[Edit\]</a></td><td>Anything you'd like to address specifically to the player reading this in an OOC manner. \"I prefer more serious RP.\", \"I'm still learning the interface!\", etc. Feel free to leave this blank if you want.</td></tr>"
+
+	dat += "</table>"
+
+	dat += "<br>"
+	dat += "<h3><a href='byond://?src=[REF(src)];option=submit;new=1;candidate=[REF(candidate)]'>Submit Personality</a></h3><br>"
+	dat += "<a href='byond://?src=[REF(src)];option=save;new=1;candidate=[REF(candidate)]'>Save Personality</a><br>"
+	dat += "<a href='byond://?src=[REF(src)];option=load;new=1;candidate=[REF(candidate)]'>Load Personality</a><br>"
+
+	M << browse(dat, "window=paiRecruit")
+
+/datum/controller/subsystem/pai/proc/spam_again()
+	ghost_spam = FALSE
+
+/datum/controller/subsystem/pai/proc/check_ready(var/datum/paiCandidate/C)
+	if(!C.ready)
+		return FALSE
+	for(var/mob/dead/observer/O in GLOB.player_list)
+		if(O.key == C.key)
+			return C
+	return FALSE
+
+/datum/controller/subsystem/pai/proc/findPAI(obj/item/paicard/p, mob/user)
+	if(!ghost_spam)
+		ghost_spam = TRUE
+		for(var/mob/dead/observer/G in GLOB.player_list)
+			if(!G.key || !G.client)
+				continue
+			if(!(ROLE_PAI in G.client.prefs.be_special))
+				continue
+			to_chat(G, "<span class='ghostalert'>[user] is requesting a pAI personality! Use the pAI button to submit yourself as one.</span>")
+		addtimer(CALLBACK(src, .proc/spam_again), spam_delay)
+	var/list/available = list()
+	for(var/datum/paiCandidate/c in SSpai.candidates)
+		available.Add(check_ready(c))
+	var/dat = ""
+
+	dat += {"
+			<style type="text/css">
+
+			p.top {
+				background-color: #AAAAAA; color: black;
+			}
+
+			tr.d0 td {
+				background-color: #CC9999; color: black;
+			}
+			tr.d1 td {
+				background-color: #9999CC; color: black;
+			}
+			tr.d2 td {
+				background-color: #99CC99; color: black;
+			}
+			</style>
+			"}
+	dat += "<p class=\"top\">Requesting AI personalities from central database... If there are no entries, or if a suitable entry is not listed, check again later as more personalities may be added.</p>"
+
+	dat += "<table>"
+
+	for(var/datum/paiCandidate/c in available)
+		dat += "<tr class=\"d0\"><td>Name:</td><td>[c.name]</td></tr>"
+		dat += "<tr class=\"d1\"><td>Description:</td><td>[c.description]</td></tr>"
+		dat += "<tr class=\"d0\"><td>Preferred Role:</td><td>[c.role]</td></tr>"
+		dat += "<tr class=\"d1\"><td>OOC Comments:</td><td>[c.comments]</td></tr>"
+		dat += "<tr class=\"d2\"><td><a href='byond://?src=[REF(src)];download=1;candidate=[REF(c)];device=[REF(p)]'>\[Download [c.name]\]</a></td><td></td></tr>"
+
+	dat += "</table>"
+
+	user << browse(dat, "window=findPai")
+
+/datum/paiCandidate
+	var/name
+	var/key
+	var/description
+	var/role
+	var/comments
+	var/ready = 0

code/controllers/subsystem/parallax.dm

@@ -0,0 +1,44 @@
+SUBSYSTEM_DEF(parallax)
+	name = "Parallax"
+	wait = 2
+	flags = SS_POST_FIRE_TIMING | SS_BACKGROUND
+	priority = FIRE_PRIORITY_PARALLAX
+	runlevels = RUNLEVEL_LOBBY | RUNLEVELS_DEFAULT
+	var/list/currentrun
+	var/planet_x_offset = 128
+	var/planet_y_offset = 128
+
+/datum/controller/subsystem/parallax/Initialize(timeofday)
+	. = ..()
+	planet_y_offset = rand(100, 160)
+	planet_x_offset = rand(100, 160)
+
+/datum/controller/subsystem/parallax/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = GLOB.clients.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(length(currentrun))
+		var/client/C = currentrun[currentrun.len]
+		currentrun.len--
+		if (!C || !C.eye)
+			if (MC_TICK_CHECK)
+				return
+			continue
+		var/atom/movable/A = C.eye
+		if(!istype(A))
+			continue
+		for (A; isloc(A.loc) && !isturf(A.loc); A = A.loc);
+
+		if(A != C.movingmob)
+			if(C.movingmob != null)
+				C.movingmob.client_mobs_in_contents -= C.mob
+				UNSETEMPTY(C.movingmob.client_mobs_in_contents)
+			LAZYINITLIST(A.client_mobs_in_contents)
+			A.client_mobs_in_contents += C.mob
+			C.movingmob = A
+		if (MC_TICK_CHECK)
+			return
+	currentrun = null

code/controllers/subsystem/pathfinder.dm

@@ -0,0 +1,48 @@
+SUBSYSTEM_DEF(pathfinder)
+	name = "Pathfinder"
+	init_order = INIT_ORDER_PATH
+	flags = SS_NO_FIRE
+	var/datum/flowcache/mobs
+	var/datum/flowcache/circuits
+	var/static/space_type_cache
+
+/datum/controller/subsystem/pathfinder/Initialize()
+	space_type_cache = typecacheof(/turf/open/space)
+	mobs = new(10)
+	circuits = new(3)
+	return ..()
+
+/datum/flowcache
+	var/lcount
+	var/run
+	var/free
+	var/list/flow
+
+/datum/flowcache/New(var/n)
+	. = ..()
+	lcount = n
+	run = 0
+	free = 1
+	flow = new/list(lcount)
+
+/datum/flowcache/proc/getfree(atom/M)
+	if(run < lcount)
+		run += 1
+		while(flow[free])
+			CHECK_TICK
+			free = (free % lcount) + 1
+		var/t = addtimer(CALLBACK(src, /datum/flowcache.proc/toolong, free), 150, TIMER_STOPPABLE)
+		flow[free] = t
+		flow[t] = M
+		return free
+	else
+		return 0
+
+/datum/flowcache/proc/toolong(l)
+	log_game("Pathfinder route took longer than 150 ticks, src bot [flow[flow[l]]]")
+	found(l)
+
+/datum/flowcache/proc/found(l)
+	deltimer(flow[l])
+	flow[l] = null
+	run -= 1

code/controllers/subsystem/persistence.dm

@@ -0,0 +1,415 @@
+#define FILE_ANTAG_REP "data/AntagReputation.json"
+
+SUBSYSTEM_DEF(persistence)
+	name = "Persistence"
+	init_order = INIT_ORDER_PERSISTENCE
+	flags = SS_NO_FIRE
+	var/list/satchel_blacklist 		= list() //this is a typecache
+	var/list/new_secret_satchels 	= list() //these are objects
+	var/list/old_secret_satchels 	= list()
+
+	var/list/obj/structure/chisel_message/chisel_messages = list()
+	var/list/saved_messages = list()
+	var/list/saved_modes = list(1,2,3)
+	var/list/saved_trophies = list()
+	var/list/spawned_objects = list()
+	var/list/antag_rep = list()
+	var/list/antag_rep_change = list()
+	var/list/picture_logging_information = list()
+	var/list/obj/structure/sign/picture_frame/photo_frames
+	var/list/obj/item/storage/photo_album/photo_albums
+
+/datum/controller/subsystem/persistence/Initialize()
+	LoadSatchels()
+	LoadPoly()
+	LoadChiselMessages()
+	LoadTrophies()
+	LoadRecentModes()
+	LoadPhotoPersistence()
+	if(CONFIG_GET(flag/use_antag_rep))
+		LoadAntagReputation()
+	LoadRandomizedRecipes()
+	return ..()
+
+/datum/controller/subsystem/persistence/proc/LoadSatchels()
+	var/placed_satchel = 0
+	var/path
+	if(fexists("data/npc_saves/SecretSatchels.sav")) //legacy conversion. Will only ever run once.
+		var/savefile/secret_satchels = new /savefile("data/npc_saves/SecretSatchels.sav")
+		for(var/map in secret_satchels)
+			var/json_file = file("data/npc_saves/SecretSatchels[map].json")
+			var/list/legacy_secret_satchels = splittext(secret_satchels[map],"#")
+			var/list/satchels = list()
+			for(var/i=1,i<=legacy_secret_satchels.len,i++)
+				var/satchel_string = legacy_secret_satchels[i]
+				var/list/chosen_satchel = splittext(satchel_string,"|")
+				if(chosen_satchel.len == 3)
+					var/list/data = list()
+					data["x"] = text2num(chosen_satchel[1])
+					data["y"] = text2num(chosen_satchel[2])
+					data["saved_obj"] = chosen_satchel[3]
+					satchels += list(data)
+			var/list/file_data = list()
+			file_data["data"] = satchels
+			WRITE_FILE(json_file, json_encode(file_data))
+		fdel("data/npc_saves/SecretSatchels.sav")
+
+	var/json_file = file("data/npc_saves/SecretSatchels[SSmapping.config.map_name].json")
+	var/list/json = list()
+	if(fexists(json_file))
+		json = json_decode(file2text(json_file))
+
+	old_secret_satchels = json["data"]
+	var/obj/item/storage/backpack/satchel/flat/F
+	if(old_secret_satchels && old_secret_satchels.len >= 10) //guards against low drop pools assuring that one player cannot reliably find his own gear.
+		var/pos = rand(1, old_secret_satchels.len)
+		F = new()
+		old_secret_satchels.Cut(pos, pos+1 % old_secret_satchels.len)
+		F.x = old_secret_satchels[pos]["x"]
+		F.y = old_secret_satchels[pos]["y"]
+		F.z = SSmapping.station_start
+		path = text2path(old_secret_satchels[pos]["saved_obj"])
+
+	if(F)
+		if(isfloorturf(F.loc) && !isplatingturf(F.loc))
+			F.hide(1)
+		if(ispath(path))
+			var/spawned_item = new path(F)
+			spawned_objects[spawned_item] = TRUE
+		placed_satchel++
+	var/free_satchels = 0
+	for(var/turf/T in shuffle(block(locate(TRANSITIONEDGE,TRANSITIONEDGE,SSmapping.station_start), locate(world.maxx-TRANSITIONEDGE,world.maxy-TRANSITIONEDGE,SSmapping.station_start)))) //Nontrivially expensive but it's roundstart only
+		if(isfloorturf(T) && !isplatingturf(T))
+			new /obj/item/storage/backpack/satchel/flat/secret(T)
+			free_satchels++
+			if((free_satchels + placed_satchel) == 10) //ten tiles, more than enough to kill anything that moves
+				break
+
+/datum/controller/subsystem/persistence/proc/LoadPoly()
+	for(var/mob/living/simple_animal/parrot/Poly/P in GLOB.alive_mob_list)
+		twitterize(P.speech_buffer, "polytalk")
+		break //Who's been duping the bird?!
+
+/datum/controller/subsystem/persistence/proc/LoadChiselMessages()
+	var/list/saved_messages = list()
+	if(fexists("data/npc_saves/ChiselMessages.sav")) //legacy compatability to convert old format to new
+		var/savefile/chisel_messages_sav = new /savefile("data/npc_saves/ChiselMessages.sav")
+		var/saved_json
+		chisel_messages_sav[SSmapping.config.map_name] >> saved_json
+		if(!saved_json)
+			return
+		saved_messages = json_decode(saved_json)
+		fdel("data/npc_saves/ChiselMessages.sav")
+	else
+		var/json_file = file("data/npc_saves/ChiselMessages[SSmapping.config.map_name].json")
+		if(!fexists(json_file))
+			return
+		var/list/json = json_decode(file2text(json_file))
+
+		if(!json)
+			return
+		saved_messages = json["data"]
+
+	for(var/item in saved_messages)
+		if(!islist(item))
+			continue
+
+		var/xvar = item["x"]
+		var/yvar = item["y"]
+		var/zvar = item["z"]
+
+		if(!xvar || !yvar || !zvar)
+			continue
+
+		var/turf/T = locate(xvar, yvar, zvar)
+		if(!isturf(T))
+			continue
+
+		if(locate(/obj/structure/chisel_message) in T)
+			continue
+
+		var/obj/structure/chisel_message/M = new(T)
+
+		if(!QDELETED(M))
+			M.unpack(item)
+
+	log_world("Loaded [saved_messages.len] engraved messages on map [SSmapping.config.map_name]")
+
+/datum/controller/subsystem/persistence/proc/LoadTrophies()
+	if(fexists("data/npc_saves/TrophyItems.sav")) //legacy compatability to convert old format to new
+		var/savefile/S = new /savefile("data/npc_saves/TrophyItems.sav")
+		var/saved_json
+		S >> saved_json
+		if(!saved_json)
+			return
+		saved_trophies = json_decode(saved_json)
+		fdel("data/npc_saves/TrophyItems.sav")
+	else
+		var/json_file = file("data/npc_saves/TrophyItems.json")
+		if(!fexists(json_file))
+			return
+		var/list/json = json_decode(file2text(json_file))
+		if(!json)
+			return
+		saved_trophies = json["data"]
+	SetUpTrophies(saved_trophies.Copy())
+
+/datum/controller/subsystem/persistence/proc/LoadRecentModes()
+	var/json_file = file("data/RecentModes.json")
+	if(!fexists(json_file))
+		return
+	var/list/json = json_decode(file2text(json_file))
+	if(!json)
+		return
+	saved_modes = json["data"]
+
+/datum/controller/subsystem/persistence/proc/LoadAntagReputation()
+	var/json = file2text(FILE_ANTAG_REP)
+	if(!json)
+		var/json_file = file(FILE_ANTAG_REP)
+		if(!fexists(json_file))
+			WARNING("Failed to load antag reputation. File likely corrupt.")
+			return
+		return
+	antag_rep = json_decode(json)
+
+/datum/controller/subsystem/persistence/proc/SetUpTrophies(list/trophy_items)
+	for(var/A in GLOB.trophy_cases)
+		var/obj/structure/displaycase/trophy/T = A
+		if (T.showpiece)
+			continue
+		T.added_roundstart = TRUE
+
+		var/trophy_data = pick_n_take(trophy_items)
+
+		if(!islist(trophy_data))
+			continue
+
+		var/list/chosen_trophy = trophy_data
+
+		if(!chosen_trophy || isemptylist(chosen_trophy)) //Malformed
+			continue
+
+		var/path = text2path(chosen_trophy["path"]) //If the item no longer exist, this returns null
+		if(!path)
+			continue
+
+		T.showpiece = new /obj/item/showpiece_dummy(T, path)
+		T.trophy_message = chosen_trophy["message"]
+		T.placer_key = chosen_trophy["placer_key"]
+		T.update_icon()
+
+/datum/controller/subsystem/persistence/proc/CollectData()
+	CollectChiselMessages()
+	CollectSecretSatchels()
+	CollectTrophies()
+	CollectRoundtype()
+	SavePhotoPersistence()						//THIS IS PERSISTENCE, NOT THE LOGGING PORTION.
+	if(CONFIG_GET(flag/use_antag_rep))
+		CollectAntagReputation()
+	SaveRandomizedRecipes()
+
+/datum/controller/subsystem/persistence/proc/GetPhotoAlbums()
+	var/album_path = file("data/photo_albums.json")
+	if(fexists(album_path))
+		return json_decode(file2text(album_path))
+
+/datum/controller/subsystem/persistence/proc/GetPhotoFrames()
+	var/frame_path = file("data/photo_frames.json")
+	if(fexists(frame_path))
+		return json_decode(file2text(frame_path))
+
+/datum/controller/subsystem/persistence/proc/LoadPhotoPersistence()
+	var/album_path = file("data/photo_albums.json")
+	var/frame_path = file("data/photo_frames.json")
+	if(fexists(album_path))
+		var/list/json = json_decode(file2text(album_path))
+		if(json.len)
+			for(var/i in photo_albums)
+				var/obj/item/storage/photo_album/A = i
+				if(!A.persistence_id)
+					continue
+				if(json[A.persistence_id])
+					A.populate_from_id_list(json[A.persistence_id])
+
+	if(fexists(frame_path))
+		var/list/json = json_decode(file2text(frame_path))
+		if(json.len)
+			for(var/i in photo_frames)
+				var/obj/structure/sign/picture_frame/PF = i
+				if(!PF.persistence_id)
+					continue
+				if(json[PF.persistence_id])
+					PF.load_from_id(json[PF.persistence_id])
+
+/datum/controller/subsystem/persistence/proc/SavePhotoPersistence()
+	var/album_path = file("data/photo_albums.json")
+	var/frame_path = file("data/photo_frames.json")
+
+	var/list/frame_json = list()
+	var/list/album_json = list()
+
+	if(fexists(album_path))
+		album_json = json_decode(file2text(album_path))
+		fdel(album_path)
+
+	for(var/i in photo_albums)
+		var/obj/item/storage/photo_album/A = i
+		if(!istype(A) || !A.persistence_id)
+			continue
+		var/list/L = A.get_picture_id_list()
+		album_json[A.persistence_id] = L
+
+	album_json = json_encode(album_json)
+
+	WRITE_FILE(album_path, album_json)
+
+	if(fexists(frame_path))
+		frame_json = json_decode(file2text(frame_path))
+		fdel(frame_path)
+
+	for(var/i in photo_frames)
+		var/obj/structure/sign/picture_frame/F = i
+		if(!istype(F) || !F.persistence_id)
+			continue
+		frame_json[F.persistence_id] = F.get_photo_id()
+
+	frame_json = json_encode(frame_json)
+
+	WRITE_FILE(frame_path, frame_json)
+
+/datum/controller/subsystem/persistence/proc/CollectSecretSatchels()
+	satchel_blacklist = typecacheof(list(/obj/item/stack/tile/plasteel, /obj/item/crowbar))
+	var/list/satchels_to_add = list()
+	for(var/A in new_secret_satchels)
+		var/obj/item/storage/backpack/satchel/flat/F = A
+		if(QDELETED(F) || F.z != SSmapping.station_start || F.invisibility != INVISIBILITY_MAXIMUM)
+			continue
+		var/list/savable_obj = list()
+		for(var/obj/O in F)
+			if(is_type_in_typecache(O, satchel_blacklist) || (O.flags_1 & ADMIN_SPAWNED_1))
+				continue
+			if(O.persistence_replacement)
+				savable_obj += O.persistence_replacement
+			else
+				savable_obj += O.type
+		if(isemptylist(savable_obj))
+			continue
+		var/list/data = list()
+		data["x"] = F.x
+		data["y"] = F.y
+		data["saved_obj"] = pick(savable_obj)
+		satchels_to_add += list(data)
+
+	var/json_file = file("data/npc_saves/SecretSatchels[SSmapping.config.map_name].json")
+	var/list/file_data = list()
+	fdel(json_file)
+	file_data["data"] = old_secret_satchels + satchels_to_add
+	WRITE_FILE(json_file, json_encode(file_data))
+
+/datum/controller/subsystem/persistence/proc/CollectChiselMessages()
+	var/json_file = file("data/npc_saves/ChiselMessages[SSmapping.config.map_name].json")
+
+	for(var/obj/structure/chisel_message/M in chisel_messages)
+		saved_messages += list(M.pack())
+
+	log_world("Saved [saved_messages.len] engraved messages on map [SSmapping.config.map_name]")
+	var/list/file_data = list()
+	file_data["data"] = saved_messages
+	fdel(json_file)
+	WRITE_FILE(json_file, json_encode(file_data))
+
+/datum/controller/subsystem/persistence/proc/SaveChiselMessage(obj/structure/chisel_message/M)
+	saved_messages += list(M.pack()) // dm eats one list
+
+
+/datum/controller/subsystem/persistence/proc/CollectTrophies()
+	var/json_file = file("data/npc_saves/TrophyItems.json")
+	var/list/file_data = list()
+	file_data["data"] = remove_duplicate_trophies(saved_trophies)
+	fdel(json_file)
+	WRITE_FILE(json_file, json_encode(file_data))
+
+/datum/controller/subsystem/persistence/proc/remove_duplicate_trophies(list/trophies)
+	var/list/ukeys = list()
+	. = list()
+	for(var/trophy in trophies)
+		var/tkey = "[trophy["path"]]-[trophy["message"]]"
+		if(ukeys[tkey])
+			continue
+		else
+			. += list(trophy)
+			ukeys[tkey] = TRUE
+
+/datum/controller/subsystem/persistence/proc/SaveTrophy(obj/structure/displaycase/trophy/T)
+	if(!T.added_roundstart && T.showpiece)
+		var/list/data = list()
+		data["path"] = T.showpiece.type
+		data["message"] = T.trophy_message
+		data["placer_key"] = T.placer_key
+		saved_trophies += list(data)
+
+/datum/controller/subsystem/persistence/proc/CollectRoundtype()
+	saved_modes[3] = saved_modes[2]
+	saved_modes[2] = saved_modes[1]
+	saved_modes[1] = SSticker.mode.config_tag
+	var/json_file = file("data/RecentModes.json")
+	var/list/file_data = list()
+	file_data["data"] = saved_modes
+	fdel(json_file)
+	WRITE_FILE(json_file, json_encode(file_data))
+
+/datum/controller/subsystem/persistence/proc/CollectAntagReputation()
+	var/ANTAG_REP_MAXIMUM = CONFIG_GET(number/antag_rep_maximum)
+
+	for(var/p_ckey in antag_rep_change)
+//		var/start = antag_rep[p_ckey]
+		antag_rep[p_ckey] = max(0, min(antag_rep[p_ckey]+antag_rep_change[p_ckey], ANTAG_REP_MAXIMUM))
+
+//		WARNING("AR_DEBUG: [p_ckey]: Committed [antag_rep_change[p_ckey]] reputation, going from [start] to [antag_rep[p_ckey]]")
+
+	antag_rep_change = list()
+
+	fdel(FILE_ANTAG_REP)
+	text2file(json_encode(antag_rep), FILE_ANTAG_REP)
+
+/datum/controller/subsystem/persistence/proc/LoadRandomizedRecipes()
+	var/json_file = file("data/RandomizedChemRecipes.json")
+	var/json
+	if(fexists(json_file))
+		json = json_decode(file2text(json_file))
+
+	for(var/randomized_type in subtypesof(/datum/chemical_reaction/randomized))
+		var/datum/chemical_reaction/randomized/R = new randomized_type
+		var/loaded = FALSE
+		if(R.persistent && json)
+			var/list/recipe_data = json[R.id]
+			if(recipe_data && R.LoadOldRecipe(recipe_data) && (daysSince(R.created) <= R.persistence_period))
+				loaded = TRUE
+		if(!loaded) //We do not have information for whatever reason, just generate new one
+			R.GenerateRecipe()
+
+		if(!R.HasConflicts()) //Might want to try again if conflicts happened in the future.
+			add_chemical_reaction(R)
+
+/datum/controller/subsystem/persistence/proc/SaveRandomizedRecipes()
+	var/json_file = file("data/RandomizedChemRecipes.json")
+	var/list/file_data = list()
+
+	//asert globchems done
+	for(var/randomized_type in subtypesof(/datum/chemical_reaction/randomized))
+		var/datum/chemical_reaction/randomized/R = randomized_type
+		R = get_chemical_reaction(initial(R.id)) //ew, would be nice to add some simple tracking
+		if(R && R.persistent && R.id)
+			var/recipe_data = list()
+			recipe_data["timestamp"] = R.created
+			recipe_data["required_reagents"] = R.required_reagents
+			recipe_data["required_catalysts"] = R.required_catalysts
+			recipe_data["required_temp"] = R.required_temp
+			recipe_data["is_cold_recipe"] = R.is_cold_recipe
+			recipe_data["results"] = R.results
+			recipe_data["required_container"] = "[R.required_container]"
+			file_data["[R.id]"] = recipe_data
+
+	fdel(json_file)
+	WRITE_FILE(json_file, json_encode(file_data))

code/controllers/subsystem/ping.dm

@@ -0,0 +1,33 @@
+SUBSYSTEM_DEF(ping)
+	name = "Ping"
+	priority = FIRE_PRIORITY_PING
+	wait = 3 SECONDS
+	flags = SS_NO_INIT
+	runlevels = RUNLEVEL_LOBBY | RUNLEVEL_SETUP | RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+
+/datum/controller/subsystem/ping/stat_entry()
+	..("P:[GLOB.clients.len]")
+
+
+/datum/controller/subsystem/ping/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = GLOB.clients.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while (currentrun.len)
+		var/client/C = currentrun[currentrun.len]
+		currentrun.len--
+
+		if (!C || !C.chatOutput || !C.chatOutput.loaded)
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		// softPang isn't handled anywhere but it'll always reset the opts.lastPang.
+		C.chatOutput.ehjax_send(data = C.is_afk(29) ? "softPang" : "pang")
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/processing/chemistry.dm

@@ -0,0 +1,5 @@
+PROCESSING_SUBSYSTEM_DEF(chemistry)
+	wait = 5
+	flags = SS_KEEP_TIMING
+
+

code/controllers/subsystem/processing/circuit.dm

@@ -0,0 +1,95 @@
+PROCESSING_SUBSYSTEM_DEF(circuit)
+	name = "Circuit"
+	stat_tag = "CIR"
+	init_order = INIT_ORDER_CIRCUIT
+	flags = NONE
+
+	var/cipherkey
+
+	var/list/all_components = list()								// Associative list of [component_name]:[component_path] pairs
+	var/list/cached_components = list()								// Associative list of [component_path]:[component] pairs
+	var/list/all_assemblies = list()								// Associative list of [assembly_name]:[assembly_path] pairs
+	var/list/cached_assemblies = list()								// Associative list of [assembly_path]:[assembly] pairs
+	var/list/all_circuits = list()									// Associative list of [circuit_name]:[circuit_path] pairs
+	var/list/circuit_fabricator_recipe_list = list()				// Associative list of [category_name]:[list_of_circuit_paths] pairs
+	var/cost_multiplier = MINERAL_MATERIAL_AMOUNT / 10 // Each circuit cost unit is 200cm3
+
+/datum/controller/subsystem/processing/circuit/Initialize(start_timeofday)
+	SScircuit.cipherkey = uppertext(random_string(2000+rand(0,10), GLOB.alphabet))
+	circuits_init()
+	return ..()
+
+/datum/controller/subsystem/processing/circuit/proc/circuits_init()
+	//Cached lists for free performance
+	for(var/path in typesof(/obj/item/integrated_circuit))
+		var/obj/item/integrated_circuit/IC = path
+		var/name = initial(IC.name)
+		all_components[name] = path // Populating the component lists
+		cached_components[IC] = new path
+
+		if(!(initial(IC.spawn_flags) & (IC_SPAWN_DEFAULT | IC_SPAWN_RESEARCH)))
+			continue
+
+		var/category = initial(IC.category_text)
+		if(!circuit_fabricator_recipe_list[category])
+			circuit_fabricator_recipe_list[category] = list()
+		var/list/category_list = circuit_fabricator_recipe_list[category]
+		category_list += IC // Populating the fabricator categories
+
+	for(var/path in typesof(/obj/item/electronic_assembly))
+		var/obj/item/electronic_assembly/A = path
+		var/name = initial(A.name)
+		all_assemblies[name] = path
+		cached_assemblies[A] = new path
+
+
+	circuit_fabricator_recipe_list["Assemblies"] = list(
+		/obj/item/electronic_assembly/default,
+		/obj/item/electronic_assembly/calc,
+		/obj/item/electronic_assembly/clam,
+		/obj/item/electronic_assembly/simple,
+		/obj/item/electronic_assembly/hook,
+		/obj/item/electronic_assembly/pda,
+		/obj/item/electronic_assembly/dildo,
+		/obj/item/electronic_assembly/small/default,
+		/obj/item/electronic_assembly/small/cylinder,
+		/obj/item/electronic_assembly/small/scanner,
+		/obj/item/electronic_assembly/small/hook,
+		/obj/item/electronic_assembly/small/box,
+		/obj/item/electronic_assembly/small/dildo,
+		/obj/item/electronic_assembly/medium/default,
+		/obj/item/electronic_assembly/medium/box,
+		/obj/item/electronic_assembly/medium/clam,
+		/obj/item/electronic_assembly/medium/medical,
+		/obj/item/electronic_assembly/medium/gun,
+		/obj/item/electronic_assembly/medium/radio,
+		/obj/item/electronic_assembly/medium/dildo,
+		/obj/item/electronic_assembly/large/default,
+		/obj/item/electronic_assembly/large/scope,
+		/obj/item/electronic_assembly/large/terminal,
+		/obj/item/electronic_assembly/large/arm,
+		/obj/item/electronic_assembly/large/tall,
+		/obj/item/electronic_assembly/large/industrial,
+		/obj/item/electronic_assembly/drone/default,
+		/obj/item/electronic_assembly/drone/arms,
+		/obj/item/electronic_assembly/drone/secbot,
+		/obj/item/electronic_assembly/drone/medbot,
+		/obj/item/electronic_assembly/drone/genbot,
+		/obj/item/electronic_assembly/drone/android,
+		/obj/item/electronic_assembly/wallmount/tiny,
+		/obj/item/electronic_assembly/wallmount/light,
+		/obj/item/electronic_assembly/wallmount,
+		/obj/item/electronic_assembly/wallmount/heavy
+		///obj/item/weapon/implant/integrated_circuit
+		)
+
+	circuit_fabricator_recipe_list["Tools"] = list(
+		/obj/item/integrated_electronics/wirer,
+		/obj/item/integrated_electronics/debugger,
+		/obj/item/integrated_electronics/analyzer,
+		/obj/item/integrated_electronics/detailer,
+		/obj/item/card/data,
+		/obj/item/card/data/full_color,
+		/obj/item/card/data/disk
+		)
+

code/controllers/subsystem/processing/fastprocess.dm

@@ -0,0 +1,6 @@
+//Fires five times every second.
+
+PROCESSING_SUBSYSTEM_DEF(fastprocess)
+	name = "Fast Processing"
+	wait = 2
+	stat_tag = "FP"

code/controllers/subsystem/processing/fields.dm

@@ -0,0 +1,6 @@
+PROCESSING_SUBSYSTEM_DEF(fields)
+	name = "Fields"
+	wait = 2
+	priority = FIRE_PRIORITY_FIELDS
+	flags = SS_KEEP_TIMING | SS_NO_INIT
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME

code/controllers/subsystem/processing/flightpacks.dm

@@ -0,0 +1,25 @@
+PROCESSING_SUBSYSTEM_DEF(flightpacks)
+	name = "Flightpack Movement"
+	priority = FIRE_PRIORITY_FLIGHTPACKS
+	wait = 2
+	stat_tag = "FM"
+	flags = SS_NO_INIT|SS_TICKER|SS_KEEP_TIMING
+
+	var/flightsuit_processing = FLIGHTSUIT_PROCESSING_FULL
+
+/datum/controller/subsystem/processing/flightpacks/Initialize()
+	sync_flightsuit_processing()
+
+/datum/controller/subsystem/processing/flightpacks/vv_edit_var(var_name, var_value)
+	..()
+	switch(var_name)
+		if("flightsuit_processing")
+			sync_flightsuit_processing()
+
+/datum/controller/subsystem/processing/flightpacks/proc/sync_flightsuit_processing()
+	for(var/obj/item/flightpack/FP in processing)
+		FP.sync_processing(src)
+	if(flightsuit_processing == FLIGHTSUIT_PROCESSING_NONE)	//Don't even bother firing.
+		can_fire = FALSE
+	else
+		can_fire = TRUE

code/controllers/subsystem/processing/nanites.dm

@@ -0,0 +1,21 @@
+PROCESSING_SUBSYSTEM_DEF(nanites)
+	name = "Nanites"
+	flags = SS_BACKGROUND|SS_POST_FIRE_TIMING|SS_NO_INIT
+	wait = 10
+
+	var/list/datum/nanite_cloud_backup/cloud_backups = list()
+	var/list/mob/living/nanite_monitored_mobs = list()
+	var/list/datum/nanite_program/relay/nanite_relays = list()
+
+/datum/controller/subsystem/processing/nanites/proc/check_hardware(datum/nanite_cloud_backup/backup)
+	if(QDELETED(backup.storage) || (backup.storage.stat & (NOPOWER|BROKEN)))
+		return FALSE
+	return TRUE
+
+/datum/controller/subsystem/processing/nanites/proc/get_cloud_backup(cloud_id, force = FALSE)
+	for(var/I in cloud_backups)
+		var/datum/nanite_cloud_backup/backup = I
+		if(!force && !check_hardware(backup))
+			return
+		if(backup.cloud_id == cloud_id)
+			return backup

code/controllers/subsystem/processing/networks.dm

@@ -0,0 +1,51 @@
+PROCESSING_SUBSYSTEM_DEF(networks)
+	name = "Networks"
+	priority = FIRE_PRIORITY_NETWORKS
+	wait = 1
+	stat_tag = "NET"
+	flags = SS_KEEP_TIMING
+	init_order = INIT_ORDER_NETWORKS
+	var/datum/ntnet/station/station_network
+	var/assignment_hardware_id = HID_RESTRICTED_END
+	var/list/networks_by_id = list()				//id = network
+	var/list/interfaces_by_id = list()				//hardware id = component interface
+	var/resolve_collisions = TRUE
+
+/datum/controller/subsystem/processing/networks/Initialize()
+	station_network = new
+	station_network.register_map_supremecy()
+	. = ..()
+
+/datum/controller/subsystem/processing/networks/proc/register_network(datum/ntnet/network)
+	if(!networks_by_id[network.network_id])
+		networks_by_id[network.network_id] = network
+		return TRUE
+	return FALSE
+
+/datum/controller/subsystem/processing/networks/proc/unregister_network(datum/ntnet/network)
+	networks_by_id -= network.network_id
+	return TRUE
+
+/datum/controller/subsystem/processing/networks/proc/register_interface(datum/component/ntnet_interface/D)
+	if(!interfaces_by_id[D.hardware_id])
+		interfaces_by_id[D.hardware_id] = D
+		return TRUE
+	return FALSE
+
+/datum/controller/subsystem/processing/networks/proc/unregister_interface(datum/component/ntnet_interface/D)
+	interfaces_by_id -= D.hardware_id
+	return TRUE
+
+/datum/controller/subsystem/processing/networks/proc/get_next_HID()
+	var/string = "[num2text(assignment_hardware_id++, 12)]"
+	return make_address(string)
+
+/datum/controller/subsystem/processing/networks/proc/make_address(string)
+	if(!string)
+		return resolve_collisions? make_address("[num2text(rand(HID_RESTRICTED_END, 999999999), 12)]"):null
+	var/hex = md5(string)
+	if(!hex)
+		return		//errored
+	. = "[copytext(hex, 1, 9)]"		//16 ^ 8 possibilities I think.
+	if(interfaces_by_id[.])
+		return resolve_collisions? make_address("[num2text(rand(HID_RESTRICTED_END, 999999999), 12)]"):null

code/controllers/subsystem/processing/obj.dm

@@ -0,0 +1,5 @@
+PROCESSING_SUBSYSTEM_DEF(obj)
+	name = "Objects"
+	priority = FIRE_PRIORITY_OBJ
+	flags = SS_NO_INIT
+	wait = 20

code/controllers/subsystem/processing/processing.dm

@@ -0,0 +1,35 @@
+//Used to process objects. Fires once every second.
+
+SUBSYSTEM_DEF(processing)
+	name = "Processing"
+	priority = FIRE_PRIORITY_PROCESS
+	flags = SS_BACKGROUND|SS_POST_FIRE_TIMING|SS_NO_INIT
+	wait = 10
+
+	var/stat_tag = "P" //Used for logging
+	var/list/processing = list()
+	var/list/currentrun = list()
+
+/datum/controller/subsystem/processing/stat_entry()
+	..("[stat_tag]:[processing.len]")
+
+/datum/controller/subsystem/processing/fire(resumed = 0)
+	if (!resumed)
+		currentrun = processing.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/current_run = currentrun
+
+	while(current_run.len)
+		var/datum/thing = current_run[current_run.len]
+		current_run.len--
+		if(QDELETED(thing))
+			processing -= thing
+		else if(thing.process(wait) == PROCESS_KILL)
+			// fully stop so that a future START_PROCESSING will work
+			STOP_PROCESSING(src, thing)
+		if (MC_TICK_CHECK)
+			return
+
+/datum/proc/process()
+	set waitfor = 0
+	return PROCESS_KILL

code/controllers/subsystem/processing/projectiles.dm

@@ -0,0 +1,23 @@
+PROCESSING_SUBSYSTEM_DEF(projectiles)
+	name = "Projectiles"
+	wait = 1
+	stat_tag = "PP"
+	flags = SS_NO_INIT|SS_TICKER
+	var/global_max_tick_moves = 10
+	var/global_pixel_speed = 2
+	var/global_iterations_per_move = 16
+
+/datum/controller/subsystem/processing/projectiles/proc/set_pixel_speed(new_speed)
+	global_pixel_speed = new_speed
+	for(var/i in processing)
+		var/obj/item/projectile/P = i
+		if(istype(P))			//there's non projectiles on this too.
+			P.set_pixel_speed(new_speed)
+
+/datum/controller/subsystem/processing/projectiles/vv_edit_var(var_name, var_value)
+	switch(var_name)
+		if(NAMEOF(src, global_pixel_speed))
+			set_pixel_speed(var_value)
+			return TRUE
+		else
+			return ..()

code/controllers/subsystem/processing/quirks.dm

@@ -0,0 +1,92 @@
+//Used to process and handle roundstart quirks
+// - Quirk strings are used for faster checking in code
+// - Quirk datums are stored and hold different effects, as well as being a vector for applying trait string
+PROCESSING_SUBSYSTEM_DEF(quirks)
+	name = "Quirks"
+	init_order = INIT_ORDER_QUIRKS
+	flags = SS_BACKGROUND
+	wait = 10
+	runlevels = RUNLEVEL_GAME
+
+	var/list/quirks = list()		//Assoc. list of all roundstart quirk datum types; "name" = /path/
+	var/list/quirk_names_by_path = list()
+	var/list/quirk_points = list()	//Assoc. list of quirk names and their "point cost"; positive numbers are good traits, and negative ones are bad
+	var/list/quirk_objects = list()	//A list of all quirk objects in the game, since some may process
+
+/datum/controller/subsystem/processing/quirks/Initialize(timeofday)
+	if(!quirks.len)
+		SetupQuirks()
+	return ..()
+
+/datum/controller/subsystem/processing/quirks/proc/SetupQuirks()
+	for(var/V in subtypesof(/datum/quirk))
+		var/datum/quirk/T = V
+		quirks[initial(T.name)] = T
+		quirk_points[initial(T.name)] = initial(T.value)
+		quirk_names_by_path[T] = initial(T.name)
+
+/datum/controller/subsystem/processing/quirks/proc/AssignQuirks(mob/living/user, client/cli, spawn_effects, roundstart = FALSE, datum/job/job, silent = FALSE, mob/to_chat_target)
+	GenerateQuirks(cli)
+	var/list/quirks = cli.prefs.character_quirks.Copy()
+	var/list/cut
+	if(job && job.blacklisted_quirks)
+		cut = filter_quirks(quirks, job)
+	for(var/V in quirks)
+		user.add_quirk(V, spawn_effects)
+	if(!silent && LAZYLEN(cut))
+		to_chat(to_chat_target || user, "<span class='boldwarning'>All of your non-neutral character quirks have been cut due to these quirks conflicting with your job assignment: [english_list(cut)].</span>")
+
+/datum/controller/subsystem/processing/quirks/proc/quirk_path_by_name(name)
+	return quirks[name]
+
+/datum/controller/subsystem/processing/quirks/proc/quirk_points_by_name(name)
+	return quirk_points[name]
+
+/datum/controller/subsystem/processing/quirks/proc/quirk_name_by_path(path)
+	return quirk_names_by_path[path]
+
+/datum/controller/subsystem/processing/quirks/proc/total_points(list/quirk_names)
+	. = 0
+	for(var/i in quirk_names)
+		. += quirk_points_by_name(i)
+
+/datum/controller/subsystem/processing/quirks/proc/filter_quirks(list/quirks, datum/job/job)
+	var/list/cut = list()
+	var/list/banned_names = list()
+	for(var/i in job.blacklisted_quirks)
+		var/name = quirk_name_by_path(i)
+		if(name)
+			banned_names += name
+	var/list/blacklisted = quirks & banned_names
+	if(length(blacklisted))
+		for(var/i in blacklisted)
+			quirks -= i
+			cut += i
+
+	/*	//Code to automatically reduce positive quirks until balance is even.
+	var/points_used = total_points(quirks)
+	if(points_used > 0)
+		//they owe us points, let's collect.
+		for(var/i in quirks)
+			var/points = quirk_points_by_name(i)
+			if(points > 0)
+				cut += i
+				quirks -= i
+				points_used -= points
+			if(points_used <= 0)
+				break
+	*/
+
+	//Nah, let's null all non-neutrals out.
+	if(cut.len)
+		for(var/i in quirks)
+			if(quirk_points_by_name(i) != 0)
+				//cut += i		-- Commented out: Only show the ones that triggered the quirk purge.
+				quirks -= i
+
+	return cut
+
+/datum/controller/subsystem/processing/quirks/proc/GenerateQuirks(client/user)
+	if(user.prefs.character_quirks.len)
+		return
+	user.prefs.character_quirks = user.prefs.all_quirks

code/controllers/subsystem/processing/wet_floors.dm

@@ -0,0 +1,7 @@
+PROCESSING_SUBSYSTEM_DEF(wet_floors)
+	name = "Wet floors"
+	priority = FIRE_PRIORITY_WET_FLOORS
+	wait = 10
+	stat_tag = "WFP" //Used for logging
+	var/temperature_coeff = 2
+	var/time_ratio = 1.5 SECONDS

code/controllers/subsystem/radiation.dm

@@ -0,0 +1,17 @@
+PROCESSING_SUBSYSTEM_DEF(radiation)
+	name = "Radiation"
+	flags = SS_NO_INIT | SS_BACKGROUND
+
+	var/list/warned_atoms = list()
+
+/datum/controller/subsystem/processing/radiation/proc/warn(datum/component/radioactive/contamination)
+	if(!contamination || QDELETED(contamination))
+		return
+	var/ref = REF(contamination.parent)
+	if(warned_atoms[ref])
+		return
+	warned_atoms[ref] = TRUE
+	var/atom/master = contamination.parent
+	SSblackbox.record_feedback("tally", "contaminated", 1, master.type)
+	var/msg = "has become contamintaed with enough radiation to contaminate other objects. || Source: [contamination.source] || Strength: [contamination.strength]"
+	master.investigate_log(msg, INVESTIGATE_RADIATION)

code/controllers/subsystem/radio.dm

@@ -0,0 +1,35 @@
+SUBSYSTEM_DEF(radio)
+	name = "Radio"
+	flags = SS_NO_FIRE|SS_NO_INIT
+
+	var/list/datum/radio_frequency/frequencies = list()
+	var/list/saymodes = list()
+
+/datum/controller/subsystem/radio/PreInit(timeofday)
+	for(var/_SM in subtypesof(/datum/saymode))
+		var/datum/saymode/SM = new _SM()
+		saymodes[SM.key] = SM
+	return ..()
+
+/datum/controller/subsystem/radio/proc/add_object(obj/device, new_frequency as num, filter = null as text|null)
+	var/f_text = num2text(new_frequency)
+	var/datum/radio_frequency/frequency = frequencies[f_text]
+	if(!frequency)
+		frequencies[f_text] = frequency = new(new_frequency)
+	frequency.add_listener(device, filter)
+	return frequency
+
+/datum/controller/subsystem/radio/proc/remove_object(obj/device, old_frequency)
+	var/f_text = num2text(old_frequency)
+	var/datum/radio_frequency/frequency = frequencies[f_text]
+	if(frequency)
+		frequency.remove_listener(device)
+		// let's don't delete frequencies in case a non-listener keeps a reference
+	return 1
+
+/datum/controller/subsystem/radio/proc/return_frequency(new_frequency as num)
+	var/f_text = num2text(new_frequency)
+	var/datum/radio_frequency/frequency = frequencies[f_text]
+	if(!frequency)
+		frequencies[f_text] = frequency = new(new_frequency)
+	return frequency

code/controllers/subsystem/research.dm

@@ -0,0 +1,335 @@
+
+SUBSYSTEM_DEF(research)
+	name = "Research"
+	priority = FIRE_PRIORITY_RESEARCH
+	wait = 10
+	init_order = INIT_ORDER_RESEARCH
+	var/list/invalid_design_ids = list()		//associative id = number of times
+	var/list/invalid_node_ids = list()			//associative id = number of times
+	var/list/invalid_node_boost = list()		//associative id = error message
+	var/list/obj/machinery/rnd/server/servers = list()
+	var/datum/techweb/science/science_tech
+	var/datum/techweb/admin/admin_tech
+	var/list/techweb_nodes = list()				//associative id = node datum
+	var/list/techweb_categories = list()		//category name = list(node.id = node)
+	var/list/techweb_designs = list()			//associative id = node datum
+	var/list/techweb_nodes_starting = list()	//associative id = node datum
+	var/list/techweb_boost_items = list()		//associative double-layer path = list(id = list(point_type = point_discount))
+	var/list/techweb_nodes_hidden = list()		//Nodes that should be hidden by default.
+	var/list/techweb_point_items = list(		//path = list(point type = value)
+	/obj/item/assembly/signaler/anomaly = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/assembly/signaler/anomaly = list(TECHWEB_POINT_TYPE_GENERIC = 5000),   // Cit three more anomalys anomalys
+	/obj/item/assembly/signaler/anomaly = list(TECHWEB_POINT_TYPE_GENERIC = 7500),
+	/obj/item/assembly/signaler/anomaly = list(TECHWEB_POINT_TYPE_GENERIC = 10000),
+	//   -   Slime Extracts!   - 
+	/obj/item/slime_extract/grey = list(TECHWEB_POINT_TYPE_GENERIC = 500),    // Adds in slime core deconing
+	/obj/item/slime_extract/metal = list(TECHWEB_POINT_TYPE_GENERIC = 750),
+	/obj/item/slime_extract/purple = list(TECHWEB_POINT_TYPE_GENERIC = 750),
+	/obj/item/slime_extract/orange = list(TECHWEB_POINT_TYPE_GENERIC = 750),
+	/obj/item/slime_extract/blue = list(TECHWEB_POINT_TYPE_GENERIC = 750),
+	/obj/item/slime_extract/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 1000),
+	/obj/item/slime_extract/silver = list(TECHWEB_POINT_TYPE_GENERIC = 1000),
+	/obj/item/slime_extract/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 1000),
+	/obj/item/slime_extract/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 1000),
+	/obj/item/slime_extract/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/red = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/green = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/pink = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/gold = list(TECHWEB_POINT_TYPE_GENERIC = 1250),
+	/obj/item/slime_extract/black = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slime_extract/adamantine =list (TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slime_extract/oil = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slime_extract/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slime_extract/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+		//  Reproductive -    Crossbreading Cores!    - (Grey Cores)
+	/obj/item/slimecross/reproductive/grey = list(TECHWEB_POINT_TYPE_GENERIC = 1000),
+	/obj/item/slimecross/reproductive/orange = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slimecross/reproductive/purple = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slimecross/reproductive/blue = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slimecross/reproductive/metal = list(TECHWEB_POINT_TYPE_GENERIC = 1500),
+	/obj/item/slimecross/reproductive/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 1750),
+	/obj/item/slimecross/reproductive/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 1750),
+	/obj/item/slimecross/reproductive/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 1750),
+	/obj/item/slimecross/reproductive/silver = list(TECHWEB_POINT_TYPE_GENERIC = 1750),
+	/obj/item/slimecross/reproductive/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/reproductive/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/reproductive/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/reproductive/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/reproductive/red = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/reproductive/green = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/reproductive/pink = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/reproductive/gold = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/reproductive/oil = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/reproductive/black = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/reproductive/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/reproductive/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/reproductive/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	//  Burning -    Crossbreading Cores!    - (Orange Cores)
+	/obj/item/slimecross/burning/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/burning/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/burning/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/burning/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/burning/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/burning/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/burning/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/burning/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/burning/silver = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/burning/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/burning/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/burning/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/burning/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/burning/red = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/burning/green = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/burning/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/burning/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/burning/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/burning/black = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/burning/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/burning/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/burning/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+		//  Regenerative -    Crossbreading Cores!    - (Purple Cores)
+	/obj/item/slimecross/regenerative/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/regenerative/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/regenerative/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/regenerative/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/regenerative/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/regenerative/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/regenerative/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/regenerative/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/regenerative/silver = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/regenerative/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/regenerative/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/regenerative/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/regenerative/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/regenerative/red = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/regenerative/green = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/regenerative/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/regenerative/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/regenerative/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/regenerative/black = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/regenerative/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/regenerative/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/regenerative/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+		//  Stabilized -    Crossbreading Cores!    - (Blue Cores)
+	/obj/item/slimecross/stabilized/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/stabilized/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/stabilized/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/stabilized/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/stabilized/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/stabilized/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/stabilized/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/stabilized/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/stabilized/silver = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/stabilized/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/stabilized/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/stabilized/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/stabilized/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/stabilized/red = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/stabilized/green = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/stabilized/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/stabilized/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/stabilized/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/stabilized/black = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/stabilized/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/stabilized/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/stabilized/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+		//  Industrial -    Crossbreading Cores!    - (Metal Cores)
+	/obj/item/slimecross/industrial/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2000),
+	/obj/item/slimecross/industrial/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/industrial/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/industrial/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/industrial/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/industrial/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/industrial/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/industrial/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/industrial/silver = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/industrial/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/industrial/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/industrial/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/industrial/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/industrial/red = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/industrial/green = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/industrial/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/industrial/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/industrial/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/industrial/black = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/industrial/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/industrial/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/industrial/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+		//  Charged -    Crossbreading Cores!    - (Yellow Cores)
+	/obj/item/slimecross/charged/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/charged/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/charged/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/charged/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/charged/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/charged/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/charged/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/charged/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/charged/silver = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/charged/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/charged/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/charged/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/charged/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/charged/red = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/charged/green = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/charged/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/charged/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/charged/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/charged/black = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/charged/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/charged/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/charged/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+			//  Selfsustaining -    Crossbreading Cores!    - (Dark Purple Cores)
+	/obj/item/slimecross/selfsustaining/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/selfsustaining/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/selfsustaining/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/selfsustaining/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/selfsustaining/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/selfsustaining/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/selfsustaining/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/selfsustaining/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/selfsustaining/silver = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/selfsustaining/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/selfsustaining/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/selfsustaining/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/selfsustaining/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/selfsustaining/red = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/selfsustaining/green = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/selfsustaining/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/selfsustaining/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/selfsustaining/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/selfsustaining/black = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/selfsustaining/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/selfsustaining/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/selfsustaining/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+			//  Consuming -    Crossbreading Cores!    - (Sliver Cores)
+	/obj/item/slimecross/consuming/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2250),
+	/obj/item/slimecross/consuming/orange = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/consuming/purple = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/consuming/blue = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/consuming/metal = list(TECHWEB_POINT_TYPE_GENERIC = 2750),
+	/obj/item/slimecross/consuming/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/consuming/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/consuming/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/consuming/silver = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/consuming/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/consuming/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/consuming/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/consuming/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/consuming/red = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/consuming/green = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/consuming/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/consuming/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/consuming/oil = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/consuming/black = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/consuming/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/consuming/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/consuming/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+		//  Prismatic -    Crossbreading Cores!    - (Pyrite Cores)
+	/obj/item/slimecross/prismatic/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/prismatic/orange = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/prismatic/purple = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/prismatic/blue = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/prismatic/metal = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/prismatic/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/prismatic/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/prismatic/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/prismatic/silver = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/prismatic/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/prismatic/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/prismatic/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/prismatic/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/prismatic/red = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/prismatic/green = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/prismatic/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/prismatic/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/prismatic/oil = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/prismatic/black = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/prismatic/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/prismatic/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/prismatic/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 4250),
+		//  Recurring -    Crossbreading Cores!    - (Cerulean Cores)
+	/obj/item/slimecross/recurring/grey = list(TECHWEB_POINT_TYPE_GENERIC = 2500),
+	/obj/item/slimecross/recurring/orange = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/recurring/purple = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/recurring/blue = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/recurring/metal = list(TECHWEB_POINT_TYPE_GENERIC = 3000),
+	/obj/item/slimecross/recurring/yellow = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/recurring/darkpurple = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/recurring/darkblue = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/recurring/silver = list(TECHWEB_POINT_TYPE_GENERIC = 3250),
+	/obj/item/slimecross/recurring/bluespace = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/recurring/sepia = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/recurring/cerulean = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/recurring/pyrite = list(TECHWEB_POINT_TYPE_GENERIC = 3500),
+	/obj/item/slimecross/recurring/red = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/recurring/green = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/recurring/pink = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/recurring/gold = list(TECHWEB_POINT_TYPE_GENERIC = 3750),
+	/obj/item/slimecross/recurring/oil = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/recurring/black = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/recurring/lightpink = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/recurring/adamantine = list(TECHWEB_POINT_TYPE_GENERIC = 4000),
+	/obj/item/slimecross/recurring/rainbow = list(TECHWEB_POINT_TYPE_GENERIC = 4250)
+	)      // End of Cit changes
+	var/list/errored_datums = list()
+	var/list/point_types = list()				//typecache style type = TRUE list
+	//----------------------------------------------
+	var/list/single_server_income = list(TECHWEB_POINT_TYPE_GENERIC = 35)	//citadel edit - techwebs nerf
+	var/multiserver_calculation = FALSE
+	var/last_income
+	//^^^^^^^^ ALL OF THESE ARE PER SECOND! ^^^^^^^^
+
+	//Aiming for 1.5 hours to max R&D
+	//[88nodes * 5000points/node] / [1.5hr * 90min/hr * 60s/min]
+	//Around 450000 points max???
+
+/datum/controller/subsystem/research/Initialize()
+	point_types = TECHWEB_POINT_TYPE_LIST_ASSOCIATIVE_NAMES
+	initialize_all_techweb_designs()
+	initialize_all_techweb_nodes()
+	science_tech = new /datum/techweb/science
+	admin_tech = new /datum/techweb/admin
+	autosort_categories()
+	return ..()
+
+/datum/controller/subsystem/research/fire()
+	var/list/bitcoins = list()
+	if(multiserver_calculation)
+		var/eff = calculate_server_coefficient()
+		for(var/obj/machinery/rnd/server/miner in servers)
+			var/list/result = (miner.mine())	//SLAVE AWAY, SLAVE.
+			for(var/i in result)
+				result[i] *= eff
+				bitcoins[i] = bitcoins[i]? bitcoins[i] + result[i] : result[i]
+	else
+		for(var/obj/machinery/rnd/server/miner in servers)
+			if(miner.working)
+				bitcoins = single_server_income.Copy()
+				break			//Just need one to work.
+	if (!isnull(last_income))
+		var/income_time_difference = world.time - last_income
+		science_tech.last_bitcoins = bitcoins  // Doesn't take tick drift into account
+		for(var/i in bitcoins)
+			bitcoins[i] *= income_time_difference / 10
+		science_tech.add_point_list(bitcoins)
+	last_income = world.time
+
+/datum/controller/subsystem/research/proc/calculate_server_coefficient()	//Diminishing returns.
+	var/amt = servers.len
+	if(!amt)
+		return 0
+	var/coeff = 100
+	coeff = sqrt(coeff / amt)
+	return coeff
+
+/datum/controller/subsystem/research/proc/autosort_categories()
+	for(var/i in techweb_nodes)
+		var/datum/techweb_node/I = techweb_nodes[i]
+		if(techweb_categories[I.category])
+			techweb_categories[I.category][I.id] = I
+		else
+			techweb_categories[I.category] = list(I.id = I)

code/controllers/subsystem/server_maint.dm

@@ -0,0 +1,64 @@
+#define PING_BUFFER_TIME 25
+
+SUBSYSTEM_DEF(server_maint)
+	name = "Server Tasks"
+	wait = 6
+	flags = SS_POST_FIRE_TIMING
+	priority = FIRE_PRIORITY_SERVER_MAINT
+	init_order = INIT_ORDER_SERVER_MAINT
+	runlevels = RUNLEVEL_LOBBY | RUNLEVELS_DEFAULT
+	var/list/currentrun
+
+/datum/controller/subsystem/server_maint/Initialize(timeofday)
+	if (CONFIG_GET(flag/hub))
+		world.update_hub_visibility(TRUE)
+	return ..()
+
+/datum/controller/subsystem/server_maint/fire(resumed = FALSE)
+	if(!resumed)
+		if(listclearnulls(GLOB.clients))
+			log_world("Found a null in clients list!")
+		if(listclearnulls(GLOB.player_list))
+			log_world("Found a null in player list!")
+		src.currentrun = GLOB.clients.Copy()
+
+	var/list/currentrun = src.currentrun
+	var/round_started = SSticker.HasRoundStarted()
+
+	var/kick_inactive = CONFIG_GET(flag/kick_inactive)
+	var/afk_period
+	if(kick_inactive)
+		afk_period = CONFIG_GET(number/afk_period)
+	for(var/I in currentrun)
+		var/client/C = I
+		//handle kicking inactive players
+		if(round_started && kick_inactive && C.is_afk(afk_period))
+			var/cmob = C.mob
+			if(!(isobserver(cmob) || (isdead(cmob) && C.holder)))
+				log_access("AFK: [key_name(C)]")
+				to_chat(C, "<span class='danger'>You have been inactive for more than [DisplayTimeText(afk_period)] and have been disconnected.</span>")
+				qdel(C)
+
+		if (!(!C || world.time - C.connection_time < PING_BUFFER_TIME || C.inactivity >= (wait-1)))
+			winset(C, null, "command=.update_ping+[world.time+world.tick_lag*TICK_USAGE_REAL/100]")
+
+		if (MC_TICK_CHECK) //one day, when ss13 has 1000 people per server, you guys are gonna be glad I added this tick check
+			return
+
+/datum/controller/subsystem/server_maint/Shutdown()
+	kick_clients_in_lobby("<span class='boldannounce'>The round came to an end with you in the lobby.</span>", TRUE) //second parameter ensures only afk clients are kicked
+	var/server = CONFIG_GET(string/server)
+	for(var/thing in GLOB.clients)
+		if(!thing)
+			continue
+		var/client/C = thing
+		var/datum/chatOutput/co = C.chatOutput
+		if(co)
+			co.ehjax_send(data = "roundrestart")
+		if(server)	//if you set a server location in config.txt, it sends you there instead of trying to reconnect to the same world address. -- NeoFite
+			C << link("byond://[server]")
+	var/tgsversion = world.TgsVersion()
+	if(tgsversion)
+		SSblackbox.record_feedback("text", "server_tools", 1, tgsversion)
+
+#undef PING_BUFFER_TIME

code/controllers/subsystem/shuttle.dm

@@ -0,0 +1,633 @@
+#define MAX_TRANSIT_REQUEST_RETRIES 10
+
+SUBSYSTEM_DEF(shuttle)
+	name = "Shuttle"
+	wait = 10
+	init_order = INIT_ORDER_SHUTTLE
+	flags = SS_KEEP_TIMING|SS_NO_TICK_CHECK
+	runlevels = RUNLEVEL_SETUP | RUNLEVEL_GAME
+
+	var/obj/machinery/shuttle_manipulator/manipulator
+
+	var/list/mobile = list()
+	var/list/stationary = list()
+	var/list/transit = list()
+
+	var/list/transit_requesters = list()
+	var/list/transit_request_failures = list()
+
+		//emergency shuttle stuff
+	var/obj/docking_port/mobile/emergency/emergency
+	var/obj/docking_port/mobile/arrivals/arrivals
+	var/obj/docking_port/mobile/emergency/backup/backup_shuttle
+	var/emergencyCallTime = 6000	//time taken for emergency shuttle to reach the station when called (in deciseconds)
+	var/emergencyDockTime = 1800	//time taken for emergency shuttle to leave again once it has docked (in deciseconds)
+	var/emergencyEscapeTime = 1200	//time taken for emergency shuttle to reach a safe distance after leaving station (in deciseconds)
+	var/area/emergencyLastCallLoc
+	var/emergencyCallAmount = 0		//how many times the escape shuttle was called
+	var/emergencyNoEscape
+	var/emergencyNoRecall = FALSE
+	var/list/hostileEnvironments = list() //Things blocking escape shuttle from leaving
+	var/list/tradeBlockade = list() //Things blocking cargo from leaving.
+	var/supplyBlocked = FALSE
+
+		//supply shuttle stuff
+	var/obj/docking_port/mobile/supply/supply
+	var/ordernum = 1					//order number given to next order
+	var/points = 5000					//number of trade-points we have
+	var/centcom_message = ""			//Remarks from CentCom on how well you checked the last order.
+	var/list/discoveredPlants = list()	//Typepaths for unusual plants we've already sent CentCom, associated with their potencies
+
+	var/list/supply_packs = list()
+	var/list/shoppinglist = list()
+	var/list/requestlist = list()
+	var/list/orderhistory = list()
+
+	var/list/hidden_shuttle_turfs = list() //all turfs hidden from navigation computers associated with a list containing the image hiding them and the type of the turf they are pretending to be
+	var/list/hidden_shuttle_turf_images = list() //only the images from the above list
+
+	var/datum/round_event/shuttle_loan/shuttle_loan
+
+	var/shuttle_purchased = FALSE //If the station has purchased a replacement escape shuttle this round
+	var/list/shuttle_purchase_requirements_met = list() //For keeping track of ingame events that would unlock new shuttles, such as defeating a boss or discovering a secret item
+
+	var/lockdown = FALSE	//disallow transit after nuke goes off
+
+	var/auto_call = 72000 //CIT CHANGE - time before in deciseconds in which the shuttle is auto called. Default is 2ish hours plus 15 for the shuttle. So total is 3.
+	var/realtimeofstart = 0
+
+/datum/controller/subsystem/shuttle/Initialize(timeofday)
+	ordernum = rand(1, 9000)
+
+	for(var/pack in subtypesof(/datum/supply_pack))
+		var/datum/supply_pack/P = new pack()
+		if(!P.contains)
+			continue
+		supply_packs[P.type] = P
+
+	initial_load()
+
+	if(!arrivals)
+		WARNING("No /obj/docking_port/mobile/arrivals placed on the map!")
+	if(!emergency)
+		WARNING("No /obj/docking_port/mobile/emergency placed on the map!")
+	if(!backup_shuttle)
+		WARNING("No /obj/docking_port/mobile/emergency/backup placed on the map!")
+	if(!supply)
+		WARNING("No /obj/docking_port/mobile/supply placed on the map!")
+	realtimeofstart = world.realtime
+	auto_call = CONFIG_GET(number/auto_transfer_delay)
+	return ..()
+
+/datum/controller/subsystem/shuttle/proc/initial_load()
+	if(!istype(manipulator))
+		CRASH("No shuttle manipulator found.")
+
+	for(var/s in stationary)
+		var/obj/docking_port/stationary/S = s
+		S.load_roundstart()
+		CHECK_TICK
+
+/datum/controller/subsystem/shuttle/fire()
+	for(var/thing in mobile)
+		if(!thing)
+			mobile.Remove(thing)
+			continue
+		var/obj/docking_port/mobile/P = thing
+		P.check()
+	for(var/thing in transit)
+		var/obj/docking_port/stationary/transit/T = thing
+		if(!T.owner)
+			qdel(T, force=TRUE)
+		// This next one removes transit docks/zones that aren't
+		// immediately being used. This will mean that the zone creation
+		// code will be running a lot.
+		var/obj/docking_port/mobile/owner = T.owner
+		if(owner)
+			var/idle = owner.mode == SHUTTLE_IDLE
+			var/not_centcom_evac = owner.launch_status == NOLAUNCH
+			var/not_in_use = (!T.get_docked())
+			if(idle && not_centcom_evac && not_in_use)
+				qdel(T, force=TRUE)
+	CheckAutoEvac()
+
+	if(!SSmapping.clearing_reserved_turfs)
+		while(transit_requesters.len)
+			var/requester = popleft(transit_requesters)
+			var/success = generate_transit_dock(requester)
+			if(!success) // BACK OF THE QUEUE
+				transit_request_failures[requester]++
+				if(transit_request_failures[requester] < MAX_TRANSIT_REQUEST_RETRIES)
+					transit_requesters += requester
+				else
+					var/obj/docking_port/mobile/M = requester
+					M.transit_failure()
+			if(MC_TICK_CHECK)
+				break
+
+/datum/controller/subsystem/shuttle/proc/CheckAutoEvac()
+	if(emergencyNoEscape || emergencyNoRecall || !emergency || !SSticker.HasRoundStarted())
+		return
+
+	var/threshold = CONFIG_GET(number/emergency_shuttle_autocall_threshold)
+	if(!threshold)
+		return
+
+	var/alive = 0
+	for(var/I in GLOB.player_list)
+		var/mob/M = I
+		if(M.stat != DEAD)
+			++alive
+
+	var/total = GLOB.joined_player_list.len
+
+	if(alive / total <= threshold)
+		var/msg = "Automatically dispatching shuttle due to crew death."
+		message_admins(msg)
+		log_game("[msg] Alive: [alive], Roundstart: [total], Threshold: [threshold]")
+		emergencyNoRecall = TRUE
+		priority_announce("Catastrophic casualties detected: crisis shuttle protocols activated - jamming recall signals across all frequencies.")
+		if(emergency.timeLeft(1) > emergencyCallTime * 0.4)
+			emergency.request(null, set_coefficient = 0.4)
+
+/datum/controller/subsystem/shuttle/proc/block_recall(lockout_timer)
+	emergencyNoRecall = TRUE
+	addtimer(CALLBACK(src, .proc/unblock_recall), lockout_timer)
+
+/datum/controller/subsystem/shuttle/proc/unblock_recall()
+	emergencyNoRecall = FALSE
+
+/datum/controller/subsystem/shuttle/proc/getShuttle(id)
+	for(var/obj/docking_port/mobile/M in mobile)
+		if(M.id == id)
+			return M
+	WARNING("couldn't find shuttle with id: [id]")
+
+/datum/controller/subsystem/shuttle/proc/getDock(id)
+	for(var/obj/docking_port/stationary/S in stationary)
+		if(S.id == id)
+			return S
+	WARNING("couldn't find dock with id: [id]")
+
+/datum/controller/subsystem/shuttle/proc/requestEvac(mob/user, call_reason)
+	if(!emergency)
+		WARNING("requestEvac(): There is no emergency shuttle, but the \
+			shuttle was called. Using the backup shuttle instead.")
+		if(!backup_shuttle)
+			throw EXCEPTION("requestEvac(): There is no emergency shuttle, \
+			or backup shuttle! The game will be unresolvable. This is \
+			possibly a mapping error, more likely a bug with the shuttle \
+			manipulation system, or badminry. It is possible to manually \
+			resolve this problem by loading an emergency shuttle template \
+			manually, and then calling register() on the mobile docking port. \
+			Good luck.")
+			return
+		emergency = backup_shuttle
+	var/srd = CONFIG_GET(number/shuttle_refuel_delay)
+	if(world.time - SSticker.round_start_time < srd)
+		to_chat(user, "The emergency shuttle is refueling. Please wait [DisplayTimeText(srd - (world.time - SSticker.round_start_time))] before trying again.")
+		return
+
+	switch(emergency.mode)
+		if(SHUTTLE_RECALL)
+			to_chat(user, "The emergency shuttle may not be called while returning to CentCom.")
+			return
+		if(SHUTTLE_CALL)
+			to_chat(user, "The emergency shuttle is already on its way.")
+			return
+		if(SHUTTLE_DOCKED)
+			to_chat(user, "The emergency shuttle is already here.")
+			return
+		if(SHUTTLE_IGNITING)
+			to_chat(user, "The emergency shuttle is firing its engines to leave.")
+			return
+		if(SHUTTLE_ESCAPE)
+			to_chat(user, "The emergency shuttle is moving away to a safe distance.")
+			return
+		if(SHUTTLE_STRANDED)
+			to_chat(user, "The emergency shuttle has been disabled by CentCom.")
+			return
+
+	call_reason = trim(html_encode(call_reason))
+
+	if(length(call_reason) < CALL_SHUTTLE_REASON_LENGTH && seclevel2num(get_security_level()) > SEC_LEVEL_GREEN)
+		to_chat(user, "You must provide a reason.")
+		return
+
+	var/area/signal_origin = get_area(user)
+	var/emergency_reason = "\nNature of emergency:\n\n[call_reason]"
+	var/security_num = seclevel2num(get_security_level())
+	switch(security_num)
+		if(SEC_LEVEL_RED,SEC_LEVEL_DELTA)
+			emergency.request(null, signal_origin, html_decode(emergency_reason), 1) //There is a serious threat we gotta move no time to give them five minutes.
+		else
+			emergency.request(null, signal_origin, html_decode(emergency_reason), 0)
+
+	var/datum/radio_frequency/frequency = SSradio.return_frequency(FREQ_STATUS_DISPLAYS)
+
+	if(!frequency)
+		return
+
+	var/datum/signal/status_signal = new(list("command" = "update")) // Start processing shuttle-mode displays to display the timer
+	frequency.post_signal(src, status_signal)
+
+	var/area/A = get_area(user)
+
+	log_game("[key_name(user)] has called the shuttle.")
+	deadchat_broadcast("<span class='deadsay'><span class='name'>[user.real_name]</span> has called the shuttle at <span class='name'>[A.name]</span>.</span>", user)
+	if(call_reason)
+		SSblackbox.record_feedback("text", "shuttle_reason", 1, "[call_reason]")
+		log_game("Shuttle call reason: [call_reason]")
+	message_admins("[ADMIN_LOOKUPFLW(user)] has called the shuttle. (<A HREF='?_src_=holder;[HrefToken()];trigger_centcom_recall=1'>TRIGGER CENTCOM RECALL</A>)")
+
+/datum/controller/subsystem/shuttle/proc/centcom_recall(old_timer, admiral_message)
+	if(emergency.mode != SHUTTLE_CALL || emergency.timer != old_timer)
+		return
+	emergency.cancel()
+
+	if(!admiral_message)
+		admiral_message = pick(GLOB.admiral_messages)
+	var/intercepttext = "<font size = 3><b>Nanotrasen Update</b>: Request For Shuttle.</font><hr>\
+						To whom it may concern:<br><br>\
+						We have taken note of the situation upon [station_name()] and have come to the \
+						conclusion that it does not warrant the abandonment of the station.<br>\
+						If you do not agree with our opinion we suggest that you open a direct \
+						line with us and explain the nature of your crisis.<br><br>\
+						<i>This message has been automatically generated based upon readings from long \
+						range diagnostic tools. To assure the quality of your request every finalized report \
+						is reviewed by an on-call rear admiral.<br>\
+						<b>Rear Admiral's Notes:</b> \
+						[admiral_message]"
+	print_command_report(intercepttext, announce = TRUE)
+
+// Called when an emergency shuttle mobile docking port is
+// destroyed, which will only happen with admin intervention
+/datum/controller/subsystem/shuttle/proc/emergencyDeregister()
+	// When a new emergency shuttle is created, it will override the
+	// backup shuttle.
+	src.emergency = src.backup_shuttle
+
+/datum/controller/subsystem/shuttle/proc/cancelEvac(mob/user)
+	if(canRecall())
+		emergency.cancel(get_area(user))
+		log_game("[key_name(user)] has recalled the shuttle.")
+		message_admins("[ADMIN_LOOKUPFLW(user)] has recalled the shuttle.")
+		deadchat_broadcast("<span class='deadsay'><span class='name'>[user.real_name]</span> has recalled the shuttle from <span class='name'>[get_area_name(user, TRUE)]</span>.</span>", user)
+		return 1
+
+/datum/controller/subsystem/shuttle/proc/canRecall()
+	if(!emergency || emergency.mode != SHUTTLE_CALL || emergencyNoRecall || SSticker.mode.name == "meteor")
+		return
+	var/security_num = seclevel2num(get_security_level())
+	switch(security_num)
+		if(SEC_LEVEL_GREEN)
+			if(emergency.timeLeft(1) < emergencyCallTime)
+				return
+		if(SEC_LEVEL_BLUE)
+			if(emergency.timeLeft(1) < emergencyCallTime * 0.6)
+				return
+		if(SEC_LEVEL_AMBER)
+			if(emergency.timeLeft(1) < emergencyCallTime * 0.4)
+				return
+		else
+			if(emergency.timeLeft(1) < emergencyCallTime * 0.25)
+				return
+	return 1
+
+/datum/controller/subsystem/shuttle/proc/autoEvac()
+	if (!SSticker.IsRoundInProgress())
+		return
+
+	var/callShuttle = 1
+
+	for(var/thing in GLOB.shuttle_caller_list)
+		if(isAI(thing))
+			var/mob/living/silicon/ai/AI = thing
+			if(AI.deployed_shell && !AI.deployed_shell.client)
+				continue
+			if(AI.stat || !AI.client)
+				continue
+		else if(istype(thing, /obj/machinery/computer/communications))
+			var/obj/machinery/computer/communications/C = thing
+			if(C.stat & BROKEN)
+				continue
+
+		var/turf/T = get_turf(thing)
+		if(T && is_station_level(T.z))
+			callShuttle = 0
+			break
+
+	if(callShuttle)
+		if(EMERGENCY_IDLE_OR_RECALLED)
+			emergency.request(null, set_coefficient = 2.5)
+			log_game("There is no means of calling the shuttle anymore. Shuttle automatically called.")
+			message_admins("All the communications consoles were destroyed and all AIs are inactive. Shuttle called.")
+
+/datum/controller/subsystem/shuttle/proc/registerHostileEnvironment(datum/bad)
+	hostileEnvironments[bad] = TRUE
+	checkHostileEnvironment()
+
+/datum/controller/subsystem/shuttle/proc/clearHostileEnvironment(datum/bad)
+	hostileEnvironments -= bad
+	checkHostileEnvironment()
+
+
+/datum/controller/subsystem/shuttle/proc/registerTradeBlockade(datum/bad)
+	tradeBlockade[bad] = TRUE
+	checkTradeBlockade()
+
+/datum/controller/subsystem/shuttle/proc/clearTradeBlockade(datum/bad)
+	tradeBlockade -= bad
+	checkTradeBlockade()
+
+
+/datum/controller/subsystem/shuttle/proc/checkTradeBlockade()
+	for(var/datum/d in tradeBlockade)
+		if(!istype(d) || QDELETED(d))
+			tradeBlockade -= d
+	supplyBlocked = tradeBlockade.len
+
+	if(supplyBlocked && (supply.mode == SHUTTLE_IGNITING))
+		supply.mode = SHUTTLE_STRANDED
+		supply.timer = null
+		//Make all cargo consoles speak up
+	if(!supplyBlocked && (supply.mode == SHUTTLE_STRANDED))
+		supply.mode = SHUTTLE_DOCKED
+		//Make all cargo consoles speak up
+
+/datum/controller/subsystem/shuttle/proc/checkHostileEnvironment()
+	for(var/datum/d in hostileEnvironments)
+		if(!istype(d) || QDELETED(d))
+			hostileEnvironments -= d
+	emergencyNoEscape = hostileEnvironments.len
+
+	if(emergencyNoEscape && (emergency.mode == SHUTTLE_IGNITING))
+		emergency.mode = SHUTTLE_STRANDED
+		emergency.timer = null
+		emergency.sound_played = FALSE
+		priority_announce("Hostile environment detected. \
+			Departure has been postponed indefinitely pending \
+			conflict resolution.", null, 'sound/misc/notice1.ogg', "Priority")
+	if(!emergencyNoEscape && (emergency.mode == SHUTTLE_STRANDED))
+		emergency.mode = SHUTTLE_DOCKED
+		emergency.setTimer(emergencyDockTime)
+		priority_announce("Hostile environment resolved. \
+			You have 3 minutes to board the Emergency Shuttle.",
+			null, 'sound/ai/shuttledock.ogg', "Priority")
+
+//try to move/request to dockHome if possible, otherwise dockAway. Mainly used for admin buttons
+/datum/controller/subsystem/shuttle/proc/toggleShuttle(shuttleId, dockHome, dockAway, timed)
+	var/obj/docking_port/mobile/M = getShuttle(shuttleId)
+	if(!M)
+		return 1
+	var/obj/docking_port/stationary/dockedAt = M.get_docked()
+	var/destination = dockHome
+	if(dockedAt && dockedAt.id == dockHome)
+		destination = dockAway
+	if(timed)
+		if(M.request(getDock(destination)))
+			return 2
+	else
+		if(M.initiate_docking(getDock(destination)) != DOCKING_SUCCESS)
+			return 2
+	return 0	//dock successful
+
+
+/datum/controller/subsystem/shuttle/proc/moveShuttle(shuttleId, dockId, timed)
+	var/obj/docking_port/mobile/M = getShuttle(shuttleId)
+	var/obj/docking_port/stationary/D = getDock(dockId)
+
+	if(!M)
+		return 1
+	if(timed)
+		if(M.request(D))
+			return 2
+	else
+		if(M.initiate_docking(D) != DOCKING_SUCCESS)
+			return 2
+	return 0	//dock successful
+
+/datum/controller/subsystem/shuttle/proc/request_transit_dock(obj/docking_port/mobile/M)
+	if(!istype(M))
+		throw EXCEPTION("[M] is not a mobile docking port")
+
+	if(M.assigned_transit)
+		return
+	else
+		if(!(M in transit_requesters))
+			transit_requesters += M
+
+/datum/controller/subsystem/shuttle/proc/generate_transit_dock(obj/docking_port/mobile/M)
+	// First, determine the size of the needed zone
+	// Because of shuttle rotation, the "width" of the shuttle is not
+	// always x.
+	var/travel_dir = M.preferred_direction
+	// Remember, the direction is the direction we appear to be
+	// coming from
+	var/dock_angle = dir2angle(M.preferred_direction) + dir2angle(M.port_direction) + 180
+	var/dock_dir = angle2dir(dock_angle)
+
+	var/transit_width = SHUTTLE_TRANSIT_BORDER * 2
+	var/transit_height = SHUTTLE_TRANSIT_BORDER * 2
+
+	// Shuttles travelling on their side have their dimensions swapped
+	// from our perspective
+	switch(dock_dir)
+		if(NORTH, SOUTH)
+			transit_width += M.width
+			transit_height += M.height
+		if(EAST, WEST)
+			transit_width += M.height
+			transit_height += M.width
+
+/*
+	to_chat(world, "The attempted transit dock will be [transit_width] width, and \)
+		[transit_height] in height. The travel dir is [travel_dir]."
+*/
+
+	var/transit_path = /turf/open/space/transit
+	var/border_path = /turf/open/space/transit/border
+	switch(travel_dir)
+		if(NORTH)
+			transit_path = /turf/open/space/transit/north
+			border_path = /turf/open/space/transit/border/north
+		if(SOUTH)
+			transit_path = /turf/open/space/transit/south
+			border_path = /turf/open/space/transit/border/south
+		if(EAST)
+			transit_path = /turf/open/space/transit/east
+			border_path = /turf/open/space/transit/border/east
+		if(WEST)
+			transit_path = /turf/open/space/transit/west
+			border_path = /turf/open/space/transit/border/west
+
+	var/datum/turf_reservation/proposal = SSmapping.RequestBlockReservation(transit_width, transit_height, null, /datum/turf_reservation/transit, transit_path, border_path)
+
+	if(!istype(proposal))
+		return FALSE
+
+	var/turf/bottomleft = locate(proposal.bottom_left_coords[1], proposal.bottom_left_coords[2], proposal.bottom_left_coords[3])
+	// Then create a transit docking port in the middle
+	var/coords = M.return_coords(0, 0, dock_dir)
+	/*  0------2
+        |      |
+        |      |
+        |  x   |
+        3------1
+	*/
+
+	var/x0 = coords[1]
+	var/y0 = coords[2]
+	var/x1 = coords[3]
+	var/y1 = coords[4]
+	// Then we want the point closest to -infinity,-infinity
+	var/x2 = min(x0, x1)
+	var/y2 = min(y0, y1)
+
+	// Then invert the numbers
+	var/transit_x = bottomleft.x + SHUTTLE_TRANSIT_BORDER + abs(x2)
+	var/transit_y = bottomleft.y + SHUTTLE_TRANSIT_BORDER + abs(y2)
+
+	var/turf/midpoint = locate(transit_x, transit_y, bottomleft.z)
+	if(!midpoint)
+		return FALSE
+	var/area/shuttle/transit/A = new()
+	A.parallax_movedir = travel_dir
+	A.contents = proposal.reserved_turfs
+	var/obj/docking_port/stationary/transit/new_transit_dock = new(midpoint)
+	new_transit_dock.reserved_area = proposal
+	new_transit_dock.name = "Transit for [M.id]/[M.name]"
+	new_transit_dock.owner = M
+	new_transit_dock.assigned_area = A
+
+	// Add 180, because ports point inwards, rather than outwards
+	new_transit_dock.setDir(angle2dir(dock_angle))
+
+	M.assigned_transit = new_transit_dock
+	return new_transit_dock
+
+/datum/controller/subsystem/shuttle/Recover()
+	if (istype(SSshuttle.mobile))
+		mobile = SSshuttle.mobile
+	if (istype(SSshuttle.stationary))
+		stationary = SSshuttle.stationary
+	if (istype(SSshuttle.transit))
+		transit = SSshuttle.transit
+	if (istype(SSshuttle.transit_requesters))
+		transit_requesters = SSshuttle.transit_requesters
+	if (istype(SSshuttle.transit_request_failures))
+		transit_request_failures = SSshuttle.transit_request_failures
+
+	if (istype(SSshuttle.emergency))
+		emergency = SSshuttle.emergency
+	if (istype(SSshuttle.arrivals))
+		arrivals = SSshuttle.arrivals
+	if (istype(SSshuttle.backup_shuttle))
+		backup_shuttle = SSshuttle.backup_shuttle
+
+	if (istype(SSshuttle.emergencyLastCallLoc))
+		emergencyLastCallLoc = SSshuttle.emergencyLastCallLoc
+
+	if (istype(SSshuttle.hostileEnvironments))
+		hostileEnvironments = SSshuttle.hostileEnvironments
+
+	if (istype(SSshuttle.supply))
+		supply = SSshuttle.supply
+
+	if (istype(SSshuttle.discoveredPlants))
+		discoveredPlants = SSshuttle.discoveredPlants
+
+	if (istype(SSshuttle.shoppinglist))
+		shoppinglist = SSshuttle.shoppinglist
+	if (istype(SSshuttle.requestlist))
+		requestlist = SSshuttle.requestlist
+	if (istype(SSshuttle.orderhistory))
+		orderhistory = SSshuttle.orderhistory
+
+	if (istype(SSshuttle.shuttle_loan))
+		shuttle_loan = SSshuttle.shuttle_loan
+
+	if (istype(SSshuttle.shuttle_purchase_requirements_met))
+		shuttle_purchase_requirements_met = SSshuttle.shuttle_purchase_requirements_met
+
+	centcom_message = SSshuttle.centcom_message
+	ordernum = SSshuttle.ordernum
+	points = SSshuttle.points
+	emergencyNoEscape = SSshuttle.emergencyNoEscape
+	emergencyCallAmount = SSshuttle.emergencyCallAmount
+	shuttle_purchased = SSshuttle.shuttle_purchased
+	lockdown = SSshuttle.lockdown
+
+
+/datum/controller/subsystem/shuttle/proc/is_in_shuttle_bounds(atom/A)
+	var/area/current = get_area(A)
+	if(istype(current, /area/shuttle) && !istype(current, /area/shuttle/transit))
+		return TRUE
+	for(var/obj/docking_port/mobile/M in mobile)
+		if(M.is_in_shuttle_bounds(A))
+			return TRUE
+
+/datum/controller/subsystem/shuttle/proc/get_containing_shuttle(atom/A)
+	var/list/mobile_cache = mobile
+	for(var/i in 1 to mobile_cache.len)
+		var/obj/docking_port/port = mobile_cache[i]
+		if(port.is_in_shuttle_bounds(A))
+			return port
+
+/datum/controller/subsystem/shuttle/proc/get_containing_dock(atom/A)
+	. = list()
+	var/list/stationary_cache = stationary
+	for(var/i in 1 to stationary_cache.len)
+		var/obj/docking_port/port = stationary_cache[i]
+		if(port.is_in_shuttle_bounds(A))
+			. += port
+
+/datum/controller/subsystem/shuttle/proc/get_dock_overlap(x0, y0, x1, y1, z)
+	. = list()
+	var/list/stationary_cache = stationary
+	for(var/i in 1 to stationary_cache.len)
+		var/obj/docking_port/port = stationary_cache[i]
+		if(!port || port.z != z)
+			continue
+		var/list/bounds = port.return_coords()
+		var/list/overlap = get_overlap(x0, y0, x1, y1, bounds[1], bounds[2], bounds[3], bounds[4])
+		var/list/xs = overlap[1]
+		var/list/ys = overlap[2]
+		if(xs.len && ys.len)
+			.[port] = overlap
+
+/datum/controller/subsystem/shuttle/proc/update_hidden_docking_ports(list/remove_turfs, list/add_turfs)
+	var/list/remove_images = list()
+	var/list/add_images = list()
+
+	if(remove_turfs)
+		for(var/T in remove_turfs)
+			var/list/L = hidden_shuttle_turfs[T]
+			if(L)
+				remove_images += L[1]
+		hidden_shuttle_turfs -= remove_turfs
+
+	if(add_turfs)
+		for(var/V in add_turfs)
+			var/turf/T = V
+			var/image/I
+			if(remove_images.len)
+				//we can just reuse any images we are about to delete instead of making new ones
+				I = remove_images[1]
+				remove_images.Cut(1, 2)
+				I.loc = T
+			else
+				I = image(loc = T)
+				add_images += I
+			I.appearance = T.appearance
+			I.override = TRUE
+			hidden_shuttle_turfs[T] = list(I, T.type)
+
+	hidden_shuttle_turf_images -= remove_images
+	hidden_shuttle_turf_images += add_images
+
+	for(var/V in GLOB.navigation_computers)
+		var/obj/machinery/computer/camera_advanced/shuttle_docker/C = V
+		C.update_hidden_docking_ports(remove_images, add_images)
+
+	QDEL_LIST(remove_images)

code/controllers/subsystem/spacedrift.dm

@@ -0,0 +1,59 @@
+SUBSYSTEM_DEF(spacedrift)
+	name = "Space Drift"
+	priority = FIRE_PRIORITY_SPACEDRIFT
+	wait = 5
+	flags = SS_NO_INIT|SS_KEEP_TIMING
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun = list()
+	var/list/processing = list()
+
+/datum/controller/subsystem/spacedrift/stat_entry()
+	..("P:[processing.len]")
+
+
+/datum/controller/subsystem/spacedrift/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = processing.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while (currentrun.len)
+		var/atom/movable/AM = currentrun[currentrun.len]
+		currentrun.len--
+		if (!AM)
+			processing -= AM
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		if (AM.inertia_next_move > world.time)
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		if (!AM.loc || AM.loc != AM.inertia_last_loc || AM.Process_Spacemove(0))
+			AM.inertia_dir = 0
+
+		if (!AM.inertia_dir)
+			AM.inertia_last_loc = null
+			processing -= AM
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		var/old_dir = AM.dir
+		var/old_loc = AM.loc
+		AM.inertia_moving = TRUE
+		step(AM, AM.inertia_dir)
+		AM.inertia_moving = FALSE
+		AM.inertia_next_move = world.time + AM.inertia_move_delay
+		if (AM.loc == old_loc)
+			AM.inertia_dir = 0
+
+		AM.setDir(old_dir)
+		AM.inertia_last_loc = AM.loc
+		if (MC_TICK_CHECK)
+			return
+

code/controllers/subsystem/stickyban.dm

@@ -0,0 +1,34 @@
+SUBSYSTEM_DEF(stickyban)
+	name = "Sticky Ban"
+	init_order = INIT_ORDER_STICKY_BAN
+	flags = SS_NO_FIRE
+
+	var/list/cache = list()
+
+/datum/controller/subsystem/stickyban/Initialize(timeofday)
+	var/list/bannedkeys = world.GetConfig("ban")
+	//sanitize the sticky ban list
+	for (var/bannedkey in bannedkeys)
+		var/ckey = ckey(bannedkey)
+		var/list/ban = stickyban2list(world.GetConfig("ban", bannedkey))
+
+		//byond stores sticky bans by key, that can end up confusing things
+		//i also remove it here so that if any stickybans cause a runtime, they just stop existing
+		world.SetConfig("ban", bannedkey, null)
+
+		if (!ban["ckey"])
+			ban["ckey"] = ckey
+
+		//storing these can break things and isn't needed for sticky ban tracking
+		ban -= "IP"
+		ban -= "computer_id"
+
+		ban["matches_this_round"] = list()
+		ban["existing_user_matches_this_round"] = list()
+		ban["admin_matches_this_round"] = list()
+		cache[ckey] = ban
+	
+	for (var/bannedckey in cache)
+		world.SetConfig("ban", bannedckey, list2stickyban(cache[bannedckey]))
+
+	return ..()

code/controllers/subsystem/sun.dm

@@ -0,0 +1,49 @@
+SUBSYSTEM_DEF(sun)
+	name = "Sun"
+	wait = 600
+	flags = SS_NO_TICK_CHECK|SS_NO_INIT
+	var/angle
+	var/dx
+	var/dy
+	var/rate
+	var/list/solars	= list()
+
+/datum/controller/subsystem/sun/PreInit()
+	angle = rand (0,360)			// the station position to the sun is randomised at round start
+	rate = rand(50,200)/100			// 50% - 200% of standard rotation
+	if(prob(50))					// same chance to rotate clockwise than counter-clockwise
+		rate = -rate
+
+/datum/controller/subsystem/sun/stat_entry(msg)
+	..("P:[solars.len]")
+
+/datum/controller/subsystem/sun/fire()
+	angle = (360 + angle + rate * 6) % 360	 // increase/decrease the angle to the sun, adjusted by the rate
+
+	// now calculate and cache the (dx,dy) increments for line drawing
+	var/s = sin(angle)
+	var/c = cos(angle)
+
+	// Either "abs(s) < abs(c)" or "abs(s) >= abs(c)"
+	// In both cases, the greater is greater than 0, so, no "if 0" check is needed for the divisions
+
+	if(abs(s) < abs(c))
+		dx = s / abs(c)
+		dy = c / abs(c)
+	else
+		dx = s / abs(s)
+		dy = c / abs(s)
+
+	//now tell the solar control computers to update their status and linked devices
+	for(var/obj/machinery/power/solar_control/SC in solars)
+		if(!SC.powernet)
+			solars.Remove(SC)
+			continue
+		SC.update()
+
+
+
+
+
+
+

code/controllers/subsystem/tgui.dm

@@ -0,0 +1,37 @@
+SUBSYSTEM_DEF(tgui)
+	name = "tgui"
+	wait = 9
+	flags = SS_NO_INIT
+	priority = FIRE_PRIORITY_TGUI
+	runlevels = RUNLEVEL_LOBBY | RUNLEVELS_DEFAULT
+
+	var/list/currentrun = list()
+	var/list/open_uis = list() // A list of open UIs, grouped by src_object and ui_key.
+	var/list/processing_uis = list() // A list of processing UIs, ungrouped.
+	var/basehtml // The HTML base used for all UIs.
+
+/datum/controller/subsystem/tgui/PreInit()
+	basehtml = file2text('tgui/tgui.html')
+
+/datum/controller/subsystem/tgui/Shutdown()
+	close_all_uis()
+
+/datum/controller/subsystem/tgui/stat_entry()
+	..("P:[processing_uis.len]")
+
+/datum/controller/subsystem/tgui/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = processing_uis.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(currentrun.len)
+		var/datum/tgui/ui = currentrun[currentrun.len]
+		currentrun.len--
+		if(ui && ui.user && ui.src_object)
+			ui.process()
+		else
+			processing_uis.Remove(ui)
+		if (MC_TICK_CHECK)
+			return
+

code/controllers/subsystem/throwing.dm

@@ -0,0 +1,161 @@
+#define MAX_THROWING_DIST 1280 // 5 z-levels on default width
+#define MAX_TICKS_TO_MAKE_UP 3 //how many missed ticks will we attempt to make up for this run.
+
+SUBSYSTEM_DEF(throwing)
+	name = "Throwing"
+	priority = FIRE_PRIORITY_THROWING
+	wait = 1
+	flags = SS_NO_INIT|SS_KEEP_TIMING|SS_TICKER
+	runlevels = RUNLEVEL_GAME | RUNLEVEL_POSTGAME
+
+	var/list/currentrun
+	var/list/processing = list()
+
+/datum/controller/subsystem/throwing/stat_entry()
+	..("P:[processing.len]")
+
+
+/datum/controller/subsystem/throwing/fire(resumed = 0)
+	if (!resumed)
+		src.currentrun = processing.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+
+	while(length(currentrun))
+		var/atom/movable/AM = currentrun[currentrun.len]
+		var/datum/thrownthing/TT = currentrun[AM]
+		currentrun.len--
+		if (QDELETED(AM) || QDELETED(TT))
+			processing -= AM
+			if (MC_TICK_CHECK)
+				return
+			continue
+
+		TT.tick()
+
+		if (MC_TICK_CHECK)
+			return
+
+	currentrun = null
+
+/datum/thrownthing
+	var/atom/movable/thrownthing
+	var/atom/target
+	var/turf/target_turf
+	var/init_dir
+	var/maxrange
+	var/speed
+	var/mob/thrower
+	var/diagonals_first
+	var/dist_travelled = 0
+	var/start_time
+	var/dist_x
+	var/dist_y
+	var/dx
+	var/dy
+	var/pure_diagonal
+	var/diagonal_error
+	var/datum/callback/callback
+	var/paused = FALSE
+	var/delayed_time = 0
+	var/last_move = 0
+
+/datum/thrownthing/Destroy()
+	SSthrowing.processing -= thrownthing
+	thrownthing.throwing = null
+	thrownthing = null
+	target = null
+	thrower = null
+	callback = null
+	return ..()
+
+/datum/thrownthing/proc/tick()
+	var/atom/movable/AM = thrownthing
+	if (!isturf(AM.loc) || !AM.throwing)
+		finalize()
+		return
+
+	if(paused)
+		delayed_time += world.time - last_move
+		return
+
+	if (dist_travelled && hitcheck()) //to catch sneaky things moving on our tile while we slept
+		finalize()
+		return
+
+	var/atom/step
+
+	last_move = world.time
+
+	//calculate how many tiles to move, making up for any missed ticks.
+	var/tilestomove = CEILING(min(((((world.time+world.tick_lag) - start_time + delayed_time) * speed) - (dist_travelled ? dist_travelled : -1)), speed*MAX_TICKS_TO_MAKE_UP) * (world.tick_lag * SSthrowing.wait), 1)
+	while (tilestomove-- > 0)
+		if ((dist_travelled >= maxrange || AM.loc == target_turf) && AM.has_gravity(AM.loc))
+			finalize()
+			return
+
+		if (dist_travelled <= max(dist_x, dist_y)) //if we haven't reached the target yet we home in on it, otherwise we use the initial direction
+			step = get_step(AM, get_dir(AM, target_turf))
+		else
+			step = get_step(AM, init_dir)
+
+		if (!pure_diagonal && !diagonals_first) // not a purely diagonal trajectory and we don't want all diagonal moves to be done first
+			if (diagonal_error >= 0 && max(dist_x,dist_y) - dist_travelled != 1) //we do a step forward unless we're right before the target
+				step = get_step(AM, dx)
+			diagonal_error += (diagonal_error < 0) ? dist_x/2 : -dist_y
+
+		if (!step) // going off the edge of the map makes get_step return null, don't let things go off the edge
+			finalize()
+			return
+
+		AM.Move(step, get_dir(AM, step))
+
+		if (!AM.throwing) // we hit something during our move
+			finalize(hit = TRUE)
+			return
+
+		dist_travelled++
+
+		if (dist_travelled > MAX_THROWING_DIST)
+			finalize()
+			return
+
+/datum/thrownthing/proc/finalize(hit = FALSE, target=null)
+	set waitfor = FALSE
+	//done throwing, either because it hit something or it finished moving
+	if(!thrownthing)
+		return
+	thrownthing.throwing = null
+	if (!hit)
+		for (var/thing in get_turf(thrownthing)) //looking for our target on the turf we land on.
+			var/atom/A = thing
+			if (A == target)
+				hit = TRUE
+				thrownthing.throw_impact(A, src)
+				break
+		if (!hit)
+			thrownthing.throw_impact(get_turf(thrownthing), src)  // we haven't hit something yet and we still must, let's hit the ground.
+			thrownthing.newtonian_move(init_dir)
+	else
+		thrownthing.newtonian_move(init_dir)
+
+	if(target)
+		thrownthing.throw_impact(target, src)
+
+	if (callback)
+		callback.Invoke()
+
+	qdel(src)
+
+/datum/thrownthing/proc/hit_atom(atom/A)
+	finalize(hit=TRUE, target=A)
+
+/datum/thrownthing/proc/hitcheck()
+	for (var/thing in get_turf(thrownthing))
+		var/atom/movable/AM = thing
+		if (AM == thrownthing || (AM == thrower && !ismob(thrownthing)))
+			continue
+		if (AM.density && !(AM.pass_flags & LETPASSTHROW) && !(AM.flags_1 & ON_BORDER_1))
+			finalize(hit=TRUE, target=AM)
+			return TRUE

code/controllers/subsystem/ticker.dm

@@ -0,0 +1,687 @@
+#define ROUND_START_MUSIC_LIST "strings/round_start_sounds.txt"
+
+SUBSYSTEM_DEF(ticker)
+	name = "Ticker"
+	init_order = INIT_ORDER_TICKER
+
+	priority = FIRE_PRIORITY_TICKER
+	flags = SS_KEEP_TIMING
+	runlevels = RUNLEVEL_LOBBY | RUNLEVEL_SETUP | RUNLEVEL_GAME
+
+	var/current_state = GAME_STATE_STARTUP	//state of current round (used by process()) Use the defines GAME_STATE_* !
+	var/force_ending = 0					//Round was ended by admin intervention
+	// If true, there is no lobby phase, the game starts immediately.
+	var/start_immediately = FALSE
+	var/setup_done = FALSE //All game setup done including mode post setup and
+
+	var/hide_mode = 0
+	var/datum/game_mode/mode = null
+	var/event_time = null
+	var/event = 0
+
+	var/login_music							//music played in pregame lobby
+	var/round_end_sound						//music/jingle played when the world reboots
+	var/round_end_sound_sent = TRUE			//If all clients have loaded it
+
+	var/list/datum/mind/minds = list()		//The characters in the game. Used for objective tracking.
+
+	var/list/syndicate_coalition = list()	//list of traitor-compatible factions
+	var/list/factions = list()				//list of all factions
+	var/list/availablefactions = list()		//list of factions with openings
+	var/list/scripture_states = list(SCRIPTURE_DRIVER = TRUE, \
+	SCRIPTURE_SCRIPT = FALSE, \
+	SCRIPTURE_APPLICATION = FALSE) //list of clockcult scripture states for announcements
+
+	var/delay_end = 0						//if set true, the round will not restart on it's own
+	var/admin_delay_notice = ""				//a message to display to anyone who tries to restart the world after a delay
+	var/ready_for_reboot = FALSE			//all roundend preparation done with, all that's left is reboot
+
+	var/triai = 0							//Global holder for Triumvirate
+	var/tipped = 0							//Did we broadcast the tip of the day yet?
+	var/selected_tip						// What will be the tip of the day?
+
+	var/timeLeft						//pregame timer
+	var/start_at
+
+	var/gametime_offset = 432000		//Deciseconds to add to world.time for station time.
+	var/station_time_rate_multiplier = 12		//factor of station time progressal vs real time.
+
+	var/totalPlayers = 0					//used for pregame stats on statpanel
+	var/totalPlayersReady = 0				//used for pregame stats on statpanel
+
+	var/queue_delay = 0
+	var/list/queued_players = list()		//used for join queues when the server exceeds the hard population cap
+
+	var/maprotatechecked = 0
+
+	var/news_report
+
+	var/late_join_disabled
+
+	var/roundend_check_paused = FALSE
+
+	var/round_start_time = 0
+	var/list/round_start_events
+	var/list/round_end_events
+	var/mode_result = "undefined"
+	var/end_state = "undefined"
+
+	var/modevoted = FALSE					//Have we sent a vote for the gamemode?
+
+/datum/controller/subsystem/ticker/Initialize(timeofday)
+	load_mode()
+
+	var/list/byond_sound_formats = list(
+		"mid"  = TRUE,
+		"midi" = TRUE,
+		"mod"  = TRUE,
+		"it"   = TRUE,
+		"s3m"  = TRUE,
+		"xm"   = TRUE,
+		"oxm"  = TRUE,
+		"wav"  = TRUE,
+		"ogg"  = TRUE,
+		"raw"  = TRUE,
+		"wma"  = TRUE,
+		"aiff" = TRUE
+	)
+
+	var/list/provisional_title_music = flist("[global.config.directory]/title_music/sounds/")
+	var/list/music = list()
+	var/use_rare_music = prob(1)
+
+	for(var/S in provisional_title_music)
+		var/lower = lowertext(S)
+		var/list/L = splittext(lower,"+")
+		switch(L.len)
+			if(3) //rare+MAP+sound.ogg or MAP+rare.sound.ogg -- Rare Map-specific sounds
+				if(use_rare_music)
+					if(L[1] == "rare" && L[2] == SSmapping.config.map_name)
+						music += S
+					else if(L[2] == "rare" && L[1] == SSmapping.config.map_name)
+						music += S
+			if(2) //rare+sound.ogg or MAP+sound.ogg -- Rare sounds or Map-specific sounds
+				if((use_rare_music && L[1] == "rare") || (L[1] == SSmapping.config.map_name))
+					music += S
+			if(1) //sound.ogg -- common sound
+				music += S
+
+	var/old_login_music = trim(file2text("data/last_round_lobby_music.txt"))
+	if(music.len > 1)
+		music -= old_login_music
+
+	for(var/S in music)
+		var/list/L = splittext(S,".")
+		if(L.len >= 2)
+			var/ext = lowertext(L[L.len]) //pick the real extension, no 'honk.ogg.exe' nonsense here
+			if(byond_sound_formats[ext])
+				continue
+		music -= S
+
+	if(isemptylist(music))
+		music = world.file2list(ROUND_START_MUSIC_LIST, "\n")
+		login_music = pick(music)
+	else
+		login_music = "[global.config.directory]/title_music/sounds/[pick(music)]"
+
+
+	if(!GLOB.syndicate_code_phrase)
+		GLOB.syndicate_code_phrase	= generate_code_phrase(return_list=TRUE)
+
+		var/codewords = jointext(GLOB.syndicate_code_phrase, "|")
+		var/regex/codeword_match = new("([codewords])", "ig")
+
+		GLOB.syndicate_code_phrase_regex = codeword_match
+
+	if(!GLOB.syndicate_code_response)
+		GLOB.syndicate_code_response = generate_code_phrase(return_list=TRUE)
+
+		var/codewords = jointext(GLOB.syndicate_code_response, "|")
+		var/regex/codeword_match = new("([codewords])", "ig")
+
+		GLOB.syndicate_code_response_regex = codeword_match
+
+	start_at = world.time + (CONFIG_GET(number/lobby_countdown) * 10)
+	if(CONFIG_GET(flag/randomize_shift_time))
+		gametime_offset = rand(0, 23) HOURS
+	else if(CONFIG_GET(flag/shift_time_realtime))
+		gametime_offset = world.timeofday
+	return ..()
+
+/datum/controller/subsystem/ticker/fire()
+	switch(current_state)
+		if(GAME_STATE_STARTUP)
+			if(Master.initializations_finished_with_no_players_logged_in)
+				start_at = world.time + (CONFIG_GET(number/lobby_countdown) * 10)
+			for(var/client/C in GLOB.clients)
+				window_flash(C, ignorepref = TRUE) //let them know lobby has opened up.
+			to_chat(world, "<span class='boldnotice'>Welcome to [station_name()]!</span>")
+			if(CONFIG_GET(flag/irc_announce_new_game))
+				world.TgsTargetedChatBroadcast("New round starting on [SSmapping.config.map_name]!", FALSE)
+			current_state = GAME_STATE_PREGAME
+			//Everyone who wants to be an observer is now spawned
+			create_observers()
+			fire()
+		if(GAME_STATE_PREGAME)
+				//lobby stats for statpanels
+			if(isnull(timeLeft))
+				timeLeft = max(0,start_at - world.time)
+			totalPlayers = 0
+			totalPlayersReady = 0
+			for(var/mob/dead/new_player/player in GLOB.player_list)
+				++totalPlayers
+				if(player.ready == PLAYER_READY_TO_PLAY)
+					++totalPlayersReady
+
+			if(start_immediately)
+				timeLeft = 0
+
+			if(!modevoted)
+				send_gamemode_vote()
+			//countdown
+			if(timeLeft < 0)
+				return
+			timeLeft -= wait
+
+			if(timeLeft <= 300 && !tipped)
+				send_tip_of_the_round()
+				tipped = TRUE
+
+			if(timeLeft <= 0)
+				current_state = GAME_STATE_SETTING_UP
+				Master.SetRunLevel(RUNLEVEL_SETUP)
+				if(start_immediately)
+					fire()
+
+		if(GAME_STATE_SETTING_UP)
+			if(!setup())
+				//setup failed
+				current_state = GAME_STATE_STARTUP
+				start_at = world.time + (CONFIG_GET(number/lobby_countdown) * 10)
+				timeLeft = null
+				Master.SetRunLevel(RUNLEVEL_LOBBY)
+
+		if(GAME_STATE_PLAYING)
+			mode.process(wait * 0.1)
+			check_queue()
+			check_maprotate()
+			scripture_states = scripture_unlock_alert(scripture_states)
+			SSshuttle.autoEnd()
+
+			if(!roundend_check_paused && mode.check_finished(force_ending) || force_ending)
+				current_state = GAME_STATE_FINISHED
+				toggle_ooc(TRUE) // Turn it on
+				toggle_dooc(TRUE)
+				declare_completion(force_ending)
+				Master.SetRunLevel(RUNLEVEL_POSTGAME)
+
+
+/datum/controller/subsystem/ticker/proc/setup()
+	to_chat(world, "<span class='boldannounce'>Starting game...</span>")
+	var/init_start = world.timeofday
+		//Create and announce mode
+	var/list/datum/game_mode/runnable_modes
+	if(GLOB.master_mode == "random" || GLOB.master_mode == "secret")
+		runnable_modes = config.get_runnable_modes()
+
+		if(GLOB.master_mode == "secret")
+			hide_mode = 1
+			if(GLOB.secret_force_mode != "secret")
+				var/datum/game_mode/smode = config.pick_mode(GLOB.secret_force_mode)
+				if(!smode.can_start())
+					message_admins("<span class='notice'>Unable to force secret [GLOB.secret_force_mode]. [smode.required_players] players and [smode.required_enemies] eligible antagonists needed.</span>")
+				else
+					mode = smode
+
+		if(!mode)
+			if(!runnable_modes.len)
+				to_chat(world, "<B>Unable to choose playable game mode.</B> Reverting to pre-game lobby.")
+				return 0
+			mode = pickweight(runnable_modes)
+			if(!mode)	//too few roundtypes all run too recently
+				mode = pick(runnable_modes)
+
+	else
+		mode = config.pick_mode(GLOB.master_mode)
+		if(!mode.can_start())
+			to_chat(world, "<B>Unable to start [mode.name].</B> Not enough players, [mode.required_players] players and [mode.required_enemies] eligible antagonists needed. Reverting to pre-game lobby.")
+			qdel(mode)
+			mode = null
+			SSjob.ResetOccupations()
+			return 0
+
+	CHECK_TICK
+	//Configure mode and assign player to special mode stuff
+	var/can_continue = 0
+	can_continue = src.mode.pre_setup()		//Choose antagonists
+	CHECK_TICK
+	SSjob.DivideOccupations() 				//Distribute jobs
+	CHECK_TICK
+
+	if(!GLOB.Debug2)
+		if(!can_continue)
+			log_game("[mode.name] failed pre_setup, cause: [mode.setup_error]")
+			send2irc("SSticker", "[mode.name] failed pre_setup, cause: [mode.setup_error]")
+			message_admins("<span class='notice'>[mode.name] failed pre_setup, cause: [mode.setup_error]</span>")
+			QDEL_NULL(mode)
+			to_chat(world, "<B>Error setting up [GLOB.master_mode].</B> Reverting to pre-game lobby.")
+			SSjob.ResetOccupations()
+			return 0
+	else
+		message_admins("<span class='notice'>DEBUG: Bypassing prestart checks...</span>")
+
+	CHECK_TICK
+	/*if(hide_mode) CIT CHANGE - comments this section out to obfuscate gamemodes. Quit self-antagging during extended just because "hurrrrr no antaggs!!!!!! i giv sec thing 2 do!!!!!!!!!" it's bullshit and everyone hates it
+		var/list/modes = new
+		for (var/datum/game_mode/M in runnable_modes)
+			modes += M.name
+		modes = sortList(modes)
+		to_chat(world, "<b>The gamemode is: secret!\nPossibilities:</B> [english_list(modes)]")
+	else
+		mode.announce()*/
+
+	if(!CONFIG_GET(flag/ooc_during_round))
+		toggle_ooc(FALSE) // Turn it off
+
+	CHECK_TICK
+	GLOB.start_landmarks_list = shuffle(GLOB.start_landmarks_list) //Shuffle the order of spawn points so they dont always predictably spawn bottom-up and right-to-left
+	create_characters() //Create player characters
+	collect_minds()
+	equip_characters()
+
+	GLOB.data_core.manifest()
+
+	transfer_characters()	//transfer keys to the new mobs
+
+	for(var/I in round_start_events)
+		var/datum/callback/cb = I
+		cb.InvokeAsync()
+	LAZYCLEARLIST(round_start_events)
+
+	log_world("Game start took [(world.timeofday - init_start)/10]s")
+	round_start_time = world.time
+	SSdbcore.SetRoundStart()
+
+	to_chat(world, "<span class='notice'><B>Welcome to [station_name()], enjoy your stay!</B></span>")
+	SEND_SOUND(world, sound('sound/ai/welcome.ogg'))
+
+	current_state = GAME_STATE_PLAYING
+	Master.SetRunLevel(RUNLEVEL_GAME)
+
+	if(SSevents.holidays)
+		to_chat(world, "<span class='notice'>and...</span>")
+		for(var/holidayname in SSevents.holidays)
+			var/datum/holiday/holiday = SSevents.holidays[holidayname]
+			to_chat(world, "<h4>[holiday.greet()]</h4>")
+
+	PostSetup()
+	SSshuttle.realtimeofstart = world.realtime
+
+	return TRUE
+
+/datum/controller/subsystem/ticker/proc/PostSetup()
+	set waitfor = FALSE
+	mode.post_setup()
+	GLOB.start_state = new /datum/station_state()
+	GLOB.start_state.count()
+
+	var/list/adm = get_admin_counts()
+	var/list/allmins = adm["present"]
+	send2irc("Server", "Round [GLOB.round_id ? "#[GLOB.round_id]:" : "of"] [hide_mode ? "secret":"[mode.name]"] has started[allmins.len ? ".":" with no active admins online!"]")
+	setup_done = TRUE
+
+	for(var/i in GLOB.start_landmarks_list)
+		var/obj/effect/landmark/start/S = i
+		if(istype(S))							//we can not runtime here. not in this important of a proc.
+			S.after_round_start()
+		else
+			stack_trace("[S] [S.type] found in start landmarks list, which isn't a start landmark!")
+
+
+//These callbacks will fire after roundstart key transfer
+/datum/controller/subsystem/ticker/proc/OnRoundstart(datum/callback/cb)
+	if(!HasRoundStarted())
+		LAZYADD(round_start_events, cb)
+	else
+		cb.InvokeAsync()
+
+//These callbacks will fire before roundend report
+/datum/controller/subsystem/ticker/proc/OnRoundend(datum/callback/cb)
+	if(current_state >= GAME_STATE_FINISHED)
+		cb.InvokeAsync()
+	else
+		LAZYADD(round_end_events, cb)
+
+/datum/controller/subsystem/ticker/proc/station_explosion_detonation(atom/bomb)
+	if(bomb)	//BOOM
+		var/turf/epi = bomb.loc
+		qdel(bomb)
+		if(epi)
+			explosion(epi, 0, 256, 512, 0, TRUE, TRUE, 0, TRUE)
+
+/datum/controller/subsystem/ticker/proc/create_characters()
+	for(var/mob/dead/new_player/player in GLOB.player_list)
+		if(player.ready == PLAYER_READY_TO_PLAY && player.mind)
+			GLOB.joined_player_list += player.ckey
+			player.create_character(FALSE)
+		else
+			player.new_player_panel()
+		CHECK_TICK
+
+/datum/controller/subsystem/ticker/proc/collect_minds()
+	for(var/mob/dead/new_player/P in GLOB.player_list)
+		if(P.new_character && P.new_character.mind)
+			SSticker.minds += P.new_character.mind
+		CHECK_TICK
+
+
+/datum/controller/subsystem/ticker/proc/equip_characters()
+	var/captainless=1
+	for(var/mob/dead/new_player/N in GLOB.player_list)
+		var/mob/living/carbon/human/player = N.new_character
+		if(istype(player) && player.mind && player.mind.assigned_role)
+			if(player.mind.assigned_role == "Captain")
+				captainless=0
+			if(player.mind.assigned_role != player.mind.special_role)
+				SSjob.EquipRank(N, player.mind.assigned_role, 0)
+			if(CONFIG_GET(flag/roundstart_traits) && ishuman(N.new_character))
+				SSquirks.AssignQuirks(N.new_character, N.client, TRUE, TRUE, SSjob.GetJob(player.mind.assigned_role), FALSE, N)
+		CHECK_TICK
+	if(captainless)
+		for(var/mob/dead/new_player/N in GLOB.player_list)
+			if(N.new_character)
+				to_chat(N, "Captainship not forced on anyone.")
+			CHECK_TICK
+
+/datum/controller/subsystem/ticker/proc/transfer_characters()
+	var/list/livings = list()
+	for(var/mob/dead/new_player/player in GLOB.mob_list)
+		var/mob/living = player.transfer_character()
+		if(living)
+			qdel(player)
+			living.notransform = TRUE
+			if(living.client)
+				var/obj/screen/splash/S = new(living.client, TRUE)
+				S.Fade(TRUE)
+			livings += living
+	if(livings.len)
+		addtimer(CALLBACK(src, .proc/release_characters, livings), 30, TIMER_CLIENT_TIME)
+
+/datum/controller/subsystem/ticker/proc/release_characters(list/livings)
+	for(var/I in livings)
+		var/mob/living/L = I
+		L.notransform = FALSE
+
+/datum/controller/subsystem/ticker/proc/send_tip_of_the_round()
+	var/m
+	if(selected_tip)
+		m = selected_tip
+	else
+		var/list/randomtips = world.file2list("strings/tips.txt")
+		var/list/memetips = world.file2list("strings/sillytips.txt")
+		if(randomtips.len && prob(95))
+			m = pick(randomtips)
+		else if(memetips.len)
+			m = pick(memetips)
+
+	if(m)
+		to_chat(world, "<span class='purple'><b>Tip of the round: </b>[html_encode(m)]</span>")
+
+/datum/controller/subsystem/ticker/proc/check_queue()
+	var/hpc = CONFIG_GET(number/hard_popcap)
+	if(!queued_players.len || !hpc)
+		return
+
+	queue_delay++
+	var/mob/dead/new_player/next_in_line = queued_players[1]
+
+	switch(queue_delay)
+		if(5) //every 5 ticks check if there is a slot available
+			if(living_player_count() < hpc)
+				if(next_in_line && next_in_line.client)
+					to_chat(next_in_line, "<span class='userdanger'>A slot has opened! You have approximately 20 seconds to join. <a href='?src=[REF(next_in_line)];late_join=override'>\>\>Join Game\<\<</a></span>")
+					SEND_SOUND(next_in_line, sound('sound/misc/notice1.ogg'))
+					next_in_line.LateChoices()
+					return
+				queued_players -= next_in_line //Client disconnected, remove he
+			queue_delay = 0 //No vacancy: restart timer
+		if(25 to INFINITY)  //No response from the next in line when a vacancy exists, remove he
+			to_chat(next_in_line, "<span class='danger'>No response received. You have been removed from the line.</span>")
+			queued_players -= next_in_line
+			queue_delay = 0
+
+/datum/controller/subsystem/ticker/proc/check_maprotate()
+	if (!CONFIG_GET(flag/maprotation))
+		return
+	if (SSshuttle.emergency && SSshuttle.emergency.mode != SHUTTLE_ESCAPE || SSshuttle.canRecall())
+		return
+	if (maprotatechecked)
+		return
+
+	maprotatechecked = 1
+
+	//map rotate chance defaults to 75% of the length of the round (in minutes)
+	if (!prob((world.time/600)*CONFIG_GET(number/maprotatechancedelta)) && CONFIG_GET(flag/tgstyle_maprotation))
+		return
+	if(CONFIG_GET(flag/tgstyle_maprotation))
+		INVOKE_ASYNC(SSmapping, /datum/controller/subsystem/mapping/.proc/maprotate)
+	else
+		SSvote.initiate_vote("map","server",TRUE)
+
+/datum/controller/subsystem/ticker/proc/HasRoundStarted()
+	return current_state >= GAME_STATE_PLAYING
+
+/datum/controller/subsystem/ticker/proc/IsRoundInProgress()
+	return current_state == GAME_STATE_PLAYING
+
+/proc/send_gamemode_vote() //CIT CHANGE - adds roundstart gamemode votes
+	if(SSticker.current_state == GAME_STATE_PREGAME)
+		if(SSticker.timeLeft < 900)
+			SSticker.timeLeft = 900
+		SSticker.modevoted = TRUE
+		SSvote.initiate_vote("roundtype","server",TRUE)
+
+/datum/controller/subsystem/ticker/Recover()
+	current_state = SSticker.current_state
+	force_ending = SSticker.force_ending
+	hide_mode = SSticker.hide_mode
+	mode = SSticker.mode
+	event_time = SSticker.event_time
+	event = SSticker.event
+
+	login_music = SSticker.login_music
+	round_end_sound = SSticker.round_end_sound
+
+	minds = SSticker.minds
+
+	syndicate_coalition = SSticker.syndicate_coalition
+	factions = SSticker.factions
+	availablefactions = SSticker.availablefactions
+
+	delay_end = SSticker.delay_end
+
+	triai = SSticker.triai
+	tipped = SSticker.tipped
+	selected_tip = SSticker.selected_tip
+
+	timeLeft = SSticker.timeLeft
+
+	totalPlayers = SSticker.totalPlayers
+	totalPlayersReady = SSticker.totalPlayersReady
+
+	queue_delay = SSticker.queue_delay
+	queued_players = SSticker.queued_players
+	maprotatechecked = SSticker.maprotatechecked
+	round_start_time = SSticker.round_start_time
+
+	queue_delay = SSticker.queue_delay
+	queued_players = SSticker.queued_players
+	maprotatechecked = SSticker.maprotatechecked
+
+	modevoted = SSticker.modevoted
+
+	switch (current_state)
+		if(GAME_STATE_SETTING_UP)
+			Master.SetRunLevel(RUNLEVEL_SETUP)
+		if(GAME_STATE_PLAYING)
+			Master.SetRunLevel(RUNLEVEL_GAME)
+		if(GAME_STATE_FINISHED)
+			Master.SetRunLevel(RUNLEVEL_POSTGAME)
+
+/datum/controller/subsystem/ticker/proc/send_news_report()
+	var/news_message
+	var/news_source = "Nanotrasen News Network"
+	switch(news_report)
+		if(NUKE_SYNDICATE_BASE)
+			news_message = "In a daring raid, the heroic crew of [station_name()] detonated a nuclear device in the heart of a terrorist base."
+		if(STATION_DESTROYED_NUKE)
+			news_message = "We would like to reassure all employees that the reports of a Syndicate backed nuclear attack on [station_name()] are, in fact, a hoax. Have a secure day!"
+		if(STATION_EVACUATED)
+			news_message = "The crew of [station_name()] has been evacuated amid unconfirmed reports of enemy activity."
+		if(BLOB_WIN)
+			news_message = "[station_name()] was overcome by an unknown biological outbreak, killing all crew on board. Don't let it happen to you! Remember, a clean work station is a safe work station."
+		if(BLOB_NUKE)
+			news_message = "[station_name()] is currently undergoing decontanimation after a controlled burst of radiation was used to remove a biological ooze. All employees were safely evacuated prior, and are enjoying a relaxing vacation."
+		if(BLOB_DESTROYED)
+			news_message = "[station_name()] is currently undergoing decontamination procedures after the destruction of a biological hazard. As a reminder, any crew members experiencing cramps or bloating should report immediately to security for incineration."
+		if(CULT_ESCAPE)
+			news_message = "Security Alert: A group of religious fanatics have escaped from [station_name()]."
+		if(CULT_FAILURE)
+			news_message = "Following the dismantling of a restricted cult aboard [station_name()], we would like to remind all employees that worship outside of the Chapel is strictly prohibited, and cause for termination."
+		if(CULT_SUMMON)
+			news_message = "Company officials would like to clarify that [station_name()] was scheduled to be decommissioned following meteor damage earlier this year. Earlier reports of an unknowable eldritch horror were made in error."
+		if(NUKE_MISS)
+			news_message = "The Syndicate have bungled a terrorist attack [station_name()], detonating a nuclear weapon in empty space nearby."
+		if(OPERATIVES_KILLED)
+			news_message = "Repairs to [station_name()] are underway after an elite Syndicate death squad was wiped out by the crew."
+		if(OPERATIVE_SKIRMISH)
+			news_message = "A skirmish between security forces and Syndicate agents aboard [station_name()] ended with both sides bloodied but intact."
+		if(REVS_WIN)
+			news_message = "Company officials have reassured investors that despite a union led revolt aboard [station_name()] there will be no wage increases for workers."
+		if(REVS_LOSE)
+			news_message = "[station_name()] quickly put down a misguided attempt at mutiny. Remember, unionizing is illegal!"
+		if(WIZARD_KILLED)
+			news_message = "Tensions have flared with the Space Wizard Federation following the death of one of their members aboard [station_name()]."
+		if(STATION_NUKED)
+			news_message = "[station_name()] activated its self destruct device for unknown reasons. Attempts to clone the Captain so he can be arrested and executed are underway."
+		if(CLOCK_SUMMON)
+			news_message = "The garbled messages about hailing a mouse and strange energy readings from [station_name()] have been discovered to be an ill-advised, if thorough, prank by a clown."
+		if(CLOCK_SILICONS)
+			news_message = "The project started by [station_name()] to upgrade their silicon units with advanced equipment have been largely successful, though they have thus far refused to release schematics in a violation of company policy."
+		if(CLOCK_PROSELYTIZATION)
+			news_message = "The burst of energy released near [station_name()] has been confirmed as merely a test of a new weapon. However, due to an unexpected mechanical error, their communications system has been knocked offline."
+		if(SHUTTLE_HIJACK)
+			news_message = "During routine evacuation procedures, the emergency shuttle of [station_name()] had its navigation protocols corrupted and went off course, but was recovered shortly after."
+		if(GANG_VICTORY)
+			news_message = "Company officials reaffirmed that sudden deployments of special forces are not in any way connected to rumors of [station_name()] being covered in graffiti."
+
+	if(SSblackbox.first_death)
+		var/list/ded = SSblackbox.first_death
+		if(ded.len)
+			news_message += " NT Sanctioned Psykers picked up faint traces of someone near the station, allegedly having had died. Their name was: [ded["name"]], [ded["role"]], at [ded["area"]].[ded["last_words"] ? " Their last words were: \"[ded["last_words"]]\"" : ""]"
+		else
+			news_message += " NT Sanctioned Psykers proudly confirm reports that nobody died this shift!"
+
+	if(news_message)
+		send2otherserver(news_source, news_message,"News_Report")
+		return news_message
+	else
+		return "We regret to inform you that shit be whack, yo. None of our reporters have any idea of what may or may not have gone on."
+
+/datum/controller/subsystem/ticker/proc/GetTimeLeft()
+	if(isnull(SSticker.timeLeft))
+		return max(0, start_at - world.time)
+	return timeLeft
+
+/datum/controller/subsystem/ticker/proc/SetTimeLeft(newtime)
+	if(newtime >= 0 && isnull(timeLeft))	//remember, negative means delayed
+		start_at = world.time + newtime
+	else
+		timeLeft = newtime
+
+//Everyone who wanted to be an observer gets made one now
+/datum/controller/subsystem/ticker/proc/create_observers()
+	for(var/mob/dead/new_player/player in GLOB.player_list)
+		if(player.ready == PLAYER_READY_TO_OBSERVE && player.mind)
+			//Break chain since this has a sleep input in it
+			addtimer(CALLBACK(player, /mob/dead/new_player.proc/make_me_an_observer), 1)
+
+/datum/controller/subsystem/ticker/proc/load_mode()
+	var/mode = trim(file2text("data/mode.txt"))
+	if(mode)
+		GLOB.master_mode = mode
+	else
+		GLOB.master_mode = "extended"
+	log_game("Saved mode is '[GLOB.master_mode]'")
+
+/datum/controller/subsystem/ticker/proc/save_mode(the_mode)
+	var/F = file("data/mode.txt")
+	fdel(F)
+	WRITE_FILE(F, the_mode)
+
+/datum/controller/subsystem/ticker/proc/SetRoundEndSound(the_sound)
+	set waitfor = FALSE
+	round_end_sound_sent = FALSE
+	round_end_sound = fcopy_rsc(the_sound)
+	for(var/thing in GLOB.clients)
+		var/client/C = thing
+		if (!C)
+			continue
+		C.Export("##action=load_rsc", round_end_sound)
+	round_end_sound_sent = TRUE
+
+/datum/controller/subsystem/ticker/proc/Reboot(reason, end_string, delay)
+	set waitfor = FALSE
+	if(usr && !check_rights(R_SERVER, TRUE))
+		return
+
+	if(!delay)
+		delay = CONFIG_GET(number/round_end_countdown) * 10
+
+	var/skip_delay = check_rights()
+	if(delay_end && !skip_delay)
+		to_chat(world, "<span class='boldannounce'>An admin has delayed the round end.</span>")
+		return
+
+	to_chat(world, "<span class='boldannounce'>Rebooting World in [DisplayTimeText(delay)]. [reason]</span>")
+
+	var/start_wait = world.time
+	UNTIL(round_end_sound_sent || (world.time - start_wait) > (delay * 2))	//don't wait forever
+	sleep(delay - (world.time - start_wait))
+
+	if(delay_end && !skip_delay)
+		to_chat(world, "<span class='boldannounce'>Reboot was cancelled by an admin.</span>")
+		return
+	if(end_string)
+		end_state = end_string
+
+	var/statspage = CONFIG_GET(string/roundstatsurl)
+	var/gamelogloc = CONFIG_GET(string/gamelogurl)
+	if(statspage)
+		to_chat(world, "<span class='info'>Round statistics and logs can be viewed <a href=\"[statspage][GLOB.round_id]\">at this website!</a></span>")
+	else if(gamelogloc)
+		to_chat(world, "<span class='info'>Round logs can be located <a href=\"[gamelogloc]\">at this website!</a></span>")
+
+	log_game("<span class='boldannounce'>Rebooting World. [reason]</span>")
+
+	world.Reboot()
+
+/datum/controller/subsystem/ticker/Shutdown()
+	gather_newscaster() //called here so we ensure the log is created even upon admin reboot
+	save_admin_data()
+	update_everything_flag_in_db()
+	if(!round_end_sound)
+		round_end_sound = pick(\
+		'sound/roundend/newroundsexy.ogg',
+		'sound/roundend/apcdestroyed.ogg',
+		'sound/roundend/bangindonk.ogg',
+		'sound/roundend/leavingtg.ogg',
+		'sound/roundend/its_only_game.ogg',
+		'sound/roundend/yeehaw.ogg',
+		'sound/roundend/disappointed.ogg',
+		'sound/roundend/gondolabridge.ogg',
+		'sound/roundend/haveabeautifultime.ogg'\
+		)
+
+	SEND_SOUND(world, sound(round_end_sound))
+	text2file(login_music, "data/last_round_lobby_music.txt")

code/controllers/subsystem/time_track.dm

@@ -0,0 +1,38 @@
+SUBSYSTEM_DEF(time_track)
+	name = "Time Tracking"
+	wait = 600
+	flags = SS_NO_INIT|SS_NO_TICK_CHECK
+	runlevels = RUNLEVEL_LOBBY | RUNLEVELS_DEFAULT
+
+	var/time_dilation_current = 0
+
+	var/time_dilation_avg_fast = 0
+	var/time_dilation_avg = 0
+	var/time_dilation_avg_slow = 0
+
+	var/first_run = TRUE
+
+	var/last_tick_realtime = 0
+	var/last_tick_byond_time = 0
+	var/last_tick_tickcount = 0
+
+/datum/controller/subsystem/time_track/fire()
+
+	var/current_realtime = REALTIMEOFDAY
+	var/current_byondtime = world.time
+	var/current_tickcount = world.time/world.tick_lag
+
+	if (!first_run)
+		var/tick_drift = max(0, (((current_realtime - last_tick_realtime) - (current_byondtime - last_tick_byond_time)) / world.tick_lag))
+
+		time_dilation_current = tick_drift / (current_tickcount - last_tick_tickcount) * 100
+
+		time_dilation_avg_fast = MC_AVERAGE_FAST(time_dilation_avg_fast, time_dilation_current)
+		time_dilation_avg = MC_AVERAGE(time_dilation_avg, time_dilation_avg_fast)
+		time_dilation_avg_slow = MC_AVERAGE_SLOW(time_dilation_avg_slow, time_dilation_avg)
+	else
+		first_run = FALSE
+	last_tick_realtime = current_realtime
+	last_tick_byond_time = current_byondtime
+	last_tick_tickcount = current_tickcount
+	SSblackbox.record_feedback("associative", "time_dilation_current", 1, list("[SQLtime()]" = list("current" = "[time_dilation_current]", "avg_fast" = "[time_dilation_avg_fast]", "avg" = "[time_dilation_avg]", "avg_slow" = "[time_dilation_avg_slow]")))

code/controllers/subsystem/timer.dm

@@ -0,0 +1,521 @@
+#define BUCKET_LEN (world.fps*1*60) //how many ticks should we keep in the bucket. (1 minutes worth)
+#define BUCKET_POS(timer) ((round((timer.timeToRun - SStimer.head_offset) / world.tick_lag) % BUCKET_LEN)||BUCKET_LEN)
+#define TIMER_MAX (world.time + TICKS2DS(min(BUCKET_LEN-(SStimer.practical_offset-DS2TICKS(world.time - SStimer.head_offset))-1, BUCKET_LEN-1)))
+#define TIMER_ID_MAX (2**24) //max float with integer precision
+
+SUBSYSTEM_DEF(timer)
+	name = "Timer"
+	wait = 1 //SS_TICKER subsystem, so wait is in ticks
+	init_order = INIT_ORDER_TIMER
+
+	flags = SS_TICKER|SS_NO_INIT
+
+	var/list/datum/timedevent/second_queue = list() //awe, yes, you've had first queue, but what about second queue?
+	var/list/hashes = list()
+
+	var/head_offset = 0 //world.time of the first entry in the the bucket.
+	var/practical_offset = 1 //index of the first non-empty item in the bucket.
+	var/bucket_resolution = 0 //world.tick_lag the bucket was designed for
+	var/bucket_count = 0 //how many timers are in the buckets
+
+	var/list/bucket_list = list() //list of buckets, each bucket holds every timer that has to run that byond tick.
+
+	var/list/timer_id_dict = list() //list of all active timers assoicated to their timer id (for easy lookup)
+
+	var/list/clienttime_timers = list() //special snowflake timers that run on fancy pansy "client time"
+
+	var/last_invoke_tick = 0
+	var/static/last_invoke_warning = 0
+	var/static/bucket_auto_reset = TRUE
+
+/datum/controller/subsystem/timer/PreInit()
+	bucket_list.len = BUCKET_LEN
+	head_offset = world.time
+	bucket_resolution = world.tick_lag
+
+/datum/controller/subsystem/timer/stat_entry(msg)
+	..("B:[bucket_count] P:[length(second_queue)] H:[length(hashes)] C:[length(clienttime_timers)] S:[length(timer_id_dict)]")
+
+/datum/controller/subsystem/timer/fire(resumed = FALSE)
+	var/lit = last_invoke_tick
+	var/last_check = world.time - TIMER_NO_INVOKE_WARNING
+	var/list/bucket_list = src.bucket_list
+
+	if(!bucket_count)
+		last_invoke_tick = world.time
+
+	if(lit && lit < last_check && last_invoke_warning < last_check)
+		last_invoke_warning = world.time
+		var/msg = "No regular timers processed in the last [TIMER_NO_INVOKE_WARNING] ticks[bucket_auto_reset ? ", resetting buckets" : ""]!"
+		message_admins(msg)
+		WARNING(msg)
+		if(bucket_auto_reset)
+			bucket_resolution = 0
+
+		log_world("Timer bucket reset. world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
+		for (var/i in 1 to length(bucket_list))
+			var/datum/timedevent/bucket_head = bucket_list[i]
+			if (!bucket_head)
+				continue
+
+			log_world("Active timers at index [i]:")
+
+			var/datum/timedevent/bucket_node = bucket_head
+			var/anti_loop_check = 1000
+			do
+				log_world(get_timer_debug_string(bucket_node))
+				bucket_node = bucket_node.next
+				anti_loop_check--
+			while(bucket_node && bucket_node != bucket_head && anti_loop_check)
+		log_world("Active timers in the second_queue queue:")
+		for(var/I in second_queue)
+			log_world(get_timer_debug_string(I))
+
+	var/next_clienttime_timer_index = 0
+	var/len = length(clienttime_timers)
+
+	for (next_clienttime_timer_index in 1 to len)
+		if (MC_TICK_CHECK)
+			next_clienttime_timer_index--
+			break
+		var/datum/timedevent/ctime_timer = clienttime_timers[next_clienttime_timer_index]
+		if (ctime_timer.timeToRun > REALTIMEOFDAY)
+			next_clienttime_timer_index--
+			break
+
+		var/datum/callback/callBack = ctime_timer.callBack
+		if (!callBack)
+			clienttime_timers.Cut(next_clienttime_timer_index,next_clienttime_timer_index+1)
+			CRASH("Invalid timer: [get_timer_debug_string(ctime_timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset], REALTIMEOFDAY: [REALTIMEOFDAY]")
+
+		ctime_timer.spent = REALTIMEOFDAY
+		callBack.InvokeAsync()
+
+		if(ctime_timer.flags & TIMER_LOOP)
+			ctime_timer.spent = 0
+			ctime_timer.timeToRun = REALTIMEOFDAY + ctime_timer.wait
+			BINARY_INSERT(ctime_timer, clienttime_timers, datum/timedevent, timeToRun)
+		else
+			qdel(ctime_timer)
+
+
+	if (next_clienttime_timer_index)
+		clienttime_timers.Cut(1, next_clienttime_timer_index+1)
+
+	if (MC_TICK_CHECK)
+		return
+
+	var/static/list/spent = list()
+	var/static/datum/timedevent/timer
+	if (practical_offset > BUCKET_LEN)
+		head_offset += TICKS2DS(BUCKET_LEN)
+		practical_offset = 1
+		resumed = FALSE
+
+	if ((length(bucket_list) != BUCKET_LEN) || (world.tick_lag != bucket_resolution))
+		reset_buckets()
+		bucket_list = src.bucket_list
+		resumed = FALSE
+
+
+	if (!resumed)
+		timer = null
+
+	while (practical_offset <= BUCKET_LEN && head_offset + (practical_offset*world.tick_lag) <= world.time)
+		var/datum/timedevent/head = bucket_list[practical_offset]
+		if (!timer || !head || timer == head)
+			head = bucket_list[practical_offset]
+			timer = head
+		while (timer)
+			var/datum/callback/callBack = timer.callBack
+			if (!callBack)
+				bucket_resolution = null //force bucket recreation
+				CRASH("Invalid timer: [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
+
+			if (!timer.spent)
+				spent += timer
+				timer.spent = world.time
+				callBack.InvokeAsync()
+				last_invoke_tick = world.time
+
+			if (MC_TICK_CHECK)
+				return
+
+			timer = timer.next
+			if (timer == head)
+				break
+
+
+		bucket_list[practical_offset++] = null
+
+		//we freed up a bucket, lets see if anything in second_queue needs to be shifted to that bucket.
+		var/i = 0
+		var/L = length(second_queue)
+		for (i in 1 to L)
+			timer = second_queue[i]
+			if (timer.timeToRun >= TIMER_MAX)
+				i--
+				break
+
+			if (timer.timeToRun < head_offset)
+				bucket_resolution = null //force bucket recreation
+				CRASH("[i] Invalid timer state: Timer in long run queue with a time to run less then head_offset. [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
+
+				if (timer.callBack && !timer.spent)
+					timer.callBack.InvokeAsync()
+					spent += timer
+					bucket_count++
+				else if(!QDELETED(timer))
+					qdel(timer)
+				continue
+
+			if (timer.timeToRun < head_offset + TICKS2DS(practical_offset))
+				bucket_resolution = null //force bucket recreation
+				CRASH("[i] Invalid timer state: Timer in long run queue that would require a backtrack to transfer to short run queue. [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
+				if (timer.callBack && !timer.spent)
+					timer.callBack.InvokeAsync()
+					spent += timer
+					bucket_count++
+				else if(!QDELETED(timer))
+					qdel(timer)
+				continue
+
+			bucket_count++
+			var/bucket_pos = max(1, BUCKET_POS(timer))
+
+			var/datum/timedevent/bucket_head = bucket_list[bucket_pos]
+			if (!bucket_head)
+				bucket_list[bucket_pos] = timer
+				timer.next = null
+				timer.prev = null
+				continue
+
+			if (!bucket_head.prev)
+				bucket_head.prev = bucket_head
+			timer.next = bucket_head
+			timer.prev = bucket_head.prev
+			timer.next.prev = timer
+			timer.prev.next = timer
+		if (i)
+			second_queue.Cut(1, i+1)
+
+		timer = null
+
+	bucket_count -= length(spent)
+
+	for (var/i in spent)
+		var/datum/timedevent/qtimer = i
+		if(QDELETED(qtimer))
+			bucket_count++
+			continue
+		if(!(qtimer.flags & TIMER_LOOP))
+			qdel(qtimer)
+		else
+			bucket_count++
+			qtimer.spent = 0
+			qtimer.bucketEject()
+			if(qtimer.flags & TIMER_CLIENT_TIME)
+				qtimer.timeToRun = REALTIMEOFDAY + qtimer.wait
+			else
+				qtimer.timeToRun = world.time + qtimer.wait
+			qtimer.bucketJoin()
+
+	spent.len = 0
+
+//formated this way to be runtime resistant
+/datum/controller/subsystem/timer/proc/get_timer_debug_string(datum/timedevent/TE)
+	. = "Timer: [TE]"
+	. += "Prev: [TE.prev ? TE.prev : "NULL"], Next: [TE.next ? TE.next : "NULL"]"
+	if(TE.spent)
+		. += ", SPENT([TE.spent])"
+	if(QDELETED(TE))
+		. += ", QDELETED"
+	if(!TE.callBack)
+		. += ", NO CALLBACK"
+
+/datum/controller/subsystem/timer/proc/reset_buckets()
+	var/list/bucket_list = src.bucket_list
+	var/list/alltimers = list()
+	//collect the timers currently in the bucket
+	for (var/bucket_head in bucket_list)
+		if (!bucket_head)
+			continue
+		var/datum/timedevent/bucket_node = bucket_head
+		do
+			alltimers += bucket_node
+			bucket_node = bucket_node.next
+		while(bucket_node && bucket_node != bucket_head)
+
+	bucket_list.len = 0
+	bucket_list.len = BUCKET_LEN
+
+	practical_offset = 1
+	bucket_count = 0
+	head_offset = world.time
+	bucket_resolution = world.tick_lag
+
+	alltimers += second_queue
+	if (!length(alltimers))
+		return
+
+	sortTim(alltimers, .proc/cmp_timer)
+
+	var/datum/timedevent/head = alltimers[1]
+
+	if (head.timeToRun < head_offset)
+		head_offset = head.timeToRun
+
+	var/new_bucket_count
+	var/i = 1
+	for (i in 1 to length(alltimers))
+		var/datum/timedevent/timer = alltimers[i]
+		if (!timer)
+			continue
+
+		var/bucket_pos = BUCKET_POS(timer)
+		if (timer.timeToRun >= TIMER_MAX)
+			i--
+			break
+
+
+		if (!timer.callBack || timer.spent)
+			WARNING("Invalid timer: [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
+			if (timer.callBack)
+				qdel(timer)
+			continue
+
+		new_bucket_count++
+		var/datum/timedevent/bucket_head = bucket_list[bucket_pos]
+		if (!bucket_head)
+			bucket_list[bucket_pos] = timer
+			timer.next = null
+			timer.prev = null
+			continue
+
+		if (!bucket_head.prev)
+			bucket_head.prev = bucket_head
+		timer.next = bucket_head
+		timer.prev = bucket_head.prev
+		timer.next.prev = timer
+		timer.prev.next = timer
+	if (i)
+		alltimers.Cut(1, i+1)
+	second_queue = alltimers
+	bucket_count = new_bucket_count
+
+
+/datum/controller/subsystem/timer/Recover()
+	second_queue |= SStimer.second_queue
+	hashes |= SStimer.hashes
+	timer_id_dict |= SStimer.timer_id_dict
+	bucket_list |= SStimer.bucket_list
+
+/datum/timedevent
+	var/id
+	var/datum/callback/callBack
+	var/timeToRun
+	var/wait
+	var/hash
+	var/list/flags
+	var/spent = 0 //time we ran the timer.
+	var/name //for easy debugging.
+	//cicular doublely linked list
+	var/datum/timedevent/next
+	var/datum/timedevent/prev
+
+/datum/timedevent/New(datum/callback/callBack, wait, flags, hash)
+	var/static/nextid = 1
+	id = TIMER_ID_NULL
+	src.callBack = callBack
+	src.wait = wait
+	src.flags = flags
+	src.hash = hash
+
+	if (flags & TIMER_CLIENT_TIME)
+		timeToRun = REALTIMEOFDAY + wait
+	else
+		timeToRun = world.time + wait
+
+	if (flags & TIMER_UNIQUE)
+		SStimer.hashes[hash] = src
+
+	if (flags & TIMER_STOPPABLE)
+		id = num2text(nextid, 100)
+		if (nextid >= SHORT_REAL_LIMIT)
+			nextid += min(1, 2**round(nextid/SHORT_REAL_LIMIT))
+		else
+			nextid++
+		SStimer.timer_id_dict[id] = src
+
+	name = "Timer: [id] (\ref[src]), TTR: [timeToRun], Flags: [jointext(bitfield2list(flags, list("TIMER_UNIQUE", "TIMER_OVERRIDE", "TIMER_CLIENT_TIME", "TIMER_STOPPABLE", "TIMER_NO_HASH_WAIT", "TIMER_LOOP")), ", ")], callBack: \ref[callBack], callBack.object: [callBack.object]\ref[callBack.object]([getcallingtype()]), callBack.delegate:[callBack.delegate]([callBack.arguments ? callBack.arguments.Join(", ") : ""])"
+
+	if ((timeToRun < world.time || timeToRun < SStimer.head_offset) && !(flags & TIMER_CLIENT_TIME))
+		CRASH("Invalid timer state: Timer created that would require a backtrack to run (addtimer would never let this happen): [SStimer.get_timer_debug_string(src)]")
+
+	if (callBack.object != GLOBAL_PROC && !QDESTROYING(callBack.object))
+		LAZYADD(callBack.object.active_timers, src)
+
+	bucketJoin()
+
+/datum/timedevent/Destroy()
+	..()
+	if (flags & TIMER_UNIQUE && hash)
+		SStimer.hashes -= hash
+
+	if (callBack && callBack.object && callBack.object != GLOBAL_PROC && callBack.object.active_timers)
+		callBack.object.active_timers -= src
+		UNSETEMPTY(callBack.object.active_timers)
+
+	callBack = null
+
+	if (flags & TIMER_STOPPABLE)
+		SStimer.timer_id_dict -= id
+
+	if (flags & TIMER_CLIENT_TIME)
+		if (!spent)
+			spent = world.time
+			SStimer.clienttime_timers -= src
+		return QDEL_HINT_IWILLGC
+
+	if (!spent)
+		spent = world.time
+		bucketEject()
+	else
+		if (prev && prev.next == src)
+			prev.next = next
+		if (next && next.prev == src)
+			next.prev = prev
+	next = null
+	prev = null
+	return QDEL_HINT_IWILLGC
+
+/datum/timedevent/proc/bucketEject()
+	var/bucketpos = BUCKET_POS(src)
+	var/list/bucket_list = SStimer.bucket_list
+	var/list/second_queue = SStimer.second_queue
+	var/datum/timedevent/buckethead
+	if(bucketpos > 0)
+		buckethead = bucket_list[bucketpos]
+	if(buckethead == src)
+		bucket_list[bucketpos] = next
+		SStimer.bucket_count--
+	else if(timeToRun < TIMER_MAX || next || prev)
+		SStimer.bucket_count--
+	else
+		var/l = length(second_queue)
+		second_queue -= src
+		if(l == length(second_queue))
+			SStimer.bucket_count--
+	if(prev != next)
+		prev.next = next
+		next.prev = prev
+	else
+		prev?.next = null
+		next?.prev = null
+	prev = next = null
+
+/datum/timedevent/proc/bucketJoin()
+	var/list/L
+
+	if (flags & TIMER_CLIENT_TIME)
+		L = SStimer.clienttime_timers
+	else if (timeToRun >= TIMER_MAX)
+		L = SStimer.second_queue
+
+	if(L)
+		BINARY_INSERT(src, L, datum/timedevent, timeToRun)
+		return
+
+	//get the list of buckets
+	var/list/bucket_list = SStimer.bucket_list
+
+	//calculate our place in the bucket list
+	var/bucket_pos = BUCKET_POS(src)
+
+	//get the bucket for our tick
+	var/datum/timedevent/bucket_head = bucket_list[bucket_pos]
+	SStimer.bucket_count++
+	//empty bucket, we will just add ourselves
+	if (!bucket_head)
+		bucket_list[bucket_pos] = src
+		return
+	//other wise, lets do a simplified linked list add.
+	if (!bucket_head.prev)
+		bucket_head.prev = bucket_head
+	next = bucket_head
+	prev = bucket_head.prev
+	next.prev = src
+	prev.next = src
+
+/datum/timedevent/proc/getcallingtype()
+	. = "ERROR"
+	if (callBack.object == GLOBAL_PROC)
+		. = "GLOBAL_PROC"
+	else
+		. = "[callBack.object.type]"
+
+/proc/addtimer(datum/callback/callback, wait = 0, flags = 0)
+	if (!callback)
+		CRASH("addtimer called without a callback")
+
+	if (wait < 0)
+		stack_trace("addtimer called with a negative wait. Converting to [world.tick_lag]")
+
+	if (callback.object != GLOBAL_PROC && QDELETED(callback.object) && !QDESTROYING(callback.object))
+		stack_trace("addtimer called with a callback assigned to a qdeleted object. In the future such timers will not be supported and may refuse to run or run with a 0 wait")
+
+	wait = max(CEILING(wait, world.tick_lag), world.tick_lag)
+
+	if(wait >= INFINITY)
+		CRASH("Attempted to create timer with INFINITY delay")
+
+	var/hash
+
+	if (flags & TIMER_UNIQUE)
+		var/list/hashlist
+		if(flags & TIMER_NO_HASH_WAIT)
+			hashlist = list(callback.object, "([REF(callback.object)])", callback.delegate, flags & TIMER_CLIENT_TIME)
+		else
+			hashlist = list(callback.object, "([REF(callback.object)])", callback.delegate, wait, flags & TIMER_CLIENT_TIME)
+		hashlist += callback.arguments
+		hash = hashlist.Join("|||||||")
+
+		var/datum/timedevent/hash_timer = SStimer.hashes[hash]
+		if(hash_timer)
+			if (hash_timer.spent) //it's pending deletion, pretend it doesn't exist.
+				hash_timer.hash = null //but keep it from accidentally deleting us
+			else
+				if (flags & TIMER_OVERRIDE)
+					hash_timer.hash = null //no need having it delete it's hash if we are going to replace it
+					qdel(hash_timer)
+				else
+					if (hash_timer.flags & TIMER_STOPPABLE)
+						. = hash_timer.id
+					return
+	else if(flags & TIMER_OVERRIDE)
+		stack_trace("TIMER_OVERRIDE used without TIMER_UNIQUE")
+
+	var/datum/timedevent/timer = new(callback, wait, flags, hash)
+	return timer.id
+
+/proc/deltimer(id)
+	if (!id)
+		return FALSE
+	if (id == TIMER_ID_NULL)
+		CRASH("Tried to delete a null timerid. Use TIMER_STOPPABLE flag")
+	if (!istext(id))
+		if (istype(id, /datum/timedevent))
+			qdel(id)
+			return TRUE
+	//id is string
+	var/datum/timedevent/timer = SStimer.timer_id_dict[id]
+	if (timer && !timer.spent)
+		qdel(timer)
+		return TRUE
+	return FALSE
+
+
+#undef BUCKET_LEN
+#undef BUCKET_POS
+#undef TIMER_MAX
+#undef TIMER_ID_MAX

code/controllers/subsystem/title.dm

@@ -0,0 +1,69 @@
+SUBSYSTEM_DEF(title)
+	name = "Title Screen"
+	flags = SS_NO_FIRE
+	init_order = INIT_ORDER_TITLE
+
+	var/file_path
+	var/icon/icon
+	var/icon/previous_icon
+	var/turf/closed/indestructible/splashscreen/splash_turf
+
+/datum/controller/subsystem/title/Initialize()
+	if(file_path && icon)
+		return
+
+	if(fexists("data/previous_title.dat"))
+		var/previous_path = file2text("data/previous_title.dat")
+		if(istext(previous_path))
+			previous_icon = new(previous_icon)
+	fdel("data/previous_title.dat")
+
+	var/list/provisional_title_screens = flist("[global.config.directory]/title_screens/images/")
+	var/list/title_screens = list()
+	var/use_rare_screens = prob(1)
+
+	SSmapping.HACK_LoadMapConfig()
+	for(var/S in provisional_title_screens)
+		var/list/L = splittext(S,"+")
+		if((L.len == 1 && L[1] != "blank.png")|| (L.len > 1 && ((use_rare_screens && lowertext(L[1]) == "rare") || (lowertext(L[1]) == lowertext(SSmapping.config.map_name)))))
+			title_screens += S
+
+	if(length(title_screens))
+		file_path = "[global.config.directory]/title_screens/images/[pick(title_screens)]"
+	
+	if(!file_path)
+		file_path = "icons/default_title.dmi"
+
+	ASSERT(fexists(file_path))
+
+	icon = new(fcopy_rsc(file_path))
+
+	if(splash_turf)
+		splash_turf.icon = icon
+
+	return ..()
+
+/datum/controller/subsystem/title/vv_edit_var(var_name, var_value)
+	. = ..()
+	if(.)
+		switch(var_name)
+			if("icon")
+				if(splash_turf)
+					splash_turf.icon = icon
+
+/datum/controller/subsystem/title/Shutdown()
+	if(file_path)
+		var/F = file("data/previous_title.dat")
+		WRITE_FILE(F, file_path)
+
+	for(var/thing in GLOB.clients)
+		if(!thing)
+			continue
+		var/obj/screen/splash/S = new(thing, FALSE)
+		S.Fade(FALSE,FALSE)
+
+/datum/controller/subsystem/title/Recover()
+	icon = SStitle.icon
+	splash_turf = SStitle.splash_turf
+	file_path = SStitle.file_path
+	previous_icon = SStitle.previous_icon

code/controllers/subsystem/traumas.dm

@@ -0,0 +1,206 @@
+SUBSYSTEM_DEF(traumas)
+	name = "Traumas"
+	flags = SS_NO_FIRE
+	var/list/phobia_types
+	var/list/phobia_words
+	var/list/phobia_mobs
+	var/list/phobia_objs
+	var/list/phobia_turfs
+	var/list/phobia_species
+
+#define PHOBIA_FILE "phobia.json"
+
+/datum/controller/subsystem/traumas/Initialize()
+	//phobia types is to pull from randomly for brain traumas, e.g. conspiracies is for special assignment only
+	phobia_types = list("spiders", "space", "security", "clowns", "greytide", "lizards",
+						"skeletons", "snakes", "robots", "doctors", "authority", "the supernatural",
+						"aliens", "strangers", "birds", "falling", "anime", "mimes", "cats", "syndicate",
+						"eye"
+						)
+
+	phobia_words = list("spiders"   = strings(PHOBIA_FILE, "spiders"),
+						"space"     = strings(PHOBIA_FILE, "space"),
+						"security"  = strings(PHOBIA_FILE, "security"),
+						"clowns"    = strings(PHOBIA_FILE, "clowns"),
+						"greytide"  = strings(PHOBIA_FILE, "greytide"),
+						"lizards"   = strings(PHOBIA_FILE, "lizards"),
+						"skeletons" = strings(PHOBIA_FILE, "skeletons"),
+						"snakes"	= strings(PHOBIA_FILE, "snakes"),
+						"robots"	= strings(PHOBIA_FILE, "robots"),
+						"doctors"	= strings(PHOBIA_FILE, "doctors"),
+						"authority"	= strings(PHOBIA_FILE, "authority"),
+						"the supernatural"	= strings(PHOBIA_FILE, "the supernatural"),
+						"aliens"	= strings(PHOBIA_FILE, "aliens"),
+						"strangers"	= strings(PHOBIA_FILE, "strangers"),
+						"conspiracies" = strings(PHOBIA_FILE, "conspiracies"),
+						"birds" = strings(PHOBIA_FILE, "birds"),
+						"falling" = strings(PHOBIA_FILE, "falling"),
+						"anime" = strings(PHOBIA_FILE, "anime"),
+						"mimes" = strings(PHOBIA_FILE, "mimes"),
+						"cats" = strings(PHOBIA_FILE, "cats"),
+						"syndicate"= strings(PHOBIA_FILE, "syndicate"),
+						"eye" = strings(PHOBIA_FILE, "eye")
+            )
+
+	phobia_mobs = list("spiders"  = typecacheof(list(/mob/living/simple_animal/hostile/poison/giant_spider)),
+					   "security" = typecacheof(list(/mob/living/simple_animal/bot/secbot, /mob/living/simple_animal/bot/ed209)),
+					   "lizards"  = typecacheof(list(/mob/living/simple_animal/hostile/lizard)),
+					   "skeletons" = typecacheof(list(/mob/living/simple_animal/hostile/skeleton)),
+					   "snakes"   = typecacheof(list(/mob/living/simple_animal/hostile/retaliate/poison/snake)),
+					   "robots"   = typecacheof(list(/mob/living/silicon/robot, /mob/living/silicon/ai,
+					   /mob/living/simple_animal/drone, /mob/living/simple_animal/bot, /mob/living/simple_animal/hostile/swarmer, /mob/living/simple_animal/bot/honkbot)),
+					   "doctors"   = typecacheof(list(/mob/living/simple_animal/bot/medbot)),
+					   "the supernatural"   = typecacheof(list(/mob/living/simple_animal/hostile/construct,
+					   /mob/living/simple_animal/hostile/clockwork, /mob/living/simple_animal/drone/cogscarab,
+					   /mob/living/simple_animal/revenant, /mob/living/simple_animal/shade)),
+					   "aliens"   = typecacheof(list(/mob/living/carbon/alien, /mob/living/simple_animal/slime)),
+					   "conspiracies" = typecacheof(list(/mob/living/simple_animal/bot/secbot, /mob/living/simple_animal/bot/ed209, /mob/living/simple_animal/drone,
+					   /mob/living/simple_animal/pet/penguin)),
+					   "birds" = typecacheof(list(/mob/living/simple_animal/parrot, /mob/living/simple_animal/chick, /mob/living/simple_animal/chicken,
+					   /mob/living/simple_animal/pet/penguin)),
+					   "anime" = typecacheof(list(/mob/living/simple_animal/hostile/guardian)),
+					   "cats"= typecacheof(list(/mob/living/simple_animal/mouse, /mob/living/simple_animal/pet/cat, /mob/living/simple_animal/hostile/cat_butcherer)),
+					   "syndicate" = typecacheof(list(/mob/living/simple_animal/hostile/syndicate, /mob/living/simple_animal/hostile/viscerator, /mob/living/simple_animal/hostile/carp/cayenne, /mob/living/silicon/robot/modules/syndicate)),
+					   "eye" = typecacheof(list(/mob/living/simple_animal/hostile/asteroid/basilisk/watcher, /mob/living/simple_animal/hostile/carp/eyeball))
+					   )
+
+
+	phobia_objs = list("snakes" = typecacheof(list(/obj/item/rod_of_asclepius)),
+
+					"spiders"   = typecacheof(list(/obj/structure/spider)),
+
+					"security"  = typecacheof(list(/obj/item/clothing/under/rank/security, /obj/item/clothing/under/rank/warden,
+											 	 /obj/item/clothing/under/rank/head_of_security, /obj/item/clothing/under/rank/det,
+												 /obj/item/melee/baton, /obj/item/gun/energy/taser, /obj/item/restraints/handcuffs,
+												 /obj/machinery/door/airlock/security, /obj/effect/hallucination/simple/securitron)),
+
+					"clowns" = typecacheof(list(/obj/item/clothing/under/rank/clown, /obj/item/clothing/shoes/clown_shoes,
+												 /obj/item/clothing/mask/gas/clown_hat, /obj/item/instrument/bikehorn,
+												 /obj/item/pda/clown, /obj/item/grown/bananapeel)),
+
+					"greytide"  = typecacheof(list(/obj/item/clothing/under/color/grey, /obj/item/melee/baton/cattleprod,
+												 /obj/item/twohanded/spear, /obj/item/clothing/mask/gas)),
+
+					"lizards"   = typecacheof(list(/obj/item/toy/plush/lizardplushie, /obj/item/reagent_containers/food/snacks/kebab/tail,
+												 /obj/item/organ/tail/lizard, /obj/item/reagent_containers/food/drinks/bottle/lizardwine)),
+
+					"skeletons" = typecacheof(list(/obj/item/organ/tongue/bone, /obj/item/clothing/suit/armor/bone, /obj/item/stack/sheet/bone,
+												 /obj/item/reagent_containers/food/snacks/meat/slab/human/mutant/skeleton,
+												 /obj/effect/decal/remains/human)),
+				   	"conspiracies" = typecacheof(list(/obj/item/clothing/under/rank/captain, /obj/item/clothing/under/rank/head_of_security,
+												 /obj/item/clothing/under/rank/chief_engineer, /obj/item/clothing/under/rank/chief_medical_officer,
+												 /obj/item/clothing/under/rank/head_of_personnel, /obj/item/clothing/under/rank/research_director,
+												 /obj/item/clothing/under/rank/head_of_security/grey, /obj/item/clothing/under/rank/head_of_security/alt,
+												 /obj/item/clothing/under/rank/research_director/alt, /obj/item/clothing/under/rank/research_director/turtleneck,
+												 /obj/item/clothing/under/captainparade, /obj/item/clothing/under/hosparademale, /obj/item/clothing/under/hosparadefem,
+												 /obj/item/clothing/head/helmet/abductor, /obj/item/clothing/suit/armor/abductor/vest, /obj/item/abductor_baton,
+												 /obj/item/storage/belt/military/abductor, /obj/item/gun/energy/alien, /obj/item/abductor/silencer,
+												 /obj/item/abductor/gizmo, /obj/item/clothing/under/rank/centcom_officer,
+												 /obj/item/clothing/suit/space/hardsuit/ert, /obj/item/clothing/suit/space/hardsuit/ert/sec,
+												 /obj/item/clothing/suit/space/hardsuit/ert/engi, /obj/item/clothing/suit/space/hardsuit/ert/med,
+												 /obj/item/clothing/suit/space/hardsuit/deathsquad, /obj/item/clothing/head/helmet/space/hardsuit/deathsquad,
+												 /obj/machinery/door/airlock/centcom)),
+					"robots"   = typecacheof(list(/obj/machinery/computer/upload, /obj/item/aiModule/, /obj/machinery/recharge_station,
+						/obj/item/aicard, /obj/item/deactivated_swarmer, /obj/effect/mob_spawn/swarmer)),
+
+					"doctors"   = typecacheof(list(/obj/item/clothing/under/rank/medical, /obj/item/clothing/under/rank/chemist,
+						/obj/item/clothing/under/rank/nursesuit, /obj/item/clothing/under/rank/chief_medical_officer,
+						/obj/item/reagent_containers/syringe, /obj/item/reagent_containers/pill/, /obj/item/reagent_containers/hypospray,
+						/obj/item/storage/firstaid, /obj/item/storage/pill_bottle, /obj/item/healthanalyzer,
+						/obj/structure/sign/departments/medbay, /obj/machinery/door/airlock/medical, /obj/machinery/sleeper,
+						/obj/machinery/dna_scannernew, /obj/machinery/atmospherics/components/unary/cryo_cell, /obj/item/surgical_drapes,
+						/obj/item/retractor, /obj/item/hemostat, /obj/item/cautery, /obj/item/surgicaldrill, /obj/item/scalpel, /obj/item/circular_saw,
+						/obj/item/clothing/suit/bio_suit/plaguedoctorsuit, /obj/item/clothing/head/plaguedoctorhat, /obj/item/clothing/mask/gas/plaguedoctor)),
+
+					"authority"   = typecacheof(list(/obj/item/clothing/under/rank/captain,  /obj/item/clothing/under/rank/head_of_personnel,
+						/obj/item/clothing/under/rank/head_of_security, /obj/item/clothing/under/rank/research_director,
+						/obj/item/clothing/under/rank/chief_medical_officer, /obj/item/clothing/under/rank/chief_engineer,
+						/obj/item/clothing/under/rank/centcom_officer, /obj/item/clothing/under/rank/centcom_commander,
+						/obj/item/melee/classic_baton/telescopic, /obj/item/card/id/silver, /obj/item/card/id/gold,
+						/obj/item/card/id/captains_spare, /obj/item/card/id/centcom, /obj/machinery/door/airlock/command)),
+
+					"the supernatural"  = typecacheof(list(/obj/structure/destructible/cult, /obj/item/tome,
+						/obj/item/melee/cultblade, /obj/item/twohanded/required/cult_bastard, /obj/item/restraints/legcuffs/bola/cult,
+						/obj/item/clothing/suit/cultrobes, /obj/item/clothing/suit/space/hardsuit/cult,
+						/obj/item/clothing/suit/hooded/cultrobes, /obj/item/clothing/head/hooded/cult_hoodie, /obj/effect/rune,
+						/obj/item/stack/sheet/runed_metal, /obj/machinery/door/airlock/cult, /obj/singularity/narsie,
+						/obj/item/soulstone,
+						/obj/structure/destructible/clockwork, /obj/item/clockwork, /obj/item/clothing/suit/armor/clockwork,
+						/obj/item/clothing/glasses/judicial_visor, /obj/effect/clockwork/sigil/, /obj/item/stack/tile/brass,
+						/obj/machinery/door/airlock/clockwork,
+						/obj/item/clothing/suit/wizrobe, /obj/item/clothing/head/wizard, /obj/item/spellbook, /obj/item/staff,
+						/obj/item/clothing/suit/space/hardsuit/shielded/wizard, /obj/item/clothing/suit/space/hardsuit/wizard,
+						/obj/item/gun/magic/staff, /obj/item/gun/magic/wand,
+						/obj/item/nullrod, /obj/item/clothing/under/rank/chaplain)),
+
+					"aliens"   = typecacheof(list(/obj/item/clothing/mask/facehugger, /obj/item/organ/body_egg/alien_embryo,
+						/obj/structure/alien, /obj/item/toy/toy_xeno,
+						/obj/item/clothing/suit/armor/abductor, /obj/item/abductor, /obj/item/gun/energy/alien,
+						/obj/item/abductor_baton, /obj/item/radio/headset/abductor, /obj/item/scalpel/alien, /obj/item/hemostat/alien,
+						/obj/item/retractor/alien, /obj/item/circular_saw/alien, /obj/item/surgicaldrill/alien, /obj/item/cautery/alien,
+						/obj/item/clothing/head/helmet/abductor, /obj/structure/bed/abductor, /obj/structure/table_frame/abductor,
+						/obj/structure/table/abductor, /obj/structure/table/optable/abductor, /obj/structure/closet/abductor, /obj/item/organ/heart/gland,
+						/obj/machinery/abductor, /obj/item/crowbar/abductor, /obj/item/screwdriver/abductor, /obj/item/weldingtool/abductor,
+						/obj/item/wirecutters/abductor, /obj/item/wrench/abductor, /obj/item/stack/sheet/mineral/abductor)),
+
+					"birds" = typecacheof(list(/obj/item/clothing/mask/gas/plaguedoctor, /obj/item/reagent_containers/food/snacks/cracker,
+						/obj/item/clothing/suit/chickensuit, /obj/item/clothing/head/chicken,
+						/obj/item/clothing/suit/toggle/owlwings, /obj/item/clothing/under/owl, /obj/item/clothing/mask/gas/owl_mask,
+						/obj/item/clothing/under/griffin, /obj/item/clothing/shoes/griffin, /obj/item/clothing/head/griffin,
+						/obj/item/clothing/head/helmet/space/freedom, /obj/item/clothing/suit/space/freedom)),
+
+					"anime" = typecacheof(list(/obj/item/clothing/under/schoolgirl, /obj/item/katana, /obj/item/reagent_containers/food/snacks/sashimi, /obj/item/reagent_containers/food/snacks/chawanmushi,
+					   /obj/item/reagent_containers/food/drinks/bottle/sake, /obj/item/throwing_star, /obj/item/clothing/head/kitty/genuine, /obj/item/clothing/suit/space/space_ninja,
+					   /obj/item/clothing/mask/gas/space_ninja, /obj/item/clothing/shoes/space_ninja, /obj/item/clothing/gloves/space_ninja, /obj/item/twohanded/vibro_weapon,
+					   /obj/item/nullrod/scythe/vibro, /obj/item/energy_katana, /obj/item/toy/katana, /obj/item/nullrod/claymore/katana, /obj/structure/window/paperframe, /obj/structure/mineral_door/paperframe)),
+
+					"mimes" = typecacheof(list(/obj/item/pda/mime, /obj/item/clothing/under/rank/mime, /obj/item/clothing/mask/gas/mime,
+						/obj/item/clothing/head/frenchberet, /obj/item/clothing/suit/suspenders, /obj/item/reagent_containers/food/drinks/bottle/bottleofnothing,
+						/obj/item/storage/backpack/mime, /obj/item/reagent_containers/food/snacks/grown/banana/mime,
+						/obj/item/grown/bananapeel/mimanapeel, /obj/item/cartridge/virus/mime, /obj/item/clothing/shoes/sneakers/mime,
+						/obj/item/bedsheet/mime, /obj/item/reagent_containers/food/snacks/burger/mime, /obj/item/clothing/head/beret, /obj/item/clothing/mask/gas/sexymime,
+						/obj/item/clothing/under/sexymime, /obj/item/toy/figure/mime, /obj/item/toy/crayon/mime, /obj/item/mecha_parts/mecha_equipment/weapon/ballistic/silenced, /obj/mecha/combat/reticence)),
+
+					"cats" = typecacheof(list(/obj/item/organ/ears/cat, /obj/item/organ/tail/cat, /obj/item/laser_pointer, /obj/item/toy/cattoy, /obj/item/clothing/head/kitty,
+						/obj/item/clothing/head/collectable/kitty, /obj/item/melee/chainofcommand/tailwhip/kitty, /obj/item/stack/sheet/animalhide/cat)),
+
+					"syndicate" = typecacheof(list(/obj/item/stack/tile/mineral/plastitanium, /obj/machinery/computer/shuttle/syndicate, /obj/machinery/computer/shuttle/syndicate/recall, /obj/machinery/computer/shuttle/syndicate/drop_pod, /obj/machinery/computer/camera_advanced/shuttle_docker/syndicate, /obj/machinery/recharge_station,
+						/obj/machinery/porta_turret/syndicate, /obj/structure/closet/syndicate, /obj/machinery/suit_storage_unit/syndicate, /obj/item/clothing/under/syndicate, /obj/item/folder/syndicate, /obj/item/documents/syndicate, /obj/item/clothing/glasses/phantomthief/syndicate, /obj/item/antag_spawner/nuke_ops, /obj/item/storage/box/syndicate,
+						/obj/structure/fluff/empty_sleeper/syndicate, /obj/item/implant/radio/syndicate, /obj/item/clothing/head/helmet/space/syndicate, /obj/machinery/nuclearbomb/syndicate, /obj/item/grenade/syndieminibomb, /obj/item/storage/backpack/duffelbag/syndie, /obj/item/gun/ballistic/automatic/pistol, /obj/item/gun/ballistic/revolver/syndie,
+						/obj/item/gun/ballistic/automatic/shotgun/bulldog, /obj/item/gun/ballistic/automatic/c20r, /obj/item/gun/ballistic/automatic/m90, /obj/item/gun/ballistic/automatic/l6_saw, /obj/item/storage/belt/grenade/full, /obj/item/gun/ballistic/automatic/sniper_rifle/syndicate, /obj/item/gun/energy/kinetic_accelerator/crossbow,
+						/obj/item/melee/transforming/energy/sword/saber, /obj/item/twohanded/dualsaber, /obj/item/melee/powerfist, /obj/item/storage/box/syndie_kit, /obj/item/grenade/spawnergrenade/manhacks, /obj/item/grenade/chem_grenade/bioterrorfoam, /obj/item/reagent_containers/spray/chemsprayer/bioterror, /obj/item/ammo_box/magazine/m10mm,
+						/obj/item/ammo_box/magazine/pistolm9mm, /obj/item/ammo_box/a357, /obj/item/ammo_box/magazine/m12g, /obj/item/ammo_box/magazine/mm195x129, /obj/item/antag_spawner/nuke_ops, /obj/mecha/combat/gygax/dark, /obj/mecha/combat/marauder/mauler, /obj/item/soap/syndie, /obj/item/gun/syringe/syndicate, /obj/item/cartridge/virus/syndicate,
+						/obj/item/cartridge/virus/frame, /obj/item/chameleon, /obj/item/storage/box/syndie_kit/cutouts, /obj/item/clothing/suit/space/hardsuit/syndi, /obj/item/card/emag, /obj/item/storage/toolbox/syndicate, /obj/item/storage/book/bible/syndicate, /obj/item/encryptionkey/binary, /obj/item/encryptionkey/syndicate, /obj/item/aiModule/syndicate,
+						/obj/item/clothing/shoes/magboots/syndie, /obj/item/powersink, /obj/item/sbeacondrop, /obj/item/sbeacondrop/bomb, /obj/item/syndicatedetonator, /obj/item/shield/energy, /obj/item/assault_pod, /obj/item/slimepotion/slime/sentience/nuclear, /obj/item/stack/telecrystal, /obj/item/jammer, /obj/item/codespeak_manual/unlimited,
+						/obj/item/toy/cards/deck/syndicate, /obj/item/storage/secure/briefcase/syndie, /obj/item/storage/fancy/cigarettes/cigpack_syndicate, /obj/item/toy/syndicateballoon, /obj/item/clothing/gloves/rapid, /obj/item/paper/fluff/ruins/thederelict/syndie_mission, /obj/item/organ/cyberimp/eyes/hud/security/syndicate, /obj/item/clothing/head/HoS/syndicate,
+						/obj/machinery/computer/pod/old/syndicate, /obj/machinery/vending/medical/syndicate_access, /obj/item/mmi/syndie, /obj/item/target/syndicate, /obj/machinery/vending/cigarette/syndicate, /obj/item/robot_module/syndicate, /obj/item/clothing/mask/gas/syndicate, /obj/machinery/power/singularity_beacon/syndicate, /obj/item/clothing/head/syndicatefake,
+						/obj/item/radio/headset/syndicate, /obj/item/gun/ballistic/automatic/pistol/antitank/syndicate, /obj/item/pda/syndicate, /obj/item/clothing/suit/armor/vest/capcarapace/syndicate, /obj/item/gun/ballistic/automatic/flechette, /obj/item/ammo_box/magazine/flechette, /obj/item/clothing/suit/toggle/lawyer/black/syndie, /obj/item/melee/transforming/energy/sword/cx/traitor,
+						/obj/structure/sign/poster/contraband/syndicate_pistol, /obj/structure/sign/poster/contraband/syndicate_recruitment, /obj/item/bedsheet/syndie, /obj/item/borg/upgrade/syndicate, /obj/item/tank/jetpack/oxygen/harness, /obj/item/firing_pin/implant/pindicate, /obj/item/reagent_containers/glass/bottle/traitor, /obj/item/storage/belt/military,
+						/obj/item/twohanded/shockpaddles/syndicate, /obj/item/clothing/mask/cigarette/syndicate, /obj/item/toy/plush/nukeplushie)),
+
+					"eye" = typecacheof(list(/obj/item/organ/eyes, /obj/item/reagent_containers/syringe))
+						)
+
+	phobia_turfs = list("space" = typecacheof(list(/turf/open/space, /turf/open/floor/holofloor/space, /turf/open/floor/fakespace)),
+						"the supernatural" = typecacheof(list(/turf/open/floor/clockwork, /turf/closed/wall/clockwork,
+						/turf/open/floor/plasteel/cult, /turf/closed/wall/mineral/cult)),
+						"aliens" = typecacheof(list(/turf/open/floor/plating/abductor, /turf/open/floor/plating/abductor2,
+						/turf/open/floor/mineral/abductor, /turf/closed/wall/mineral/abductor)),
+						"falling" = typecacheof(list(/turf/open/chasm, /turf/open/floor/fakepit)),
+						"syndicate" = typecacheof(list(/turf/closed/wall/mineral/plastitanium, /turf/open/floor/mineral/plastitanium, /turf/open/floor/plasteel/shuttle/red/syndicate))
+						)
+
+	phobia_species = list("lizards" = typecacheof(list(/datum/species/lizard)),
+						  "skeletons" = typecacheof(list(/datum/species/skeleton, /datum/species/plasmaman)),
+						  "conspiracies" = typecacheof(list(/datum/species/abductor, /datum/species/lizard, /datum/species/synth, /datum/species/corporate)),
+						  "robots" = typecacheof(list(/datum/species/android, /datum/species/synth)),
+						  "the supernatural" = typecacheof(list(/datum/species/golem/clockwork, /datum/species/golem/runic)),
+						  "aliens" = typecacheof(list(/datum/species/abductor, /datum/species/jelly, /datum/species/pod, /datum/species/shadow)),
+						  "anime" = typecacheof(list(/datum/species/human/felinid)),
+						  "cats" = typecacheof(list(/datum/species/human/felinid)),
+						  "syndicate" = typecacheof(list(/datum/species/corporate, /datum/species/zombie/infectious))
+						 )
+
+	return ..()
+
+#undef PHOBIA_FILE

code/controllers/subsystem/vis_overlays.dm

@@ -0,0 +1,75 @@
+SUBSYSTEM_DEF(vis_overlays)
+	name = "Vis contents overlays"
+	wait = 1 MINUTES
+	priority = FIRE_PRIORITY_VIS
+	init_order = INIT_ORDER_VIS
+
+	var/list/vis_overlay_cache
+	var/list/currentrun
+	var/datum/callback/rotate_cb
+
+/datum/controller/subsystem/vis_overlays/Initialize()
+	vis_overlay_cache = list()
+	rotate_cb = CALLBACK(src, .proc/rotate_vis_overlay)
+	return ..()
+
+/datum/controller/subsystem/vis_overlays/fire(resumed = FALSE)
+	if(!resumed)
+		currentrun = vis_overlay_cache.Copy()
+	var/list/current_run = currentrun
+
+	while(current_run.len)
+		var/key = current_run[current_run.len]
+		var/obj/effect/overlay/vis/overlay = current_run[key]
+		current_run.len--
+		if(!overlay.unused && !length(overlay.vis_locs))
+			overlay.unused = world.time
+		else if(overlay.unused && overlay.unused + overlay.cache_expiration < world.time)
+			vis_overlay_cache -= key
+			qdel(overlay)
+		if(MC_TICK_CHECK)
+			return
+
+//the "thing" var can be anything with vis_contents which includes images
+/datum/controller/subsystem/vis_overlays/proc/add_vis_overlay(atom/movable/thing, icon, iconstate, layer, plane, dir, alpha=255)
+	. = "[icon]|[iconstate]|[layer]|[plane]|[dir]|[alpha]"
+	var/obj/effect/overlay/vis/overlay = vis_overlay_cache[.]
+	if(!overlay)
+		overlay = new
+		overlay.icon = icon
+		overlay.icon_state = iconstate
+		overlay.layer = layer
+		overlay.plane = plane
+		overlay.dir = dir
+		overlay.alpha = alpha
+		vis_overlay_cache[.] = overlay
+	else
+		overlay.unused = 0
+	thing.vis_contents += overlay
+
+	if(!isatom(thing)) // Automatic rotation is not supported on non atoms
+		return
+
+	if(!thing.managed_vis_overlays)
+		thing.managed_vis_overlays = list(overlay)
+		RegisterSignal(thing, COMSIG_ATOM_DIR_CHANGE, rotate_cb)
+	else
+		thing.managed_vis_overlays += overlay
+
+/datum/controller/subsystem/vis_overlays/proc/remove_vis_overlay(atom/movable/thing, list/overlays)
+	thing.vis_contents -= overlays
+	if(!isatom(thing))
+		return
+	thing.managed_vis_overlays -= overlays
+	if(!length(thing.managed_vis_overlays))
+		thing.managed_vis_overlays = null
+		UnregisterSignal(thing, COMSIG_ATOM_DIR_CHANGE)
+
+/datum/controller/subsystem/vis_overlays/proc/rotate_vis_overlay(atom/thing, old_dir, new_dir)
+	var/rotation = dir2angle(old_dir) - dir2angle(new_dir)
+	var/list/overlays_to_remove = list()
+	for(var/i in thing.managed_vis_overlays)
+		var/obj/effect/overlay/vis/overlay = i
+		add_vis_overlay(thing, overlay.icon, overlay.icon_state, overlay.layer, overlay.plane, turn(overlay.dir, rotation))
+		overlays_to_remove += overlay
+	remove_vis_overlay(thing, overlays_to_remove)

code/controllers/subsystem/vore.dm

@@ -0,0 +1,41 @@
+#define SSBELLIES_PROCESSED 1
+#define SSBELLIES_IGNORED 2
+
+//
+// Bellies subsystem - Process vore bellies
+//
+
+SUBSYSTEM_DEF(bellies)
+	name = "Bellies"
+	priority = FIRE_PRIORITY_VORE
+	wait = 1 SECONDS
+	flags = SS_KEEP_TIMING|SS_NO_INIT
+	runlevels = RUNLEVEL_GAME|RUNLEVEL_POSTGAME
+
+	var/static/list/belly_list = list()
+	var/list/currentrun = list()
+	var/ignored_bellies = 0
+
+/datum/controller/subsystem/bellies/stat_entry()
+	..("#: [belly_list.len] | P: [ignored_bellies]")
+
+/datum/controller/subsystem/bellies/fire(resumed = 0)
+	if (!resumed)
+		ignored_bellies = 0
+		src.currentrun = belly_list.Copy()
+
+	//cache for sanic speed (lists are references anyways)
+	var/list/currentrun = src.currentrun
+	var/times_fired = src.times_fired
+	while(currentrun.len)
+		var/obj/belly/B = currentrun[currentrun.len]
+		currentrun.len--
+
+		if(QDELETED(B))
+			belly_list -= B
+		else
+			if(B.process_belly(times_fired,wait) == SSBELLIES_IGNORED)
+				ignored_bellies++
+
+		if (MC_TICK_CHECK)
+			return

code/controllers/subsystem/vote.dm

@@ -0,0 +1,372 @@
+SUBSYSTEM_DEF(vote)
+	name = "Vote"
+	wait = 10
+
+	flags = SS_KEEP_TIMING|SS_NO_INIT
+
+	runlevels = RUNLEVEL_LOBBY | RUNLEVELS_DEFAULT
+
+	var/initiator = null
+	var/started_time = null
+	var/time_remaining = 0
+	var/mode = null
+	var/question = null
+	var/list/choices = list()
+	var/list/voted = list()
+	var/list/voting = list()
+	var/list/generated_actions = list()
+
+	var/obfuscated = FALSE//CIT CHANGE - adds obfuscated/admin-only votes
+
+	var/list/stored_gamemode_votes = list() //Basically the last voted gamemode is stored here for end-of-round use.
+
+/datum/controller/subsystem/vote/fire()	//called by master_controller
+	if(mode)
+		time_remaining = round((started_time + CONFIG_GET(number/vote_period) - world.time)/10)
+
+		if(time_remaining < 0)
+			result()
+			for(var/client/C in voting)
+				C << browse(null, "window=vote;can_close=0")
+			reset()
+		else
+			var/datum/browser/client_popup
+			for(var/client/C in voting)
+				client_popup = new(C, "vote", "Voting Panel")
+				client_popup.set_window_options("can_close=0")
+				client_popup.set_content(interface(C))
+				client_popup.open(0)
+
+
+/datum/controller/subsystem/vote/proc/reset()
+	initiator = null
+	time_remaining = 0
+	mode = null
+	question = null
+	choices.Cut()
+	voted.Cut()
+	voting.Cut()
+	obfuscated = FALSE //CIT CHANGE - obfuscated votes
+	remove_action_buttons()
+
+/datum/controller/subsystem/vote/proc/get_result()
+	//get the highest number of votes
+	var/greatest_votes = 0
+	var/total_votes = 0
+	for(var/option in choices)
+		var/votes = choices[option]
+		total_votes += votes
+		if(votes > greatest_votes)
+			greatest_votes = votes
+	//default-vote for everyone who didn't vote
+	if(!CONFIG_GET(flag/default_no_vote) && choices.len)
+		var/list/non_voters = GLOB.directory.Copy()
+		non_voters -= voted
+		for (var/non_voter_ckey in non_voters)
+			var/client/C = non_voters[non_voter_ckey]
+			if (!C || C.is_afk())
+				non_voters -= non_voter_ckey
+		if(non_voters.len > 0)
+			if(mode == "restart")
+				choices["Continue Playing"] += non_voters.len
+				if(choices["Continue Playing"] >= greatest_votes)
+					greatest_votes = choices["Continue Playing"]
+			else if(mode == "gamemode")
+				if(GLOB.master_mode in choices)
+					choices[GLOB.master_mode] += non_voters.len
+					if(choices[GLOB.master_mode] >= greatest_votes)
+						greatest_votes = choices[GLOB.master_mode]
+	//get all options with that many votes and return them in a list
+	. = list()
+	if(greatest_votes)
+		for(var/option in choices)
+			if(choices[option] == greatest_votes)
+				. += option
+	return .
+
+/datum/controller/subsystem/vote/proc/announce_result()
+	var/list/winners = get_result()
+	var/text
+	var/was_roundtype_vote = mode == "roundtype"
+	if(winners.len > 0)
+		if(question)
+			text += "<b>[question]</b>"
+		else
+			text += "<b>[capitalize(mode)] Vote</b>"
+		if(was_roundtype_vote)
+			stored_gamemode_votes = list()
+		for(var/i=1,i<=choices.len,i++)
+			var/votes = choices[choices[i]]
+			if(!votes)
+				votes = 0
+			if(was_roundtype_vote)
+				stored_gamemode_votes[choices[i]] = votes
+			text += "\n<b>[choices[i]]:</b> [obfuscated ? "???" : votes]" //CIT CHANGE - adds obfuscated votes
+		if(mode != "custom")
+			if(winners.len > 1 && !obfuscated) //CIT CHANGE - adds obfuscated votes
+				text = "\n<b>Vote Tied Between:</b>"
+				for(var/option in winners)
+					text += "\n\t[option]"
+			. = pick(winners)
+			text += "\n<b>Vote Result: [obfuscated ? "???" : .]</b>" //CIT CHANGE - adds obfuscated votes
+		else
+			text += "\n<b>Did not vote:</b> [GLOB.clients.len-voted.len]"
+	else
+		text += "<b>Vote Result: Inconclusive - No Votes!</b>"
+	log_vote(text)
+	remove_action_buttons()
+	to_chat(world, "\n<font color='purple'>[text]</font>")
+	if(obfuscated) //CIT CHANGE - adds obfuscated votes. this messages admins with the vote's true results
+		var/admintext = "Obfuscated results"
+		for(var/i=1,i<=choices.len,i++)
+			var/votes = choices[choices[i]]
+			admintext += "\n<b>[choices[i]]:</b> [votes]"
+		message_admins(admintext)
+	return .
+
+/datum/controller/subsystem/vote/proc/result()
+	. = announce_result()
+	var/restart = 0
+	if(.)
+		switch(mode)
+			if("roundtype") //CIT CHANGE - adds the roundstart extended/secret vote
+				if(SSticker.current_state > GAME_STATE_PREGAME)//Don't change the mode if the round already started.
+					return message_admins("A vote has tried to change the gamemode, but the game has already started. Aborting.")
+				GLOB.master_mode = .
+				SSticker.save_mode(.)
+				message_admins("The gamemode has been voted for, and has been changed to: [GLOB.master_mode]")
+				log_admin("Gamemode has been voted for and switched to: [GLOB.master_mode].")
+			if("restart")
+				if(. == "Restart Round")
+					restart = 1
+			if("gamemode")
+				if(GLOB.master_mode != .)
+					SSticker.save_mode(.)
+					if(SSticker.HasRoundStarted())
+						restart = 1
+					else
+						GLOB.master_mode = .
+			if("map")
+				var/datum/map_config/VM = config.maplist[.]
+				message_admins("The map has been voted for and will change to: [VM.map_name]")
+				log_admin("The map has been voted for and will change to: [VM.map_name]")
+				if(SSmapping.changemap(config.maplist[.]))
+					to_chat(world, "<span class='boldannounce'>The map vote has chosen [VM.map_name] for next round!</span>")
+	if(restart)
+		var/active_admins = 0
+		for(var/client/C in GLOB.admins)
+			if(!C.is_afk() && check_rights_for(C, R_SERVER))
+				active_admins = 1
+				break
+		if(!active_admins)
+			SSticker.Reboot("Restart vote successful.", "restart vote")
+		else
+			to_chat(world, "<span style='boldannounce'>Notice:Restart vote will not restart the server automatically because there are active admins on.</span>")
+			message_admins("A restart vote has passed, but there are active admins on with +server, so it has been canceled. If you wish, you may restart the server.")
+
+	return .
+
+/datum/controller/subsystem/vote/proc/submit_vote(vote)
+	if(mode)
+		if(CONFIG_GET(flag/no_dead_vote) && usr.stat == DEAD && !usr.client.holder)
+			return 0
+		if(!(usr.ckey in voted))
+			if(vote && 1<=vote && vote<=choices.len)
+				voted += usr.ckey
+				voted[usr.ckey] = vote
+				choices[choices[vote]]++	//check this
+				return vote
+		else if(vote && 1<=vote && vote<=choices.len)
+			choices[choices[voted[usr.ckey]]]--
+			voted[usr.ckey] = vote
+			choices[choices[vote]]++
+			return vote
+	return 0
+
+/datum/controller/subsystem/vote/proc/initiate_vote(vote_type, initiator_key, hideresults)//CIT CHANGE - adds hideresults argument to votes to allow for obfuscated votes
+	if(!mode)
+		if(started_time)
+			var/next_allowed_time = (started_time + CONFIG_GET(number/vote_delay))
+			if(mode)
+				to_chat(usr, "<span class='warning'>There is already a vote in progress! please wait for it to finish.</span>")
+				return 0
+
+			var/admin = FALSE
+			var/ckey = ckey(initiator_key)
+			if(GLOB.admin_datums[ckey])
+				admin = TRUE
+
+			if(next_allowed_time > world.time && !admin)
+				to_chat(usr, "<span class='warning'>A vote was initiated recently, you must wait [DisplayTimeText(next_allowed_time-world.time)] before a new vote can be started!</span>")
+				return 0
+
+		reset()
+		obfuscated = hideresults //CIT CHANGE - adds obfuscated votes
+		switch(vote_type)
+			if("restart")
+				choices.Add("Restart Round","Continue Playing")
+			if("gamemode")
+				choices.Add(config.votable_modes)
+			if("map")
+				choices.Add(config.maplist)
+				for(var/i in choices)//this is necessary because otherwise we'll end up with a bunch of /datum/map_config's as the default vote value instead of 0 as intended
+					choices[i] = 0
+			if("roundtype") //CIT CHANGE - adds the roundstart secret/extended vote
+				choices.Add("secret", "extended")
+			if("custom")
+				question = stripped_input(usr,"What is the vote for?")
+				if(!question)
+					return 0
+				for(var/i=1,i<=10,i++)
+					var/option = capitalize(stripped_input(usr,"Please enter an option or hit cancel to finish"))
+					if(!option || mode || !usr.client)
+						break
+					choices.Add(option)
+			else
+				return 0
+		mode = vote_type
+		initiator = initiator_key
+		started_time = world.time
+		var/text = "[capitalize(mode)] vote started by [initiator]."
+		if(mode == "custom")
+			text += "\n[question]"
+		log_vote(text)
+		var/vp = CONFIG_GET(number/vote_period)
+		to_chat(world, "\n<font color='purple'><b>[text]</b>\nType <b>vote</b> or click <a href='?src=[REF(src)]'>here</a> to place your votes.\nYou have [DisplayTimeText(vp)] to vote.</font>")
+		time_remaining = round(vp/10)
+		for(var/c in GLOB.clients)
+			SEND_SOUND(c, sound('sound/misc/server-ready.ogg'))
+			var/client/C = c
+			var/datum/action/vote/V = new
+			if(question)
+				V.name = "Vote: [question]"
+			C.player_details.player_actions += V
+			V.Grant(C.mob)
+			generated_actions += V
+		return 1
+	return 0
+
+/datum/controller/subsystem/vote/proc/interface(client/C)
+	if(!C)
+		return
+	var/admin = 0
+	var/trialmin = 0
+	if(C.holder)
+		admin = 1
+		if(check_rights_for(C, R_ADMIN))
+			trialmin = 1
+	voting |= C
+
+	if(mode)
+		if(question)
+			. += "<h2>Vote: '[question]'</h2>"
+		else
+			. += "<h2>Vote: [capitalize(mode)]</h2>"
+		. += "Time Left: [time_remaining] s<hr><ul>"
+		for(var/i=1,i<=choices.len,i++)
+			var/votes = choices[choices[i]]
+			var/ivotedforthis = ((C.ckey in voted) && (voted[C.ckey] == i) ? TRUE : FALSE)
+			if(!votes)
+				votes = 0
+			. += "<li>[ivotedforthis ? "<b>" : ""]<a href='?src=[REF(src)];vote=[i]'>[choices[i]]</a> ([obfuscated ? (admin ? "??? ([votes])" : "???") : votes] votes)[ivotedforthis ? "</b>" : ""]</li>" // CIT CHANGE - adds obfuscated votes
+		. += "</ul><hr>"
+		if(admin)
+			. += "(<a href='?src=[REF(src)];vote=cancel'>Cancel Vote</a>) "
+	else
+		. += "<h2>Start a vote:</h2><hr><ul><li>"
+		//restart
+		var/avr = CONFIG_GET(flag/allow_vote_restart)
+		if(trialmin || avr)
+			. += "<a href='?src=[REF(src)];vote=restart'>Restart</a>"
+		else
+			. += "<font color='grey'>Restart (Disallowed)</font>"
+		if(trialmin)
+			. += "\t(<a href='?src=[REF(src)];vote=toggle_restart'>[avr ? "Allowed" : "Disallowed"]</a>)"
+		. += "</li><li>"
+		//gamemode
+		var/avm = CONFIG_GET(flag/allow_vote_mode)
+		if(trialmin || avm)
+			. += "<a href='?src=[REF(src)];vote=gamemode'>GameMode</a>"
+		else
+			. += "<font color='grey'>GameMode (Disallowed)</font>"
+		if(trialmin)
+			. += "\t(<a href='?src=[REF(src)];vote=toggle_gamemode'>[avm ? "Allowed" : "Disallowed"]</a>)"
+
+		. += "</li>"
+		//custom
+		if(trialmin)
+			. += "<li><a href='?src=[REF(src)];vote=custom'>Custom</a></li>"
+		. += "</ul><hr>"
+	. += "<a href='?src=[REF(src)];vote=close' style='position:absolute;right:50px'>Close</a>"
+	return .
+
+
+/datum/controller/subsystem/vote/Topic(href,href_list[],hsrc)
+	if(!usr || !usr.client)
+		return	//not necessary but meh...just in-case somebody does something stupid
+	switch(href_list["vote"])
+		if("close")
+			voting -= usr.client
+			usr << browse(null, "window=vote")
+			return
+		if("cancel")
+			if(usr.client.holder)
+				reset()
+		if("toggle_restart")
+			if(usr.client.holder)
+				CONFIG_SET(flag/allow_vote_restart, !CONFIG_GET(flag/allow_vote_restart))
+		if("toggle_gamemode")
+			if(usr.client.holder)
+				CONFIG_SET(flag/allow_vote_mode, !CONFIG_GET(flag/allow_vote_mode))
+		if("restart")
+			if(CONFIG_GET(flag/allow_vote_restart) || usr.client.holder)
+				initiate_vote("restart",usr.key)
+		if("gamemode")
+			if(CONFIG_GET(flag/allow_vote_mode) || usr.client.holder)
+				initiate_vote("gamemode",usr.key)
+		if("custom")
+			if(usr.client.holder)
+				initiate_vote("custom",usr.key)
+		else
+			submit_vote(round(text2num(href_list["vote"])))
+	usr.vote()
+
+/datum/controller/subsystem/vote/proc/remove_action_buttons()
+	for(var/v in generated_actions)
+		var/datum/action/vote/V = v
+		if(!QDELETED(V))
+			V.remove_from_client()
+			V.Remove(V.owner)
+	generated_actions = list()
+
+/mob/verb/vote()
+	set category = "OOC"
+	set name = "Vote"
+
+	var/datum/browser/popup = new(src, "vote", "Voting Panel")
+	popup.set_window_options("can_close=0")
+	popup.set_content(SSvote.interface(client))
+	popup.open(0)
+
+/datum/action/vote
+	name = "Vote!"
+	button_icon_state = "vote"
+
+/datum/action/vote/Trigger()
+	if(owner)
+		owner.vote()
+		remove_from_client()
+		Remove(owner)
+
+/datum/action/vote/IsAvailable()
+	return 1
+
+/datum/action/vote/proc/remove_from_client()
+	if(!owner)
+		return
+	if(owner.client)
+		owner.client.player_details.player_actions -= src
+	else if(owner.ckey)
+		var/datum/player_details/P = GLOB.player_details[owner.ckey]
+		if(P)
+			P.player_actions -= src

code/controllers/subsystem/weather.dm

@@ -0,0 +1,83 @@
+#define STARTUP_STAGE 1
+#define MAIN_STAGE 2
+#define WIND_DOWN_STAGE 3
+#define END_STAGE 4
+
+//Used for all kinds of weather, ex. lavaland ash storms.
+SUBSYSTEM_DEF(weather)
+	name = "Weather"
+	flags = SS_BACKGROUND
+	wait = 10
+	runlevels = RUNLEVEL_GAME
+	var/list/processing = list()
+	var/list/eligible_zlevels = list()
+	var/list/next_hit_by_zlevel = list() //Used by barometers to know when the next storm is coming
+
+/datum/controller/subsystem/weather/fire()
+	// process active weather
+	for(var/V in processing)
+		var/datum/weather/W = V
+		if(W.aesthetic || W.stage != MAIN_STAGE)
+			continue
+		for(var/i in GLOB.mob_living_list)
+			var/mob/living/L = i
+			if(W.can_weather_act(L))
+				W.weather_act(L)
+
+	// start random weather on relevant levels
+	for(var/z in eligible_zlevels)
+		var/possible_weather = eligible_zlevels[z]
+		var/datum/weather/W = pickweight(possible_weather)
+		run_weather(W, list(text2num(z)))
+		eligible_zlevels -= z
+		var/randTime = rand(3000, 6000)
+		addtimer(CALLBACK(src, .proc/make_eligible, z, possible_weather), randTime + initial(W.weather_duration_upper), TIMER_UNIQUE) //Around 5-10 minutes between weathers
+		next_hit_by_zlevel["[z]"] = world.time + randTime + initial(W.telegraph_duration)
+
+/datum/controller/subsystem/weather/Initialize(start_timeofday)
+	for(var/V in subtypesof(/datum/weather))
+		var/datum/weather/W = V
+		var/probability = initial(W.probability)
+		var/target_trait = initial(W.target_trait)
+
+		// any weather with a probability set may occur at random
+		if (probability)
+			for(var/z in SSmapping.levels_by_trait(target_trait))
+				LAZYINITLIST(eligible_zlevels["[z]"])
+				eligible_zlevels["[z]"][W] = probability
+	return ..()
+
+/datum/controller/subsystem/weather/proc/run_weather(datum/weather/weather_datum_type, z_levels)
+	if (istext(weather_datum_type))
+		for (var/V in subtypesof(/datum/weather))
+			var/datum/weather/W = V
+			if (initial(W.name) == weather_datum_type)
+				weather_datum_type = V
+				break
+	if (!ispath(weather_datum_type, /datum/weather))
+		CRASH("run_weather called with invalid weather_datum_type: [weather_datum_type || "null"]")
+		return
+
+	if (isnull(z_levels))
+		z_levels = SSmapping.levels_by_trait(initial(weather_datum_type.target_trait))
+	else if (isnum(z_levels))
+		z_levels = list(z_levels)
+	else if (!islist(z_levels))
+		CRASH("run_weather called with invalid z_levels: [z_levels || "null"]")
+		return
+
+	var/datum/weather/W = new weather_datum_type(z_levels)
+	W.telegraph()
+
+/datum/controller/subsystem/weather/proc/make_eligible(z, possible_weather)
+	eligible_zlevels[z] = possible_weather
+	next_hit_by_zlevel["[z]"] = null
+
+/datum/controller/subsystem/weather/proc/get_weather(z, area/active_area)
+    var/datum/weather/A
+    for(var/V in processing)
+        var/datum/weather/W = V
+        if((z in W.impacted_z_levels) && W.area_type == active_area.type)
+            A = W
+            break
+    return A