Merge remote-tracking branch 'upstream/master' into more_ss_ports

# Conflicts:
#	paradise.dme

code/controllers/Processes/nano_mob_hunter.dm

@@ -44,7 +44,7 @@ DECLARE_GLOBAL_CONTROLLER(mob_hunt, mob_hunt_server)
 		recover_time = 3000
 	if(recover_time > 0)	//when provided with a negative or zero valued recover_time argument, the server won't auto-restart but can be manually rebooted still
 		//set a timer to automatically recover after recover_time has passed (can be manually restarted if you get impatient too)
-		addtimer(src, "auto_recover", recover_time, TRUE)
+		addtimer(CALLBACK(src, .proc/auto_recover), recover_time, TIMER_UNIQUE)
 
 /datum/controller/process/mob_hunt/proc/client_mob_update()
 	var/list/ex_players = list()

code/controllers/Processes/timer.dm

@@ -1,100 +0,0 @@
-var/global/datum/controller/process/timer/timer_master
-
-/datum/controller/process/timer
-	var/list/processing_timers = list()
-	var/list/hashes = list()
-
-/datum/controller/process/timer/setup()
-	name = "timer"
-	schedule_interval = 1 //every 0.1 seconds--2 server ticks
-	log_startup_progress("Timer process starting up.")
-
-/datum/controller/process/timer/statProcess()
-	..()
-	stat(null, "[processing_timers.len] timers")
-
-/datum/controller/process/timer/doWork()
-	if(!processing_timers.len)
-		disabled = 1 //nothing to do, lets stop firing.
-		return
-	for(last_object in processing_timers)
-		var/datum/timedevent/event = last_object
-		if(!event.thingToCall || check_datum_qdeleted(event.thingToCall))
-			qdel(event)
-		if(event.timeToRun <= world.time)
-			runevent(event)
-			qdel(event)
-		SCHECK
-
-DECLARE_GLOBAL_CONTROLLER(timer, timer_master)
-
-/datum/controller/process/timer/proc/runevent(datum/timedevent/event)
-	set waitfor = 0
-	if(event.thingToCall)
-		if(event.thingToCall == GLOBAL_PROC && istext(event.procToCall))
-			call("/proc/[event.procToCall]")(arglist(event.argList))
-		else
-			call(event.thingToCall, event.procToCall)(arglist(event.argList))
-
-/datum/timedevent
-	var/thingToCall
-	var/procToCall
-	var/timeToRun
-	var/argList
-	var/id
-	var/hash
-	var/static/nextid = 1
-
-/datum/timedevent/New()
-	id = nextid++
-
-/datum/timedevent/Destroy()
-	timer_master.processing_timers -= src
-	timer_master.hashes -= hash
-	return QDEL_HINT_IWILLGC
-
-/proc/addtimer(thingToCall, procToCall, wait, unique = FALSE, ...)
-	if(!timer_master) //can't run timers before the mc has been created
-		return
-	if(!thingToCall || !procToCall)
-		return
-	if(timer_master.disabled)
-		timer_master.disabled = 0
-
-	var/datum/timedevent/event = new()
-	event.thingToCall = thingToCall
-	event.procToCall = procToCall
-	event.timeToRun = world.time + wait
-	var/hashlist = args.Copy()
-
-	hashlist[1] = "[thingToCall](\ref[thingToCall])"
-	event.hash = jointext(hashlist, null)
-	if(args.len > 4)
-		event.argList = args.Copy(5)
-
-	// Check for dupes if unique = 1.
-	if(unique)
-		var/datum/timedevent/hash_event = timer_master.hashes[event.hash]
-		if(hash_event)
-			return hash_event.id
-	timer_master.hashes[event.hash] = event
-	if(wait <= 0)
-		timer_master.runevent(event)
-		timer_master.hashes -= event.hash
-		return
-	// If we are unique (or we're not checking that), add the timer and return the id.
-	timer_master.processing_timers += event
-
-	return event.id
-
-/proc/deltimer(id)
-	if(id == 0)
-		// No event will correspond to an id of 0 - the timer does not exist
-		// Save us a possibly expensive iteration through the timer list
-		// This would probably be more efficient in general if we used an associative list instead
-		return 0
-	for(var/datum/timedevent/event in timer_master.processing_timers)
-		if(event.id == id)
-			qdel(event)
-			return 1
-	return 0

code/controllers/Processes/weather.dm

@@ -37,7 +37,7 @@ var/global/datum/controller/process/weather/weather_master
 		var/datum/weather/W = pickweight(possible_weather_for_this_z)
 		run_weather(W.name)
 		eligible_zlevels -= Z
-		addtimer(src, "make_z_eligible", rand(3000, 6000) + W.weather_duration_upper, TRUE, Z) //Around 5-10 minutes between weathers
+		addtimer(CALLBACK(src, .proc/make_z_eligible, Z), rand(3000, 6000) + W.weather_duration_upper, TIMER_UNIQUE) //Around 5-10 minutes between weathers
 
 DECLARE_GLOBAL_CONTROLLER(weather, weather_master)
 

code/controllers/configuration.dm

@@ -202,6 +202,9 @@
 	var/randomize_shift_time = FALSE
 	var/enable_night_shifts = FALSE
 
+	// Developer
+	var/developer_express_start = 0
+
 /datum/configuration/New()
 	for(var/T in subtypesof(/datum/game_mode))
 		var/datum/game_mode/M = T
@@ -612,6 +615,8 @@
 					config.high_pop_mc_mode_amount = text2num(value)
 				if("disable_high_pop_mc_mode_amount")
 					config.disable_high_pop_mc_mode_amount = text2num(value)
+				if("developer_express_start")
+					config.developer_express_start = 1
 				else
 					log_config("Unknown setting in configuration: '[name]'")
 

code/controllers/master.dm

@@ -54,7 +54,7 @@ GLOBAL_REAL(Master, /datum/controller/master) = new
 	var/static/restart_clear = 0
 	var/static/restart_timeout = 0
 	var/static/restart_count = 0
-	
+
 	var/static/random_seed
 
 	//current tick limit, assigned before running a subsystem.
@@ -70,7 +70,7 @@ GLOBAL_REAL(Master, /datum/controller/master) = new
 	if(!random_seed)
 		random_seed = rand(1, 1e9)
 		rand_seed(random_seed)
-	
+
 	var/list/_subsystems = list()
 	subsystems = _subsystems
 	if(Master != src)
@@ -194,6 +194,9 @@ GLOBAL_REAL(Master, /datum/controller/master) = new
 	to_chat(world, "<span class='boldannounce'>[msg]</span>")
 	log_world(msg)
 
+	if(config.developer_express_start & ticker.current_state == GAME_STATE_PREGAME)
+		ticker.current_state = GAME_STATE_SETTING_UP
+
 	if(!current_runlevel)
 		SetRunLevel(1)
 

code/controllers/subsystem/timer.dm

@@ -0,0 +1,518 @@
+#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) + 1)
+#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/second_queue = list() //awe, yes, you've had first queue, but what about second queue? Contains: /datum/timedevent
+	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()
+		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/spent_timer in spent)
+		qdel(spent_timer)
+
+	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[1]
+		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/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, timeToRun, flags, hash)
+	var/static/nextid = 1
+	id = TIMER_ID_NULL
+	src.callBack = callBack
+	src.timeToRun = timeToRun
+	src.flags = flags
+	src.hash = hash
+
+	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")), ", ")], 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)
+		LAZYADD(callBack.object.active_timers, src)
+
+
+	var/list/L
+
+	if(flags & TIMER_CLIENT_TIME)
+		L = SStimer.clienttime_timers
+	else if(timeToRun >= TIMER_MAX)
+		L = SStimer.second_queue
+
+
+	if(L)
+		//binary search sorted insert
+		var/cttl = length(L)
+		if(cttl)
+			var/left = 1
+			var/right = cttl
+			var/mid = (left+right) >> 1 //rounded divide by two for hedgehogs
+
+			var/datum/timedevent/item
+			while(left < right)
+				item = L[mid]
+				if(item.timeToRun <= timeToRun)
+					left = mid+1
+				else
+					right = mid
+				mid = (left+right) >> 1
+
+			item = L[mid]
+			mid = item.timeToRun > timeToRun ? mid : mid+1
+			L.Insert(mid, src)
+
+		else
+			L += src
+		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/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
+		var/bucketpos = BUCKET_POS(src)
+		var/datum/timedevent/buckethead
+		var/list/bucket_list = SStimer.bucket_list
+		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(SStimer.second_queue)
+			SStimer.second_queue -= src
+			if(l == length(SStimer.second_queue))
+				SStimer.bucket_count--
+
+		if(prev == next && next)
+			next.prev = null
+			prev.next = null
+		else
+			if(prev)
+				prev.next = next
+			if(next)
+				next.prev = prev
+	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/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 0")
+
+	//alot of things add short timers on themselves in their destroy, we ignore those cases
+	if(wait >= 1 && callback && callback.object && callback.object != GLOBAL_PROC && QDELETED(callback.object))
+		stack_trace("addtimer called with a callback assigned to a qdeleted object")
+
+	wait = max(wait, 0)
+
+	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, "([callback.object.UID()])", callback.delegate, flags & TIMER_CLIENT_TIME)
+		else
+			hashlist = list(callback.object, "([callback.object.UID()])", 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
+
+
+	var/timeToRun = world.time + wait
+	if(flags & TIMER_CLIENT_TIME)
+		timeToRun = REALTIMEOFDAY + wait
+
+	var/datum/timedevent/timer = new(callback, timeToRun, 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/verbs.dm

@@ -91,7 +91,7 @@
 			debug_variables(shuttle_master)
 			feedback_add_details("admin_verb","DShuttle")
 		if("Timer")
-			debug_variables(timer_master)
+			debug_variables(SStimer)
 			feedback_add_details("admin_verb","DTimer")
 		if("Weather")
 			debug_variables(weather_master)