Merge branch 'master' of https://github.com/Citadel-Station-13/Citadel-Station-13 into Ghommie-cit723

code/datums/brain_damage/imaginary_friend.dm

@@ -150,6 +150,8 @@
 	friend_talk(message)
 
 /mob/camera/imaginary_friend/Hear(message, atom/movable/speaker, datum/language/message_language, raw_message, radio_freq, list/spans, message_mode, atom/movable/source)
+	if (client?.prefs.chat_on_map && (client.prefs.see_chat_non_mob || ismob(speaker)))
+		create_chat_message(speaker, message_language, raw_message, spans, message_mode)
 	to_chat(src, compose_message(speaker, message_language, raw_message, radio_freq, spans, message_mode, FALSE, source))
 
 /mob/camera/imaginary_friend/proc/friend_talk(message)

code/datums/chatmessage.dm

@@ -0,0 +1,236 @@
+#define CHAT_MESSAGE_SPAWN_TIME		0.2 SECONDS
+#define CHAT_MESSAGE_LIFESPAN		5 SECONDS
+#define CHAT_MESSAGE_EOL_FADE		0.7 SECONDS
+#define CHAT_MESSAGE_EXP_DECAY		0.7 // Messages decay at pow(factor, idx in stack)
+#define CHAT_MESSAGE_HEIGHT_DECAY	0.9 // Increase message decay based on the height of the message
+#define CHAT_MESSAGE_APPROX_LHEIGHT	11 // Approximate height in pixels of an 'average' line, used for height decay
+#define CHAT_MESSAGE_WIDTH			96 // pixels
+#define CHAT_MESSAGE_MAX_LENGTH		110 // characters
+#define WXH_TO_HEIGHT(x)			text2num(copytext((x), findtextEx((x), "x") + 1)) // thanks lummox
+
+/**
+  * # Chat Message Overlay
+  *
+  * Datum for generating a message overlay on the map
+  */
+/datum/chatmessage
+	/// The visual element of the chat messsage
+	var/image/message
+	/// The location in which the message is appearing
+	var/atom/message_loc
+	/// The client who heard this message
+	var/client/owned_by
+	/// Contains the scheduled destruction time
+	var/scheduled_destruction
+	/// Contains the approximate amount of lines for height decay
+	var/approx_lines
+
+/**
+  * Constructs a chat message overlay
+  *
+  * Arguments:
+  * * text - The text content of the overlay
+  * * target - The target atom to display the overlay at
+  * * owner - The mob that owns this overlay, only this mob will be able to view it
+  * * extra_classes - Extra classes to apply to the span that holds the text
+  * * lifespan - The lifespan of the message in deciseconds
+  */
+/datum/chatmessage/New(text, atom/target, mob/owner, list/extra_classes = null, lifespan = CHAT_MESSAGE_LIFESPAN)
+	. = ..()
+	if (!istype(target))
+		CRASH("Invalid target given for chatmessage")
+	if(QDELETED(owner) || !istype(owner) || !owner.client)
+		stack_trace("/datum/chatmessage created with [isnull(owner) ? "null" : "invalid"] mob owner")
+		qdel(src)
+		return
+	INVOKE_ASYNC(src, .proc/generate_image, text, target, owner, extra_classes, lifespan)
+
+/datum/chatmessage/Destroy()
+	if (owned_by)
+		if (owned_by.seen_messages)
+			LAZYREMOVEASSOC(owned_by.seen_messages, message_loc, src)
+		owned_by.images.Remove(message)
+	owned_by = null
+	message_loc = null
+	message = null
+	return ..()
+
+/**
+  * Generates a chat message image representation
+  *
+  * Arguments:
+  * * text - The text content of the overlay
+  * * target - The target atom to display the overlay at
+  * * owner - The mob that owns this overlay, only this mob will be able to view it
+  * * extra_classes - Extra classes to apply to the span that holds the text
+  * * lifespan - The lifespan of the message in deciseconds
+  */
+/datum/chatmessage/proc/generate_image(text, atom/target, mob/owner, list/extra_classes, lifespan)
+	// Register client who owns this message
+	owned_by = owner.client
+	RegisterSignal(owned_by, COMSIG_PARENT_QDELETING, .proc/qdel, src)
+
+	// Clip message
+	var/maxlen = owned_by.prefs.max_chat_length
+	if (length_char(text) > maxlen)
+		text = copytext_char(text, 1, maxlen + 1) + "..." // BYOND index moment
+
+	// Calculate target color if not already present
+	if (!target.chat_color || target.chat_color_name != target.name)
+		target.chat_color = colorize_string(target.name)
+		target.chat_color_darkened = colorize_string(target.name, 0.85, 0.85)
+		target.chat_color_name = target.name
+
+	// Get rid of any URL schemes that might cause BYOND to automatically wrap something in an anchor tag
+	var/static/regex/url_scheme = new(@"[A-Za-z][A-Za-z0-9+-\.]*:\/\/", "g")
+	text = replacetext(text, url_scheme, "")
+
+	// Reject whitespace
+	var/static/regex/whitespace = new(@"^\s*$")
+	if (whitespace.Find(text))
+		qdel(src)
+		return
+
+	// Non mobs speakers can be small
+	if (!ismob(target))
+		extra_classes |= "small"
+
+	// Append radio icon if from a virtual speaker
+	if (extra_classes.Find("virtual-speaker"))
+		var/image/r_icon = image('icons/UI_Icons/chat/chat_icons.dmi', icon_state = "radio")
+		text =  "\icon[r_icon] " + text
+
+	// We dim italicized text to make it more distinguishable from regular text
+	var/tgt_color = extra_classes.Find("italics") ? target.chat_color_darkened : target.chat_color
+
+	// Approximate text height
+	// Note we have to replace HTML encoded metacharacters otherwise MeasureText will return a zero height
+	// BYOND Bug #2563917
+	// Construct text
+	var/static/regex/html_metachars = new(@"&[A-Za-z]{1,7};", "g")
+	var/complete_text = "<span class='center maptext [extra_classes != null ? extra_classes.Join(" ") : ""]' style='color: [tgt_color]'>[text]</span>"
+	var/mheight = WXH_TO_HEIGHT(owned_by.MeasureText(replacetext(complete_text, html_metachars, "m"), null, CHAT_MESSAGE_WIDTH))
+	approx_lines = max(1, mheight / CHAT_MESSAGE_APPROX_LHEIGHT)
+
+	// Translate any existing messages upwards, apply exponential decay factors to timers
+	message_loc = target
+	if (owned_by.seen_messages)
+		var/idx = 1
+		var/combined_height = approx_lines
+		for(var/msg in owned_by.seen_messages[message_loc])
+			var/datum/chatmessage/m = msg
+			animate(m.message, pixel_y = m.message.pixel_y + mheight, time = CHAT_MESSAGE_SPAWN_TIME)
+			combined_height += m.approx_lines
+			var/sched_remaining = m.scheduled_destruction - world.time
+			if (sched_remaining > CHAT_MESSAGE_SPAWN_TIME)
+				var/remaining_time = (sched_remaining) * (CHAT_MESSAGE_EXP_DECAY ** idx++) * (CHAT_MESSAGE_HEIGHT_DECAY ** combined_height)
+				m.scheduled_destruction = world.time + remaining_time
+				addtimer(CALLBACK(m, .proc/end_of_life), remaining_time, TIMER_UNIQUE|TIMER_OVERRIDE)
+
+	// Build message image
+	message = image(loc = message_loc, layer = CHAT_LAYER)
+	message.plane = GAME_PLANE
+	message.appearance_flags = APPEARANCE_UI_IGNORE_ALPHA | KEEP_APART
+	message.alpha = 0
+	message.pixel_y = owner.bound_height * 0.95
+	message.maptext_width = CHAT_MESSAGE_WIDTH
+	message.maptext_height = mheight
+	message.maptext_x = (CHAT_MESSAGE_WIDTH - owner.bound_width) * -0.5
+	message.maptext = complete_text
+
+	// View the message
+	LAZYADDASSOC(owned_by.seen_messages, message_loc, src)
+	owned_by.images |= message
+	animate(message, alpha = 255, time = CHAT_MESSAGE_SPAWN_TIME)
+
+	// Prepare for destruction
+	scheduled_destruction = world.time + (lifespan - CHAT_MESSAGE_EOL_FADE)
+	addtimer(CALLBACK(src, .proc/end_of_life), lifespan - CHAT_MESSAGE_EOL_FADE, TIMER_UNIQUE|TIMER_OVERRIDE)
+
+/**
+  * Applies final animations to overlay CHAT_MESSAGE_EOL_FADE deciseconds prior to message deletion
+  */
+/datum/chatmessage/proc/end_of_life(fadetime = CHAT_MESSAGE_EOL_FADE)
+	animate(message, alpha = 0, time = fadetime, flags = ANIMATION_PARALLEL)
+	QDEL_IN(src, fadetime)
+
+/**
+  * Creates a message overlay at a defined location for a given speaker
+  *
+  * Arguments:
+  * * speaker - The atom who is saying this message
+  * * message_language - The language that the message is said in
+  * * raw_message - The text content of the message
+  * * spans - Additional classes to be added to the message
+  * * message_mode - Bitflags relating to the mode of the message
+  */
+/mob/proc/create_chat_message(atom/movable/speaker, datum/language/message_language, raw_message, list/spans, message_mode)
+	// Ensure the list we are using, if present, is a copy so we don't modify the list provided to us
+	spans = spans?.Copy()
+
+	// Check for virtual speakers (aka hearing a message through a radio)
+	var/atom/movable/originalSpeaker = speaker
+	if (istype(speaker, /atom/movable/virtualspeaker))
+		var/atom/movable/virtualspeaker/v = speaker
+		speaker = v.source
+		spans |= "virtual-speaker"
+
+	// Ignore virtual speaker (most often radio messages) from ourself
+	if (originalSpeaker != src && speaker == src)
+		return
+
+	// Display visual above source
+	new /datum/chatmessage(lang_treat(speaker, message_language, raw_message, spans, null, TRUE), speaker, src, spans)
+
+
+// Tweak these defines to change the available color ranges
+#define CM_COLOR_SAT_MIN	0.6
+#define CM_COLOR_SAT_MAX	0.7
+#define CM_COLOR_LUM_MIN	0.65
+#define CM_COLOR_LUM_MAX	0.75
+
+/**
+  * Gets a color for a name, will return the same color for a given string consistently within a round.atom
+  *
+  * Note that this proc aims to produce pastel-ish colors using the HSL colorspace. These seem to be favorable for displaying on the map.
+  *
+  * Arguments:
+  * * name - The name to generate a color for
+  * * sat_shift - A value between 0 and 1 that will be multiplied against the saturation
+  * * lum_shift - A value between 0 and 1 that will be multiplied against the luminescence
+  */
+/datum/chatmessage/proc/colorize_string(name, sat_shift = 1, lum_shift = 1)
+	// seed to help randomness
+	var/static/rseed = rand(1,26)
+
+	// get hsl using the selected 6 characters of the md5 hash
+	var/hash = copytext(md5(name + GLOB.round_id), rseed, rseed + 6)
+	var/h = hex2num(copytext(hash, 1, 3)) * (360 / 255)
+	var/s = (hex2num(copytext(hash, 3, 5)) >> 2) * ((CM_COLOR_SAT_MAX - CM_COLOR_SAT_MIN) / 63) + CM_COLOR_SAT_MIN
+	var/l = (hex2num(copytext(hash, 5, 7)) >> 2) * ((CM_COLOR_LUM_MAX - CM_COLOR_LUM_MIN) / 63) + CM_COLOR_LUM_MIN
+
+	// adjust for shifts
+	s *= clamp(sat_shift, 0, 1)
+	l *= clamp(lum_shift, 0, 1)
+
+	// convert to rgb
+	var/h_int = round(h/60) // mapping each section of H to 60 degree sections
+	var/c = (1 - abs(2 * l - 1)) * s
+	var/x = c * (1 - abs((h / 60) % 2 - 1))
+	var/m = l - c * 0.5
+	x = (x + m) * 255
+	c = (c + m) * 255
+	m *= 255
+	switch(h_int)
+		if(0)
+			return "#[num2hex(c, 2)][num2hex(x, 2)][num2hex(m, 2)]"
+		if(1)
+			return "#[num2hex(x, 2)][num2hex(c, 2)][num2hex(m, 2)]"
+		if(2)
+			return "#[num2hex(m, 2)][num2hex(c, 2)][num2hex(x, 2)]"
+		if(3)
+			return "#[num2hex(m, 2)][num2hex(x, 2)][num2hex(c, 2)]"
+		if(4)
+			return "#[num2hex(x, 2)][num2hex(m, 2)][num2hex(c, 2)]"
+		if(5)
+			return "#[num2hex(c, 2)][num2hex(m, 2)][num2hex(x, 2)]"

code/datums/components/archaeology.dm

@@ -1,95 +0,0 @@
-/datum/component/archaeology
-	dupe_mode = COMPONENT_DUPE_UNIQUE
-	var/list/archdrops = list(/obj/item/bikehorn = list(ARCH_PROB = 100, ARCH_MAXDROP = 1)) // honk~
-	var/prob2drop
-	var/dug
-	var/datum/callback/callback
-
-/datum/component/archaeology/Initialize(list/_archdrops = list(), datum/callback/_callback)
-	archdrops = _archdrops
-	for(var/i in archdrops)
-		if(isnull(archdrops[i][ARCH_MAXDROP]))
-			archdrops[i][ARCH_MAXDROP] = 1
-			stack_trace("ARCHAEOLOGY WARNING: [parent] contained a null max_drop value in [i].")
-		if(isnull(archdrops[i][ARCH_PROB]))
-			archdrops[i][ARCH_PROB] = 100
-			stack_trace("ARCHAEOLOGY WARNING: [parent] contained a null probability value in [i].")
-	callback = _callback
-	RegisterSignal(parent, COMSIG_PARENT_ATTACKBY,.proc/Dig)
-	RegisterSignal(parent, COMSIG_ATOM_EX_ACT, .proc/BombDig)
-	RegisterSignal(parent, COMSIG_ATOM_SING_PULL, .proc/SingDig)
-
-/datum/component/archaeology/InheritComponent(datum/component/archaeology/A, i_am_original)
-	var/list/other_archdrops = A.archdrops
-	var/list/_archdrops = archdrops
-	for(var/I in other_archdrops)
-		_archdrops[I] += other_archdrops[I]
-
-/datum/component/archaeology/proc/Dig(datum/source, obj/item/I, mob/living/user)
-	if(dug)
-		to_chat(user, "<span class='notice'>Looks like someone has dug here already.</span>")
-		return
-
-	if(!isturf(user.loc))
-		return
-
-	if(I.tool_behaviour == TOOL_SHOVEL || I.tool_behaviour == TOOL_MINING)
-		to_chat(user, "<span class='notice'>You start digging...</span>")
-
-		if(I.use_tool(parent, user, 40, volume=50))
-			to_chat(user, "<span class='notice'>You dig a hole.</span>")
-			gets_dug()
-			dug = TRUE
-			SSblackbox.record_feedback("tally", "pick_used_mining", 1, I.type)
-			return COMPONENT_NO_AFTERATTACK
-
-/datum/component/archaeology/proc/gets_dug()
-	if(dug)
-		return
-	else
-		var/turf/open/OT = get_turf(parent)
-		for(var/thing in archdrops)
-			var/maxtodrop = archdrops[thing][ARCH_MAXDROP]
-			for(var/i in 1 to maxtodrop)
-				if(prob(archdrops[thing][ARCH_PROB])) // can't win them all!
-					new thing(OT)
-
-		if(isopenturf(OT))
-			if(OT.postdig_icon_change)
-				if(istype(OT, /turf/open/floor/plating/asteroid/) && !OT.postdig_icon)
-					var/turf/open/floor/plating/asteroid/AOT = parent
-					AOT.icon_plating = "[AOT.environment_type]_dug"
-					AOT.icon_state = "[AOT.environment_type]_dug"
-				else
-					if(isplatingturf(OT))
-						var/turf/open/floor/plating/POT = parent
-						POT.icon_plating = "[POT.postdig_icon]"
-						POT.icon_state = "[OT.postdig_icon]"
-
-			if(OT.slowdown) //Things like snow slow you down until you dig them.
-				OT.slowdown = 0
-	dug = TRUE
-	if(callback)
-		callback.Invoke()
-
-/datum/component/archaeology/proc/SingDig(datum/source, S, current_size)
-	switch(current_size)
-		if(STAGE_THREE)
-			if(prob(30))
-				gets_dug()
-		if(STAGE_FOUR)
-			if(prob(50))
-				gets_dug()
-		else
-			if(current_size >= STAGE_FIVE && prob(70))
-				gets_dug()
-
-/datum/component/archaeology/proc/BombDig(datum/source, severity, target)
-	switch(severity)
-		if(3)
-			return
-		if(2)
-			if(prob(20))
-				gets_dug()
-		if(1)
-			gets_dug()

code/datums/components/crafting/recipes/recipes_misc.dm

@@ -260,6 +260,15 @@
 	subcategory = CAT_TOOL
 	category = CAT_MISC
 
+/datum/crafting_recipe/electrochromatic_kit
+	name = "Electrochromatic Kit"
+	result = /obj/item/electronics/electrochromatic_kit
+	reqs = list(/obj/item/stack/sheet/metal = 1,
+				/obj/item/stack/cable_coil = 1)
+	time = 5
+	subcategory = CAT_TOOL
+	category = CAT_MISC
+
 ////////////
 //Vehicles//
 ////////////

code/datums/components/mirage_border.dm

@@ -39,4 +39,5 @@
 /obj/effect/abstract/mirage_holder
 	name = "Mirage holder"
 	anchored = TRUE
+	plane = PLANE_SPACE
 	mouse_opacity = MOUSE_OPACITY_TRANSPARENT

code/datums/elements/mob_holder.dm

@@ -164,7 +164,7 @@
 	release()
 
 /obj/item/clothing/head/mob_holder/mob_can_equip(mob/living/M, mob/living/equipper, slot, disable_warning = FALSE, bypass_equip_delay_self = FALSE)
-	if(!ishuman(M)) //monkeys holding monkeys holding monkeys...
+	if(M == held_mob || !ishuman(M)) //monkeys holding monkeys holding monkeys...
 		return FALSE
 	return ..()
 

code/datums/elements/scavenging.dm

@@ -0,0 +1,215 @@
+ /*
+  * Scavenging element. Its scope shouldn't elude your imagination.
+  * Basically loot piles that can be searched through for some items.
+  * In my opinion, these are more engaging than normal maintenance loot spawners.
+  * The loot doesn't have to be strictly made of items and objects, you could also use it to invoke some "events"
+  * such as mice, rats, an halloween spook, persistent relics, traps, etcetera, go wild.
+  */
+/datum/element/scavenging
+	element_flags = ELEMENT_BESPOKE|ELEMENT_DETACH
+	id_arg_index = 3
+
+	var/list/loot_left_per_atom = list() //loot left per attached atom.
+	var/list/loot_table //pickweight list of available loot.
+	var/list/unique_loot //limited loot, once the associated value reaches zero, its key is removed from loot_table
+	var/scavenge_time = 12 SECONDS //how much time it takes
+	var/can_use_hands = TRUE  //bare handed scavenge time multiplier. If set to zero, only tools are usable.
+	var/list/tool_types //which tool types the player can use instead of scavenging by hand, associated value is their speed.
+	var/del_atom_on_depletion = FALSE //Will the atom be deleted when there is no loot left?
+	var/list/search_texts = list("starts searching through", "start searching through", "You hear rummaging...")
+	var/loot_restriction = NO_LOOT_RESTRICTION
+	var/maximum_loot_per_player = 1 //only relevant if there is a restriction.
+	var/list/scavenger_restriction_list //used for restrictions.
+
+	var/mean_loot_weight = 0
+	var/list/progress_per_atom = list() //seconds of ditched progress per atom, used to resume the work instead of starting over.
+	var/static/list/players_busy_scavenging = list() //players already busy scavenging.
+
+/datum/element/scavenging/Attach(atom/target, amount = 5, list/loot, list/unique, time = 12 SECONDS, hands = TRUE, list/tools, list/texts, \
+								del_deplete = FALSE, restriction = NO_LOOT_RESTRICTION, max_per_player = 1)
+	. = ..()
+	if(. == ELEMENT_INCOMPATIBLE || !length(loot) || !amount || !istype(target) || isarea(target))
+		return ELEMENT_INCOMPATIBLE
+	loot_left_per_atom[target] = amount
+	if(!loot_table)
+		loot_table = loot
+		for(var/A in loot_table) //tally the list weights
+			mean_loot_weight += loot_table[A]
+		mean_loot_weight /= length(loot_table)
+	if(!unique_loot)
+		unique_loot = unique || list()
+	scavenge_time = time
+	can_use_hands = hands
+	tool_types = tools
+	if(texts)
+		search_texts = texts
+	del_atom_on_depletion = del_deplete
+	loot_restriction = restriction
+	maximum_loot_per_player = max_per_player
+	if(can_use_hands)
+		RegisterSignal(target, list(COMSIG_ATOM_ATTACK_HAND, COMSIG_ATOM_ATTACK_PAW), .proc/scavenge_barehanded)
+	if(tool_types)
+		RegisterSignal(target, COMSIG_PARENT_ATTACKBY, .proc/scavenge_tool)
+	RegisterSignal(target, COMSIG_PARENT_EXAMINE, .proc/on_examine)
+
+/datum/element/scavenging/Detach(atom/target)
+	. = ..()
+	loot_left_per_atom -= target
+	progress_per_atom -= target
+	if(maximum_loot_per_player == LOOT_RESTRICTION_MIND_PILE || maximum_loot_per_player == LOOT_RESTRICTION_CKEY_PILE)
+		maximum_loot_per_player -= target
+	UnregisterSignal(target, list(COMSIG_ATOM_ATTACK_HAND, COMSIG_PARENT_ATTACKBY, COMSIG_PARENT_EXAMINE))
+
+/datum/element/scavenging/proc/on_examine(atom/source, mob/user, list/examine_list)
+	var/methods = tool_types.Copy()
+	if(can_use_hands)
+		methods += list("bare handed")
+	if(!length(methods))
+		return
+	var/text = english_list(methods, "", " or ")
+	examine_list += "<span class='notice'>Looks like [source.p_they()] can be scavenged [length(tool_types) ? "with" : ""][length(methods == 1) ? "" : "either "][length(tool_types) ? "a " : ""][text]</span>"
+
+/datum/element/scavenging/proc/scavenge_barehanded(atom/source, mob/user)
+	scavenge(source, user, 1)
+	return COMPONENT_NO_ATTACK_HAND
+
+/datum/element/scavenging/proc/scavenge_tool(atom/source, obj/item/I, mob/user, params)
+	if(user.a_intent == INTENT_HARM || !I.tool_behaviour) //Robust trash disposal techniques!
+		return
+	var/speed_multi = tool_types[I.tool_behaviour]
+	if(!speed_multi)
+		return
+	scavenge(source, user, speed_multi)
+	return COMPONENT_NO_AFTERATTACK
+
+/// This proc has to be asynced (cough cough, do_after) in order to return the comsig values in time to stop the attack chain.
+/datum/element/scavenging/proc/scavenge(atom/source, mob/user, speed_multi = 1)
+	set waitfor = FALSE
+
+	if(players_busy_scavenging[user])
+		return
+	players_busy_scavenging[user] = TRUE
+	var/progress_done = progress_per_atom[source]
+	var/len_messages = length(search_texts)
+	var/msg_first_person
+	if(len_messages >= 2)
+		msg_first_person = "<span class='notice'>You [progress_done ? ", resume a ditched task and " : ""][search_texts[2]] [source].</span>"
+	var/msg_blind
+	if(len_messages >= 3)
+		msg_blind = "<span class='italic'>[search_texts[3]]</span>"
+	user.visible_message("<span class='notice'>[user] [search_texts[1]] [source].</span>", msg_first_person, msg_blind)
+	if(do_after(user, scavenge_time * speed_multi, TRUE, source, TRUE, CALLBACK(src, .proc/set_progress, source, world.time), resume_time = progress_done * speed_multi))
+		spawn_loot(source, user)
+	players_busy_scavenging -= user
+
+/datum/element/scavenging/proc/set_progress(atom/source, start_time)
+	progress_per_atom[source] = world.time - start_time
+	return TRUE
+
+/datum/element/scavenging/proc/spawn_loot(atom/source, mob/user)
+	progress_per_atom -= source
+
+	var/loot = pickweight(loot_table)
+	var/special = TRUE
+	var/free = FALSE
+	if(!loot_left_per_atom[source])
+		to_chat(user, "<span class='warning'>Looks likes there is nothing worth of interest left in [source], what a shame...</span>")
+		return
+
+	var/num_times = 0
+	switch(loot_restriction)
+		if(LOOT_RESTRICTION_MIND)
+			num_times = LAZYACCESS(scavenger_restriction_list, user.mind)
+		if(LOOT_RESTRICTION_CKEY)
+			num_times = LAZYACCESS(scavenger_restriction_list, user.ckey)
+		if(LOOT_RESTRICTION_MIND_PILE)
+			var/list/L = LAZYACCESS(scavenger_restriction_list, source)
+			if(L)
+				num_times = LAZYACCESS(L, user.mind)
+		if(LOOT_RESTRICTION_CKEY_PILE)
+			var/list/L = LAZYACCESS(scavenger_restriction_list, source)
+			if(L)
+				num_times = LAZYACCESS(L, user.ckey)
+	if(num_times >= maximum_loot_per_player)
+		to_chat(user, "<span class='warning'>You can't find anything else vaguely useful in [source].  Another set of eyes might, however.</span>")
+		return
+
+	switch(loot) // TODO: datumize these out.
+		if(SCAVENGING_FOUND_NOTHING)
+			to_chat(user, "<span class='notice'>You found nothing, better luck next time.</span>")
+			free = TRUE //doesn't consume the loot pile.
+		if(SCAVENGING_SPAWN_MOUSE)
+			var/nasty_rodent = pick("mouse", "rodent", "squeaky critter", "stupid pest", "annoying cable chewer", "nasty, ugly, evil, disease-ridden rodent")
+			to_chat(user, "<span class='notice'>You found something in [source]... no wait, that's just another [nasty_rodent].</span>")
+			new /mob/living/simple_animal/mouse(source.loc)
+		if(SCAVENGING_SPAWN_MICE)
+			user.visible_message("<span class='notice'>A small gang of mice emerges from [source].</span>", \
+				"<span class='notice'>You found something in [source]... no wait, that's just another- <b>no wait, that's a lot of damn mice.</b></span>")
+			for(var/i in 1 to rand(4, 6))
+				new /mob/living/simple_animal/mouse(source.loc)
+		if(SCAVENGING_SPAWN_TOM)
+			if(GLOB.tom_existed) //There can only be one.
+				to_chat(user, "<span class='notice'>You found nothing, better luck next time.</span>")
+				free = TRUE
+			else
+				to_chat(user, "<span class='notice'>You found something in [source]... no wait, that's Tom, the mouse! What is he doing here?</span>")
+				new /mob/living/simple_animal/mouse/brown/Tom(source.loc)
+		else
+			special = FALSE
+
+	if(!special) //generic loot. Nothing too strange like more loot spawners anyway.
+		var/atom/A = new loot(source.loc)
+		if(isitem(A) && !user.get_active_held_item())
+			user.put_in_hands(A)
+		var/rarity_append = "."
+		switch(loot_table[loot]/mean_loot_weight*100)
+			if(0 to 1)
+				rarity_append = "! <b>AMAZING!</b>"
+			if(1 to 2)
+				rarity_append = "! Woah!"
+			if(2 to 5)
+				rarity_append = ". Rare!"
+			if(5 to 10)
+				rarity_append = ". Great."
+			if(10 to 25)
+				rarity_append = ". Nice."
+			if(20 to 50)
+				rarity_append = ". Not bad."
+		to_chat(user, "You found something in [source]... it's \a [A][rarity_append]")
+
+	if(unique_loot[loot])
+		var/loot_left = --unique_loot[loot]
+		if(!loot_left)
+			loot_table -= loot
+			unique_loot -= loot
+			mean_loot_weight = 0
+			for(var/A in loot_table) //re-tally the list weights
+				mean_loot_weight += loot_table[A]
+			mean_loot_weight /= length(loot_table)
+
+	if(free)
+		return
+
+	--loot_left_per_atom[source]
+	if(del_atom_on_depletion && !loot_left_per_atom[source])
+		source.visible_message("<span class='warning'>[source] has been looted clean.</span>")
+		qdel(source)
+		return
+
+	if(!loot_restriction)
+		return
+
+	LAZYINITLIST(scavenger_restriction_list)
+	switch(loot_restriction)
+		if(LOOT_RESTRICTION_MIND)
+			scavenger_restriction_list[user.mind]++
+		if(LOOT_RESTRICTION_CKEY)
+			scavenger_restriction_list[user.ckey]++
+		if(LOOT_RESTRICTION_MIND_PILE)
+			LAZYINITLIST(scavenger_restriction_list[source])
+			var/list/L = scavenger_restriction_list[source]
+			L[user.mind]++
+		if(LOOT_RESTRICTION_CKEY_PILE)
+			LAZYINITLIST(scavenger_restriction_list[source])
+			var/list/L = scavenger_restriction_list[source]
+			L[user.ckey]++

code/datums/skills/_skill_holder.dm

@@ -41,9 +41,7 @@
 /datum/skill_holder/proc/get_skill_affinity(skill)
 	if(!ispath(skill))
 		CRASH("Invalid get_skill_affinity call. Use typepaths.")		//until a time when we somehow need text ids for dynamic skills, I'm enforcing this.
-	if(!skills)
-		return 1
-	var/affinity = skill_affinities[skill]
+	var/affinity = LAZYACCESS(skill_affinities, skill)
 	if(isnull(affinity))
 		return 1
 	return affinity