Radiation Rework (ParadiseSS13#28320)

* initial changes

* Rad wave is working. now to implement the rest

* Makes the waves square

* Makes wave square

* multiplies the strength in all instances of radiation_pulse by 4 because each pulse makes one wave instead of 4 now

* Undef thing and apply suggestion

* Make radiation_pulse() not radiate the radiation source and implements contamination

* Adds contamination to uranium walls and meteors

* Fixes stuff

* Handle some contamination on attack still need to take care of meteors

* Fixed the meteor stuff

* Introduce emission types

* moves contaminate_touch to an atom proc and renames it to contaminate_atom

* deduplicates some contamination code

* Move inherent radioactivity to a component and signals from the atom vars and behaviour

* fix some things with the new component

* Update inherent_radioactivity.dm

* implement contaminating things that hit things that are inherently radioactive

* window things

* adds emission type to the rad_act call

* Changes radiation insulation values on a bunch of stuff

* fixes radioactive component radiating the wrong type

* more adjustments

* refactros rad_act

* adjustments to collector power production

* Adds plastitaniumglass windows and makes further adjustments

* Adds sprites to the shards and plastitanium directional window

* Update misc_cleanables.dm

* removes alpha rad insulation from floor turfs

* Fixes a bug with the starting tile of radiation waves

* More adjustments

* Adjusting singularity rad production

* reduces window half life a bit to make power smoother and buffs full window rad conversion

* Strengthens gamma and beta radiation effect on mobs.

* Makes radsuit block radiation completely

* Fixes Geiger Counters

* Fixes contamination not irradiating the contaminated thing

* Fixes inherent radioactivity not processing. Also makes it stop processing when a nuke core is contained

* Fixes ghost contamination

* Adds info to the collector

* Handles alpha radiation better on humans and changes some instances of rad_act to base_rad_act

* oops

* adjustments and fixes to alpha rad handling on mobs

* Make collector info more compact

* Core no longer radiates and contaminates from within the nuke until the plates are removed

* Contamination no longer counts as being inside a mob(it is supposed to be surface level)

* Adds inherent radioactivity to a bunch of uranium things. makes it all process.

* Nerf full windows

* Adjustments to collector and fulltile window radiation absorption

* Reduces passive contamination, especially while on the floor

* Adds different rad types to the geiger counter and fixes a runtime

* Makes full tile windows strong again and disallows building them on top of collectors

* adds emissive blockers to the rad blacklist and gives windows and collectors priority when irradiating for increased consistency

* Gives each contamination type it's own color.

* Gives each contamination type it's own color.  And makes the rad hud display them separately

* Changes how much the radiation wave affects the source tile, adds decay for performance reasons and adjusts collector parameters as well as SM and singulo rad production

* improves performance at very high rad amounts

* Fixes supermatter sliver box not containing radiation

* Restores supermatter sliver to old behaviour(not inherently radioactive)

* Slight nerf to fulltile windows and removes an unnecessary multiplication from rad wave processing

* Removes redundant line from window rad act

* Fixes radiation waves ignoring walls

* fixes it better

* more adjustments to collector stats

* Adjustment to collector gamma absorption

* increases grille beta blocking

* Review changes

Author: Migratingcocofruit

code/__DEFINES/dcs/atom_signals.dm

@@ -61,8 +61,10 @@
 #define COMSIG_ATOM_ACID_ACT "atom_acid_act"
 ///from base of atom/emag_act(): (/mob/user)
 #define COMSIG_ATOM_EMAG_ACT "atom_emag_act"
-///from base of atom/rad_act(intensity)
+///from base of atom/rad_act(intensity, emission_type)
 #define COMSIG_ATOM_RAD_ACT "atom_rad_act"
+///from base of turf/irradiate(/datum/radiation_wave)
+#define COMSIG_TURF_IRRADIATE
 ///from base of atom/singularity_pull(): (S, current_size)
 #define COMSIG_ATOM_SING_PULL "atom_sing_pull"
 ///from base of atom/set_light(): (l_range, l_power, l_color)

code/__DEFINES/radiation_defines.dm

@@ -38,21 +38,41 @@ Ask ninjanomnom if they're around
 #define RAD_MOB_GORILLIZE 1500						// How much stored radiation to check for gorillization
 #define RAD_MOB_GORILLIZE_PROB 0.1					// Chance of gorillization per tick when over threshold
 
-#define RAD_NO_INSULATION 1.0						// For things that shouldn't become irradiated for whatever reason
-#define RAD_VERY_LIGHT_INSULATION 0.9				// What girders have
+// Values here are for how much of the radiation is let through
+#define RAD_NO_INSULATION 1.0						// Default value for Gamma and Beta insulation
+#define RAD_ONE_PERCENT 0.99						// Used by geiger counters
+#define RAD_MOB_INSULATION 0.98						// Default value for mobs
+#define RAD_VERY_LIGHT_INSULATION 0.9
 #define RAD_LIGHT_INSULATION 0.8
-#define RAD_MEDIUM_INSULATION  0.7					// What common walls have
-#define RAD_HEAVY_INSULATION 0.6					// What reinforced walls have
-#define RAD_EXTREME_INSULATION 0.5					// What rad collectors have
+#define RAD_MEDIUM_INSULATION  0.7
+#define RAD_HEAVY_INSULATION 0.6
+#define RAD_VERY_HEAVY_INSULATION 0.5
+#define RAD_EXTREME_INSULATION 0.4
+#define RAD_VERY_EXTREME_INSULATION 0.2
+#define RAD_GAMMA_WINDOW 0.4						// For directional windows that are activated by gamma radiation
+#define RAD_GAMMA_FULL_WINDOW 0.16					// For full tile windows that are activated by gamma radiation
+#define RAD_BETA_COLLECTOR 0.2						// Amount of Beta radiation absorbed by collectors
+#define RAD_BETA_BLOCKER 0.2						// Amount of Beta radiation blocked by metallic things like walls and airlocks
+#define RAD_ALPHA_BLOCKER 0.01						// default value for Alpha insulation
 #define RAD_FULL_INSULATION 0						// Unused
 
-// WARNING: The defines below could have disastrous consequences if tweaked incorrectly. See: The great SM purge of Oct.6.2017
-// contamination_strength = 	(strength - RAD_MINIMUM_CONTAMINATION) * RAD_CONTAMINATION_STR_COEFFICIENT
-#define RAD_MINIMUM_CONTAMINATION 350				// How strong does a radiation wave have to be to contaminate objects
-#define RAD_CONTAMINATION_STR_COEFFICIENT 0.25		// Higher means higher strength scaling contamination strength
-#define RAD_DISTANCE_COEFFICIENT 1					// Lower means further rad spread
+// Contamination chance in percent. Mostly used by contaminate_adjacent(atom/source, intensity, emission_type)
+#define CONTAMINATION_CHANCE_TURF 1				// Chance to contaminate things while on/in a turf
+#define CONTAMINATION_CHANCE_OTHER 10			// Chance to contaminate things while in something like a bag
 
 #define RAD_HALF_LIFE 90							// The half-life of contaminated objects
 
 #define RAD_GEIGER_MEASURE_SMOOTHING 5
 #define RAD_GEIGER_GRACE_PERIOD 2
+
+/// The portion of a radiation wave that acts on the source tile.
+#define RAD_SOURCE_WEIGHT 0.25
+
+/// The point in steps at which radiation waves start to decay
+#define RAD_DECAY_POINT 10
+/// This multiplies the intensity of the radiation wave each step after reaching the decay point.
+#define RAD_DECAY_RATE 0.7943 // 1% after 20 tiles
+
+#define ALPHA_RAD 1
+#define BETA_RAD 2
+#define GAMMA_RAD 3

code/__HELPERS/radiation_helpers.dm

@@ -3,52 +3,183 @@
   * Components which return COMPONENT_BLOCK_RADIATION prevent further searching into that object's contents. The object itself will get returned still.
   * The ignore list makes those objects never return at all
   */
-/proc/get_rad_contents(atom/location)
+/proc/get_rad_contents(atom/location, emission_type)
 	var/static/list/ignored_things = typecacheof(list(
-		/mob/dead,
 		/mob/camera,
+		/mob/dead,
 		/obj/effect,
 		/obj/docking_port,
 		/atom/movable/lighting_object,
 		/obj/item/projectile,
-		/obj/structure/railing // uhhhh they're highly radiation resistant, or some shit (stops stupid exploits)
+		/atom/movable/emissive_blocker,
 	))
 	var/list/processing_list = list(location)
+	var/list/window_priority = list()
+	var/list/collector_priority = list()
+	var/list/other_priority = list()
 	. = list()
+	var/insulation = 1
 	while(length(processing_list))
 		var/atom/thing = processing_list[1]
 		processing_list -= thing
-		if(ignored_things[thing.type])
+		if(!thing || ignored_things[thing.type])
 			continue
-		. += thing
+		switch(emission_type)
+			if(ALPHA_RAD)
+				insulation = thing.rad_insulation_alpha
+			if(BETA_RAD)
+				insulation = thing.rad_insulation_beta
+			if(GAMMA_RAD)
+				insulation = thing.rad_insulation_gamma
+		/// 1 means no rad insulation, which means perfectly permeable, so no interaction with it directly, but the contents might be relevant.
+		if(insulation < 1)
+			if(istype(thing, /obj/structure/window))
+				window_priority += thing
+			else if(istype(thing, /obj/machinery/power/rad_collector))
+				collector_priority += thing
+			else
+				other_priority += thing
 		if((thing.flags_2 & RAD_PROTECT_CONTENTS_2) || (SEND_SIGNAL(thing, COMSIG_ATOM_RAD_PROBE) & COMPONENT_BLOCK_RADIATION))
 			continue
 		if(ishuman(thing))
-			var/mob/living/carbon/human/H = thing
-			if(H.get_rad_protection() >= 0.99) // I would do exactly equal to 1, but you will never hit anything between 1 and .975, and byond seems to output 0.99999
+			var/mob/living/carbon/human/target_mob = thing
+			if(target_mob.get_rad_protection() >= 0.99) // I would do exactly equal to 1, but you will never hit anything between 1 and .975, and byond seems to output 0.99999
 				continue
 		processing_list += thing.contents
+	. =	window_priority + collector_priority + other_priority
 
-/proc/radiation_pulse(atom/source, intensity, range_modifier, log = FALSE, can_contaminate = TRUE, source_radius = 0)
-	if(!SSradiation.can_fire)
-		return
-	for(var/dir in GLOB.cardinal)
-		new /datum/radiation_wave(source, dir, intensity, range_modifier, can_contaminate, source_radius)
+/proc/get_rad_contamination_adjacent(atom/location, atom/source)
+	var/static/list/ignored_things = typecacheof(list(
+		/mob/camera,
+		/mob/dead,
+		/obj/effect,
+		/obj/docking_port,
+		/atom/movable/lighting_object,
+		/obj/item/projectile,
+		/atom/movable/emissive_blocker,
+	))
+	var/list/processing_list = list(location)
+	// We want to select which clothes and items we contaminate depending on where on the human we are. We assume we are in some form of storage or on the floor otherwise.
+	// If the source is a human(like a uranium golem) we just attempt to contaminate all our contents
+	if(!ishuman(location) || ishuman(source))
+		processing_list += location.contents
+	. = list()
+	for(var/atom/thing in processing_list)
+		if(thing && source && thing.UID() == source.UID())
+			continue
+		if(ignored_things[thing.type])
+			continue
+		if((SEND_SIGNAL(thing, COMSIG_ATOM_RAD_CONTAMINATING) & COMPONENT_BLOCK_CONTAMINATION) || thing.flags_2 & RAD_NO_CONTAMINATE_2)
+			continue
+		if(ishuman(thing) || ishuman(thing.loc))
+			var/mob/living/carbon/human/target_mob = ishuman(thing) ? thing : thing.loc
+			var/passed = TRUE
+			var/zone
+			var/pocket = FALSE
+			// Check if we hold the contamination source, have it in our pockets or in our belts or if it's inside us
+			if(target_mob.UID() == location.UID())
+				// If it's in our hands check if it can permeate our gloves
+				if((source && (target_mob.r_hand && target_mob.r_hand.UID() == source.UID()) || (target_mob.l_hand && target_mob.l_hand.UID() == source.UID())))
+					zone = HANDS
 
-	var/list/things = get_rad_contents(source) //copypasta because I don't want to put special code in waves to handle their origin
-	for(var/k in 1 to length(things))
-		var/atom/thing = things[k]
-		if(!thing)
+				// If it's in our pockets check against our jumpsuit only
+				else if((target_mob?.l_store && target_mob?.l_store?.UID() == source?.UID()) || (target_mob?.r_store && target_mob?.r_store.UID() == source?.UID()))
+					zone = LOWER_TORSO
+					pocket = TRUE
+
+			// If it's on our belt check against both our outer layer and jumpsuit
+			if(location.loc.UID() == target_mob.UID() && istype(location, /obj/item/storage/belt))
+				zone = LOWER_TORSO
+
+			// If on the floor check if it can permeate our shoes
+			if(istype(location, /turf/))
+				zone = FEET
+
+			// zone being unchanged here means the item is inside the mob
+			var/list/results = target_mob.rad_contaminate_zone(zone, pocket)
+			passed = results[1]
+			results -= results[1]
+			. |= results
+			if(!passed)
+				continue
+		. += thing
+
+/proc/get_rad_contamination_target(atom/location, atom/source)
+	var/static/list/ignored_things = typecacheof(list(
+		/mob/camera,
+		/mob/dead,
+		/obj/effect,
+		/obj/docking_port,
+		/atom/movable/lighting_object,
+		/obj/item/projectile,
+		/atom/movable/emissive_blocker,
+	))
+	var/list/processing_list = list(location) + location.contents
+	. = list()
+	while(length(processing_list))
+		var/atom/thing = processing_list[1]
+		processing_list -= thing
+		if(thing?.UID() == source?.UID())
+			continue
+		if(ignored_things[thing.type])
+			continue
+		if((SEND_SIGNAL(thing, COMSIG_ATOM_RAD_CONTAMINATING) & COMPONENT_BLOCK_CONTAMINATION) || thing.flags_2 & RAD_NO_CONTAMINATE_2)
 			continue
-		thing.rad_act(intensity)
+		/// If it's a human check for rad protection on all areas
+		if(ishuman(thing))
+			var/mob/living/carbon/human/target_mob = thing
+			var/zone = 0
+			var/list/contaminate = list()
+			var/list/results = list()
+			var/passed = TRUE
+			for(var/i in 0 to 9)
+				zone = (1<<i)
+				results = target_mob.rad_contaminate_zone(zone)
+				passed = results[1] || passed
+				results -= results[1]
+				contaminate |= results
+			. |= contaminate
+			if(!passed)
+				continue
+			for(var/atom/human_content in target_mob.contents)
+				if(!istype(human_content, /obj/item/clothing))
+					. |= human_content
+		. += thing
+
+
+/proc/radiation_pulse(atom/source, intensity, emission_type = ALPHA_RAD, log = FALSE)
+	if(!SSradiation.can_fire || intensity < RAD_BACKGROUND_RADIATION)
+		return
+	var/datum/radiation_wave/wave = new /datum/radiation_wave(source, intensity, emission_type)
+
+	var/turf/start_turf = source
+
+	// Find the turf where we are
+	while(!istype(start_turf, /turf))
+		start_turf = start_turf.loc
+
+	var/list/things = get_rad_contents(start_turf, emission_type) // Radiate the waves origin frist
+	// Adjust the weights so the source tile doesn't get all the rads
+	wave.weight_sum = RAD_SOURCE_WEIGHT
+	wave.weights = list(wave.weight_sum)
+	for(var/atom/thing in things)
+		if(thing.UID() == source.UID())
+			// Don't block our own radiation
+			source.base_rad_act(source ,intensity, emission_type)
+		else
+			wave.weight_sum = wave.weight_sum * thing.base_rad_act(source ,intensity * wave.weight_sum, emission_type)
+	// Add the rest of the weight back
+	wave.weight_sum += (1 - RAD_SOURCE_WEIGHT)
+	// We can do this because we are on one tile so we have one weight
+	wave.weights[1] = wave.weight_sum
 
 	var/static/last_huge_pulse = 0
-	if(intensity > 3000 && world.time > last_huge_pulse + 200)
+	if(intensity > 12000 && world.time > last_huge_pulse + 200)
 		last_huge_pulse = world.time
 		log = TRUE
 	if(log)
 		var/turf/_source_T = isturf(source) ? source : get_turf(source)
-		log_game("Radiation pulse with intensity: [intensity] and range modifier: [range_modifier] in [loc_name(_source_T)] ")
+		log_game("Radiation pulse with intensity: [intensity] in [loc_name(_source_T)] ")
 	return TRUE
 
 /proc/get_rad_contamination(atom/location)
@@ -58,6 +189,24 @@
 		if(!thing)
 			continue
 		var/datum/component/radioactive/radiation = thing.GetComponent(/datum/component/radioactive)
-		if(radiation && rad_strength < radiation.strength)
-			rad_strength = radiation.strength
+		if(radiation && rad_strength < (radiation.alpha_strength + radiation.beta_strength + radiation.gamma_strength))
+			rad_strength = (radiation.alpha_strength + radiation.beta_strength + radiation.gamma_strength)
 	return rad_strength
+
+/// Contaminate things that share our immediate location(periodic)
+/proc/contaminate_adjacent(atom/source, intensity, emission_type)
+	// If the source is a turf it is it's location
+	var/atom/location = isturf(source) ? source : source.loc
+	// Are we on a turf or in something else
+	var/is_source_on_turf = isturf(location)
+	var/contamination_chance = is_source_on_turf ? CONTAMINATION_CHANCE_TURF : CONTAMINATION_CHANCE_OTHER
+	var/list/contamination_contents = get_rad_contamination_adjacent(location, source)
+	for(var/atom/thing in contamination_contents)
+		if(prob(contamination_chance))
+			thing.AddComponent(/datum/component/radioactive, intensity, source, emission_type)
+
+/// Contaminate the contents of a target(single instance)
+/proc/contaminate_target(atom/target, atom/source, intensity, emission_type)
+	var/list/contamination_contents = get_rad_contamination_target(target, source)
+	for(var/atom/thing in contamination_contents)
+		thing.AddComponent(/datum/component/radioactive, intensity, source, emission_type)

code/__HELPERS/unsorted.dm

@@ -1403,6 +1403,8 @@ GLOBAL_DATUM_INIT(dview_mob, /mob/dview, new)
 			var/obj/structure/window/W = O
 			if(W.ini_dir == dir_to_check || W.ini_dir == FULLTILE_WINDOW_DIR || dir_to_check == FULLTILE_WINDOW_DIR)
 				return FALSE
+		if(istype(O, /obj/machinery/power/rad_collector))
+			return FALSE
 	return TRUE
 
 //datum may be null, but it does need to be a typed var

code/controllers/subsystem/SSradiation.dm

@@ -26,7 +26,7 @@ PROCESSING_SUBSYSTEM_DEF(radiation)
 	warned_atoms[ref] = TRUE
 	var/atom/master = contamination.parent
 	SSblackbox.record_feedback("tally", "contaminated", 1, master.type)
-	var/msg = "has become contaminated with enough radiation to contaminate other objects. || Source: [contamination.source] || Strength: [contamination.strength]"
+	var/msg = "has become contaminated with enough radiation to emit radiation waves || Source: [contamination.source] || Strength: [contamination.alpha_strength + contamination.beta_strength + contamination.gamma_strength]"
 	master.investigate_log(msg, "radiation")
 
 /datum/controller/subsystem/processing/radiation/fire(resumed)
@@ -41,13 +41,25 @@ PROCESSING_SUBSYSTEM_DEF(radiation)
 	else
 		return 0
 
-/datum/controller/subsystem/processing/radiation/proc/update_rad_cache(datum/component/radioactive/thing)
+/datum/controller/subsystem/processing/radiation/proc/update_rad_cache_contaminated(datum/component/radioactive/thing)
 	var/atom/owner = thing.parent
 	var/turf/place = get_turf(owner)
 	if(turf_rad_cache[place])
-		turf_rad_cache[place] += thing.strength
+		turf_rad_cache[place][1] += thing.alpha_strength
+		turf_rad_cache[place][2] += thing.beta_strength
+		turf_rad_cache[place][3] += thing.gamma_strength
 	else
-		turf_rad_cache[place] = thing.strength
+		turf_rad_cache[place] = list(thing.alpha_strength, thing.beta_strength, thing.gamma_strength)
+
+/datum/controller/subsystem/processing/radiation/proc/update_rad_cache_inherent(datum/component/inherent_radioactivity/thing)
+	var/atom/owner = thing.parent
+	var/turf/place = get_turf(owner)
+	if(turf_rad_cache[place])
+		turf_rad_cache[place][1] += thing.radioactivity_alpha
+		turf_rad_cache[place][2] += thing.radioactivity_beta
+		turf_rad_cache[place][3] += thing.radioactivity_gamma
+	else
+		turf_rad_cache[place] = list(thing.radioactivity_alpha, thing.radioactivity_beta, thing.radioactivity_gamma)
 
 
 /datum/controller/subsystem/processing/radiation/proc/refresh_rad_cache()