Merge branch 'master' of https://github.com/Citadel-Station-13/Citadel-Station-13 into upstream-merge-27840

code/controllers/subsystem/explosion.dm

@@ -0,0 +1,510 @@
+SUBSYSTEM_DEF(explosion)
+	priority = 99
+	wait = 1
+	flags = SS_TICKER|SS_NO_INIT
+
+	var/list/explosions
+
+	var/rebuild_tick_split_count = FALSE
+	var/tick_portions_required = 0
+
+	var/list/logs
+
+	var/list/zlevels_that_ignore_bombcap
+	var/list/doppler_arrays
+
+	//legacy caps, set by config
+	var/devastation_cap = 3
+	var/heavy_cap = 7
+	var/light_cap = 14
+	var/flash_cap = 14
+	var/flame_cap = 14
+	var/dyn_ex_scale = 0.5
+
+	var/id_counter = 0
+
+/datum/controller/subsystem/explosion/PreInit()
+	doppler_arrays = list()
+	logs = list()
+	explosions = list()
+	zlevels_that_ignore_bombcap = list("[ZLEVEL_MINING]")
+
+/datum/controller/subsystem/explosion/Shutdown()
+	QDEL_LIST(explosions)
+	QDEL_LIST(logs)
+	zlevels_that_ignore_bombcap.Cut()
+
+/datum/controller/subsystem/explosion/Recover()
+	explosions = SSexplosion.explosions
+	logs = SSexplosion.logs
+	id_counter = SSexplosion.id_counter
+	rebuild_tick_split_count = TRUE
+	zlevels_that_ignore_bombcap = SSexplosion.zlevels_that_ignore_bombcap
+	doppler_arrays = SSexplosion.doppler_arrays
+
+	devastation_cap = SSexplosion.devastation_cap
+	heavy_cap = SSexplosion.heavy_cap
+	light_cap = SSexplosion.light_cap
+	flash_cap = SSexplosion.flash_cap
+	flame_cap = SSexplosion.flame_cap
+	dyn_ex_scale = SSexplosion.dyn_ex_scale
+
+/datum/controller/subsystem/explosion/fire()    
+	var/list/cached_explosions = explosions
+	var/num_explosions = cached_explosions.len
+	if(!num_explosions)
+		return
+	
+	//figure exactly how many tick splits are required
+	var/num_splits
+	if(rebuild_tick_split_count)
+		var/reactionary = config.reactionary_explosions
+		num_splits = num_explosions
+		for(var/I in cached_explosions)
+			var/datum/explosion/E = I
+			if(!E.turfs_processed)
+				++num_splits
+			if(reactionary && !E.densities_processed)
+				++num_splits
+		tick_portions_required = num_splits
+	else
+		num_splits = tick_portions_required
+
+	MC_SPLIT_TICK_INIT(num_splits)
+
+	for(var/I in cached_explosions)
+		var/datum/explosion/E = I
+
+		var/etp = E.turfs_processed
+		if(!etp)
+			if(GatherTurfs(E))
+				--tick_portions_required
+				etp = TRUE
+			MC_SPLIT_TICK
+
+		var/edp = E.densities_processed
+		if(!edp)
+			if(DensityCalculate(E, etp))
+				--tick_portions_required
+				edp = TRUE
+			MC_SPLIT_TICK
+
+		if(ProcessExplosion(E, edp)) //splits the tick
+			--tick_portions_required
+			explosions -= E
+			logs += E
+			NotifyDopplers(E)
+		MC_SPLIT_TICK
+
+/datum/controller/subsystem/explosion/proc/NotifyDopplers(datum/explosion/E)
+	for(var/array in doppler_arrays)
+		var/obj/machinery/doppler_array/A = array
+		A.sense_explosion(E.epicenter, E.devastation, E.heavy, E.light, E.finished_at - E.started_at, E.orig_dev_range, E.orig_heavy_range, E.orig_light_range)
+
+/datum/controller/subsystem/explosion/proc/Create(atom/epicenter, devastation_range, heavy_impact_range, light_impact_range, flash_range, adminlog = TRUE, ignorecap = FALSE, flame_range = 0 , silent = FALSE, smoke = FALSE)
+	epicenter = get_turf(epicenter)
+	if(!epicenter)
+		return
+
+	if(adminlog)
+		message_admins("Explosion with size ([devastation_range], [heavy_impact_range], [light_impact_range], [flame_range]) in area: [get_area(epicenter)] [ADMIN_COORDJMP(epicenter)]")
+		log_game("Explosion with size ([devastation_range], [heavy_impact_range], [light_impact_range], [flame_range]) in area [epicenter.loc.name] ([epicenter.x],[epicenter.y],[epicenter.z])")
+
+	var/datum/explosion/E = new(++id_counter, epicenter, devastation_range, heavy_impact_range, light_impact_range, flash_range, flame_range, silent, smoke, ignorecap)
+
+	if(heavy_impact_range > 1)
+		var/datum/effect_system/explosion/Eff
+		if(smoke)
+			Eff = new /datum/effect_system/explosion/smoke
+		else
+			Eff = new
+		Eff.set_up(epicenter)
+		Eff.start()
+
+	//flash mobs
+	if(flash_range)
+		for(var/mob/living/L in viewers(flash_range, epicenter))
+			L.flash_act()
+
+	if(!silent)
+		ExplosionSound(epicenter, devastation_range, heavy_impact_range, E.extent)
+
+	//add to SS
+	if(E.extent)
+		tick_portions_required += 2 + (config.reactionary_explosions ? 1 : 0)
+		explosions += E
+	else
+		logs += E	//Already done processing
+
+/datum/controller/subsystem/explosion/proc/CreateDynamic(atom/epicenter, power, flash_range, adminlog = TRUE, ignorecap = TRUE, flame_range = 0 , silent = FALSE, smoke = TRUE)
+	if(!power)
+		return
+	var/range = round((2 * power) ** dyn_ex_scale)
+	Create(epicenter, round(range * 0.25), round(range * 0.5), round(range), flash_range*range, adminlog, ignorecap, flame_range*range, silent, smoke)
+
+// Using default dyn_ex scale:
+// 100 explosion power is a (5, 10, 20) explosion.
+// 75 explosion power is a (4, 8, 17) explosion.
+// 50 explosion power is a (3, 7, 14) explosion.
+// 25 explosion power is a (2, 5, 10) explosion.
+// 10 explosion power is a (1, 3, 6) explosion.
+// 5 explosion power is a (0, 1, 3) explosion.
+// 1 explosion power is a (0, 0, 1) explosion.
+
+/datum/explosion
+	var/explosion_id
+	var/turf/epicenter
+
+	var/started_at
+	var/finished_at
+	var/tick_started
+	var/tick_finished
+
+	var/turfs_processed = FALSE
+	var/densities_processed = FALSE
+
+	var/orig_dev_range
+	var/orig_heavy_range
+	var/orig_light_range
+	var/orig_flash_range
+	var/orig_flame_range
+
+	var/devastation
+	var/heavy
+	var/light
+	var/extent
+
+	var/flash
+	var/flame
+
+	var/gather_dist = 0
+
+	var/list/gathered_turfs
+	var/list/calculated_turfs
+
+	var/list/unsafe_turfs
+
+/datum/explosion/New(id, turf/epi, devastation_range, heavy_impact_range, light_impact_range, flash_range, flame_range, silent, smoke, ignorecap)
+	explosion_id = id
+	epicenter = epi
+
+	densities_processed = !config.reactionary_explosions
+
+	orig_dev_range = devastation_range
+	orig_heavy_range = heavy_impact_range
+	orig_light_range = light_impact_range
+	orig_flash_range = flash_range
+	orig_flame_range = flame_range
+
+	if(!ignorecap && !("[epicenter.z]" in SSexplosion.zlevels_that_ignore_bombcap))
+		//Clamp all values
+		devastation_range = min(SSexplosion.devastation_cap, devastation_range)
+		heavy_impact_range = min(SSexplosion.heavy_cap, heavy_impact_range)
+		light_impact_range = min(SSexplosion.light_cap, light_impact_range)
+		flash_range = min(SSexplosion.flash_cap, flash_range)
+		flame_range = min(SSexplosion.flame_cap, flame_range)
+
+	//store this
+	devastation = devastation_range
+	heavy = heavy_impact_range
+	light = light_impact_range
+
+	extent = max(devastation_range, heavy_impact_range, light_impact_range, flame_range)
+
+	flash = flash_range
+	flame = flame_range
+
+	started_at = REALTIMEOFDAY
+	tick_started = world.time
+	
+	gathered_turfs = list()
+	calculated_turfs = list()
+	unsafe_turfs = list()
+
+// Play sounds; we want sounds to be different depending on distance so we will manually do it ourselves.
+// Stereo users will also hear the direction of the explosion!
+
+// Calculate far explosion sound range. Only allow the sound effect for heavy/devastating explosions.
+// 3/7/14 will calculate to 80 + 35
+/proc/ExplosionSound(turf/epicenter, devastation_range, heavy_impact_range, extent)
+	var/far_dist = 0
+	far_dist += heavy_impact_range * 5
+	far_dist += devastation_range * 20
+
+	var/z0 = epicenter.z
+
+	var/frequency = get_rand_frequency()
+	var/ex_sound = get_sfx("explosion")
+	for(var/mob/M in GLOB.player_list)
+		// Double check for client
+		var/turf/M_turf = get_turf(M)
+		if(M_turf && M_turf.z == z0)
+			var/dist = get_dist(M_turf, epicenter)
+			// If inside the blast radius + world.view - 2
+			if(dist <= round(extent + world.view - 2, 1))
+				M.playsound_local(epicenter, ex_sound, 100, 1, frequency, falloff = 5)
+			// You hear a far explosion if you're outside the blast radius. Small bombs shouldn't be heard all over the station.
+			else if(dist <= far_dist)
+				var/far_volume = Clamp(far_dist, 30, 50) // Volume is based on explosion size and dist
+				far_volume += (dist <= far_dist * 0.5 ? 50 : 0) // add 50 volume if the mob is pretty close to the explosion
+				M.playsound_local(epicenter, 'sound/effects/explosionfar.ogg', far_volume, 1, frequency, falloff = 5)
+
+/datum/explosion/Destroy()
+	SSexplosion.explosions -= src
+	SSexplosion.logs -= src
+	LAZYCLEARLIST(gathered_turfs)
+	LAZYCLEARLIST(calculated_turfs)
+	LAZYCLEARLIST(unsafe_turfs)
+	return ..()
+
+/datum/controller/subsystem/explosion/proc/GatherTurfs(datum/explosion/E)
+	var/turf/epicenter = E.epicenter
+
+	var/x0 = epicenter.x
+	var/y0 = epicenter.y
+	var/z0 = epicenter.z
+
+	var/c_dist = E.gather_dist
+	var/dist = E.extent
+
+	var/list/L = E.gathered_turfs
+
+	if(!c_dist)
+		L += epicenter
+		++c_dist
+
+	while( c_dist <= dist )
+		var/y = y0 + c_dist
+		var/x = x0 - c_dist + 1
+		for(x in x to x0 + c_dist)
+			var/turf/T = locate(x, y, z0)
+			if(T)
+				L += T
+
+		y = y0 + c_dist - 1
+		x = x0 + c_dist
+		for(y in y0 - c_dist to y)
+			var/turf/T = locate(x, y, z0)
+			if(T)
+				L += T
+
+		y = y0 - c_dist
+		x = x0 + c_dist - 1
+		for(x in x0 - c_dist to x)
+			var/turf/T = locate(x, y, z0)
+			if(T)
+				L += T
+
+		y = y0 - c_dist + 1
+		x = x0 - c_dist
+		for(y in y to y0 + c_dist)
+			var/turf/T = locate(x, y, z0)
+			if(T)
+				L += T
+		++c_dist
+
+		if(MC_TICK_CHECK)
+			break
+
+	if(c_dist > dist)
+		E.turfs_processed = TRUE
+		return TRUE
+	else
+		E.gather_dist = c_dist
+		return FALSE
+
+/datum/controller/subsystem/explosion/proc/DensityCalculate(datum/explosion/E, done_gathering_turfs)
+	var/list/L = E.calculated_turfs
+	var/cut_to = 1
+	for(var/I in E.gathered_turfs) // we cache the explosion block rating of every turf in the explosion area
+		var/turf/T = I
+		++cut_to
+
+		var/current_exp_block = T.density ? T.explosion_block : 0
+
+		for(var/obj/machinery/door/D in T)
+			if(D.density)
+				current_exp_block += D.explosion_block
+
+		for(var/obj/structure/window/W in T)
+			if(W.reinf && W.fulltile)
+				current_exp_block += W.explosion_block
+
+		for(var/obj/structure/blob/B in T)
+			current_exp_block += B.explosion_block
+		
+		L[T] = current_exp_block
+
+		if(MC_TICK_CHECK)
+			E.gathered_turfs.Cut(1, cut_to)
+			return FALSE
+	
+	E.gathered_turfs.Cut()
+	return done_gathering_turfs
+
+/datum/controller/subsystem/explosion/proc/ProcessExplosion(datum/explosion/E, done_calculating_turfs)
+	//cache shit for speed
+	var/id = E.explosion_id
+
+	var/list/cached_unsafe = E.unsafe_turfs
+	var/list/cached_exp_block = E.calculated_turfs
+	var/list/affected_turfs = cached_exp_block ? cached_exp_block : E.gathered_turfs
+
+	var/devastation_range = E.devastation
+	var/heavy_impact_range = E.heavy
+	var/light_impact_range = E.light
+
+	var/flame_range = E.flame
+	var/throw_range_max = E.extent
+
+	var/turf/epi = E.epicenter
+	
+	var/x0 = epi.x
+	var/y0 = epi.y
+
+	var/cut_to = 1
+	for(var/TI in affected_turfs)
+		var/turf/T = TI
+		++cut_to
+
+		var/init_dist = cheap_hypotenuse(T.x, T.y, x0, y0)
+		var/dist = init_dist
+
+		if(cached_exp_block)
+			var/turf/Trajectory = T
+			while(Trajectory != epi)
+				Trajectory = get_step_towards(Trajectory, epi)
+				dist += cached_exp_block[Trajectory]
+
+		var/flame_dist = dist < flame_range
+		var/throw_dist = dist
+
+		if(dist < devastation_range)
+			dist = 1
+		else if(dist < heavy_impact_range)
+			dist = 2
+		else if(dist < light_impact_range)
+			dist = 3
+		else
+			dist = 0
+
+		//------- EX_ACT AND TURF FIRES -------
+
+		if(flame_dist && prob(40) && !isspaceturf(T) && !T.density)
+			new /obj/effect/hotspot(T) //Mostly for ambience!
+
+		if(dist > 0)
+			T.explosion_level = max(T.explosion_level, dist)	//let the bigger one have it
+			T.explosion_id = id
+			T.ex_act(dist)
+			cached_unsafe += T
+
+		//--- THROW ITEMS AROUND ---
+
+		var/throw_dir = get_dir(epi, T)
+		for(var/obj/item/I in T)
+			if(!I.anchored)
+				var/throw_range = rand(throw_dist, throw_range_max)
+				var/turf/throw_at = get_ranged_target_turf(I, throw_dir, throw_range)
+				I.throw_speed = 4 //Temporarily change their throw_speed for embedding purposes (Resets when it finishes throwing, regardless of hitting anything)
+				I.throw_at(throw_at, throw_range, 4)		
+
+		if(MC_TICK_CHECK)
+			var/circumference = (PI * (init_dist + 4) * 2) //+4 to radius to prevent shit gaps
+			if(cached_unsafe.len > circumference)	//only do this every revolution
+				for(var/Unexplode in cached_unsafe)
+					var/turf/UnexplodeT = Unexplode
+					UnexplodeT.explosion_level = 0
+				cached_unsafe.Cut()
+			done_calculating_turfs = FALSE
+			break
+
+	affected_turfs.Cut(1, cut_to)
+
+	if(!done_calculating_turfs)
+		return FALSE
+
+	//unfuck the shit
+	for(var/Unexplode in cached_unsafe)
+		var/turf/UnexplodeT = Unexplode
+		UnexplodeT.explosion_level = 0
+	cached_unsafe.Cut()
+
+	E.finished_at = REALTIMEOFDAY
+	E.tick_finished = world.time
+	
+	return TRUE
+
+/client/proc/check_bomb_impacts()
+	set name = "Check Bomb Impact"
+	set category = "Debug"
+
+	var/newmode = alert("Use reactionary explosions?","Check Bomb Impact", "Yes", "No")
+	var/turf/epicenter = get_turf(mob)
+	if(!epicenter)
+		return
+
+	var/x0 = epicenter.x
+	var/y0 = epicenter.y
+
+	var/dev = 0
+	var/heavy = 0
+	var/light = 0
+	var/list/choices = list("Small Bomb","Medium Bomb","Big Bomb","Custom Bomb")
+	var/choice = input("Bomb Size?") in choices
+	switch(choice)
+		if(null)
+			return 0
+		if("Small Bomb")
+			dev = 1
+			heavy = 2
+			light = 3
+		if("Medium Bomb")
+			dev = 2
+			heavy = 3
+			light = 4
+		if("Big Bomb")
+			dev = 3
+			heavy = 5
+			light = 7
+		if("Custom Bomb")
+			dev = input("Devestation range (Tiles):") as num
+			heavy = input("Heavy impact range (Tiles):") as num
+			light = input("Light impact range (Tiles):") as num
+		else
+			return
+
+	var/datum/explosion/E = new(null, epicenter, dev, heavy, light, ignorecap = TRUE)
+
+	while(!SSexplosion.GatherTurfs(E))
+		stoplag()
+	var/list/turfs
+	if(newmode)
+		while(!SSexplosion.DensityCalculate(E, TRUE))
+			stoplag()
+		turfs = E.calculated_turfs.Copy()
+	else
+		turfs = E.gathered_turfs.Copy()
+
+	qdel(E)
+
+	for(var/I in turfs)
+		var/turf/T = I
+		var/dist = cheap_hypotenuse(T.x, T.y, x0, y0) + turfs[T]
+
+		if(dist < dev)
+			T.color = "red"
+			T.maptext = "Dev"
+		else if (dist < heavy)
+			T.color = "yellow"
+			T.maptext = "Heavy"
+		else if (dist < light)
+			T.color = "blue"
+			T.maptext = "Light"
+		CHECK_TICK
+
+	sleep(100)
+	for(var/I in turfs)
+		var/turf/T = I
+		T.color = null
+		T.maptext = null

code/controllers/subsystem/machines.dm

@@ -37,11 +37,11 @@ SUBSYSTEM_DEF(machines)
 
 	var/seconds = wait * 0.1
 	while(currentrun.len)
-		var/datum/thing = currentrun[currentrun.len]
+		var/obj/machinery/thing = currentrun[currentrun.len]
 		currentrun.len--
 		if(thing && thing.process(seconds) != PROCESS_KILL)
-			if(thing:use_power)
-				thing:auto_use_power() //add back the power state
+			if(thing.use_power)
+				thing.auto_use_power() //add back the power state
 		else
 			processing -= thing
 			if (thing)

code/controllers/subsystem/mapping.dm

@@ -119,7 +119,9 @@ SUBSYSTEM_DEF(mapping)
 	INIT_ANNOUNCE("Loading [config.map_name]...")
 	TryLoadZ(config.GetFullMapPath(), FailedZs, ZLEVEL_STATION)
 	INIT_ANNOUNCE("Loaded station in [(REALTIMEOFDAY - start_time)/10]s!")
-	SSblackbox.add_details("map_name", config.map_name)
+	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()
 
 	if(config.minetype != "lavaland")
 		INIT_ANNOUNCE("WARNING: A map without lavaland set as it's minetype was loaded! This is being ignored! Update the maploader code!")

code/controllers/subsystem/shuttle.dm

@@ -25,6 +25,7 @@ SUBSYSTEM_DEF(shuttle)
 	var/area/emergencyLastCallLoc
 	var/emergencyCallAmount = 0		//how many times the escape shuttle was called
 	var/emergencyNoEscape
+	var/emergencyNoRecall = FALSE
 	var/list/hostileEnvironments = list()
 
 		//supply shuttle stuff