Merge pull request #132 from MistakeNot4892/pyrelight

Updating from Neb dev.

Author: MistakeNot4892

code/__defines/chemistry.dm

@@ -78,13 +78,30 @@
 #define HANDLE_REACTIONS(_reagents)  if(!QDELETED(_reagents)) { SSmaterials.active_holders[_reagents] = TRUE; }
 #define UNQUEUE_REACTIONS(_reagents) SSmaterials.active_holders -= _reagents
 
-#define REAGENT_LIST(R) (R.reagents?.get_reagents() || "No reagent holder")
+#define REAGENT_LIST(R) ((istype(R, /datum/reagents) && R:get_reagents()) || "No reagent holder")
+
+#define REAGENT_TOTAL_VOLUME(R) (UNLINT((istype(R, /datum/reagents) && R:total_volume) || 0))
+#define REAGENT_TOTAL_LIQUID_VOLUME(R) (UNLINT((istype(R, /datum/reagents) && R:total_liquid_volume) || 0))
+
+#define REAGENT_MAXIMUM_VOLUME(R) (UNLINT((istype(R, /datum/reagents) && R:maximum_volume) || 0))
+#define REAGENTS_FREE_SPACE(R) (UNLINT(istype(R, /datum/reagents) ? (R.maximum_volume - R.total_volume) : 0))
+
+#define REAGENT_VOLUMES(R)        ( (istype(R, /datum/reagents) && UNLINT(R:reagent_volumes)) || null )
+#define REAGENT_SOLID_VOLUMES(R)  ( (istype(R, /datum/reagents) && UNLINT(R:solid_volumes))   || null )
+#define REAGENT_LIQUID_VOLUMES(R) ( (istype(R, /datum/reagents) && UNLINT(R:liquid_volumes))  || null )
+#define REAGENT_GET_MAX_VOL(R)    ( (istype(R, /datum/reagents) && UNLINT(R:maximum_volume))  || 0 )
+#define REAGENT_GET_ATOM(R)       ( (istype(R, /datum/reagents) && UNLINT(R:my_atom))         || null )
+
+#define REAGENT_VOLUME(R, M)      ( istype(R, /datum/reagents) && UNLINT(R:reagent_volumes && R:reagent_volumes[RESOLVE_TO_DECL(M)]) )
+#define LIQUID_VOLUME(R, M)       ( istype(R, /datum/reagents) && UNLINT(R:liquid_volumes  && R:liquid_volumes[RESOLVE_TO_DECL(M)]) )
+#define SOLID_VOLUME(R, M)        ( istype(R, /datum/reagents) && UNLINT(R:solid_volumes   && R:solid_volumes[RESOLVE_TO_DECL(M)]) )
+#define REAGENT_DATA(R, M)        ( istype(R, /datum/reagents) && UNLINT(R:reagent_data    && R:reagent_data[RESOLVE_TO_DECL(M)]) )
+
+#define REAGENT_SET_MAX_VOL(R, V) if(istype(R, /datum/reagents)) { UNLINT(R:maximum_volume = V) }
+#define REAGENT_ADD_MAX_VOL(R, V) if(istype(R, /datum/reagents)) { UNLINT(R:maximum_volume += V) }
+#define REAGENT_SET_ATOM(R, A)    if(istype(R, /datum/reagents)) { UNLINT(R:my_atom = A) }
+#define REAGENT_SET_DATA(R, M, D) if(istype(R, /datum/reagents)) { LAZYSET(UNLINT(R:reagent_data), M, D) }
 
-#define REAGENTS_FREE_SPACE(R) (R?.maximum_volume - R?.total_volume)
-#define REAGENT_VOLUME(REAGENT_HOLDER, REAGENT_TYPE) (REAGENT_HOLDER?.reagent_volumes && REAGENT_HOLDER.reagent_volumes[RESOLVE_TO_DECL(REAGENT_TYPE)])
-#define LIQUID_VOLUME(REAGENT_HOLDER,  REAGENT_TYPE) (REAGENT_HOLDER?.liquid_volumes  && REAGENT_HOLDER.liquid_volumes[RESOLVE_TO_DECL(REAGENT_TYPE)])
-#define SOLID_VOLUME(REAGENT_HOLDER,   REAGENT_TYPE) (REAGENT_HOLDER?.solid_volumes   && REAGENT_HOLDER.solid_volumes[RESOLVE_TO_DECL(REAGENT_TYPE)])
-#define REAGENT_DATA(REAGENT_HOLDER,   REAGENT_TYPE) (REAGENT_HOLDER?.reagent_data    && REAGENT_HOLDER.reagent_data[RESOLVE_TO_DECL(REAGENT_TYPE)])
 
 #define CHEM_DOSE(M, R) LAZYACCESS(M._chem_doses, RESOLVE_TO_DECL(R))
 

code/__defines/damage_organs.dm

@@ -77,6 +77,8 @@
 #define ORGAN_CATEGORY_STANCE      "stance"
 /// Limb is considered the 'root' of a given stance limb (leg) - also counted for stance damage a la ORGAN_CATEGORY_STANCE
 #define ORGAN_CATEGORY_STANCE_ROOT "stance_root"
+// Limb is considered a manipulator, currently only used when trying to pilot a wheelchair.
+#define ORGAN_CATEGORY_MANIPLE     "maniple"
 
 // Droplimb types.
 #define DISMEMBER_METHOD_EDGE  0

code/__defines/mobs.dm

@@ -150,30 +150,15 @@
 #define BP_EYES     "eyes"
 #define BP_HEART    "heart"
 #define BP_LUNGS    "lungs"
-#define BP_TRACH	"tracheae"
 #define BP_BRAIN    "brain"
 #define BP_LIVER    "liver"
 #define BP_KIDNEYS  "kidneys"
 #define BP_STOMACH  "stomach"
-#define BP_PLASMA   "plasma vessel"
 #define BP_APPENDIX "appendix"
 #define BP_CELL     "cell"
-#define BP_HIVE     "hive node"
-#define BP_NUTRIENT "nutrient vessel"
-#define BP_ACID     "acid gland"
-#define BP_EGG      "egg sac"
-#define BP_RESIN    "resin spinner"
-#define BP_STRATA   "neural strata"
-#define BP_RESPONSE "response node"
-#define BP_GBLADDER "gas bladder"
-#define BP_POLYP    "polyp segment"
-#define BP_ANCHOR   "anchoring ligament"
-#define BP_ACETONE  "acetone reactor"
 
 // Robo Organs.
 #define BP_VOICE             "vocal synthesiser"
-#define BP_STACK             "stack"
-#define BP_OPTICS            "optics"
 
 //Augmetations
 #define BP_AUGMENT_R_ARM        "right arm augment"
@@ -351,6 +336,7 @@ var/global/list/dexterity_levels = list(
 // Additional pronoun sets.
 #define NEUTER_ANIMATE "animate singular neutral"
 #define SECOND_PERSON_SINGULAR "second person singular"
+#define PSEUDOPLURAL "pseudoplural"
 
 // Equipment Overlays Indices //
 #define HO_CONDITION_LAYER  1

code/_helpers/global_lists.dm

@@ -37,12 +37,15 @@ var/global/list/string_slot_flags = list(
 )
 
 // Used to avoid constantly generating new lists during movement.
+var/global/list/all_maniple_limbs   = list(
+	(ORGAN_CATEGORY_MANIPLE)
+)
 var/global/list/all_stance_limbs   = list(
-	ORGAN_CATEGORY_STANCE,
-	ORGAN_CATEGORY_STANCE_ROOT
+	(ORGAN_CATEGORY_STANCE),
+	(ORGAN_CATEGORY_STANCE_ROOT)
 )
 var/global/list/child_stance_limbs = list(
-	ORGAN_CATEGORY_STANCE
+	(ORGAN_CATEGORY_STANCE)
 )
 
 // TODO: Replace keybinding datums with keybinding decls to make this unnecessary.

code/_helpers/lists.dm

@@ -27,13 +27,17 @@
 			input -= thing
 			var/thing_string = isatom(thing) ? thing.name : "\proper [thing]"
 			thing_count[thing_string] += 1
-			thing_gender[thing_string] = isatom(thing) ? thing.gender : NEUTER
+			if(ismob(thing))
+				var/mob/mob_thing = thing
+				thing_gender[thing_string] = mob_thing.get_gender()
+			else
+				thing_gender[thing_string] = isatom(thing) ? thing.gender : NEUTER
 		input = list()
 		for(var/thing_string in thing_count)
 			if(thing_count[thing_string] == 1)
 				input += "\the [thing_string]"
 			else
-				input += "[thing_count[thing_string]] [thing_string][thing_gender[thing_string] == PLURAL ? "" : "s"]"
+				input += "[thing_count[thing_string]] [thing_gender[thing_string] == PLURAL ? text_make_plural(thing_string) : thing_string]"
 
 	switch(length(input))
 		if(1)
@@ -172,7 +176,7 @@
 
 //Checks for specific types in specifically structured (Assoc "type" = TRUE) lists ('typecaches')
 /proc/is_type_in_typecache(atom/A, list/cache)
-	if(!cache || !cache.len || !A)
+	if(!LAZYLEN(cache) || !A)
 		return 0
 	return cache[A.type]
 

code/_helpers/medical_scans.dm

@@ -42,15 +42,14 @@
 	.["immune_system"] =    get_immunity()
 	.["reagents"] = list()
 
-	if(reagents?.total_volume)
-		for(var/decl/material/reagent as anything in reagents.liquid_volumes)
+	if(REAGENT_TOTAL_VOLUME(reagents))
+		for(var/decl/material/reagent as anything in REAGENT_LIQUID_VOLUMES(reagents))
 			var/list/reagent_data = list()
 			reagent_data["name"]      = reagent.get_reagent_name(reagents, MAT_PHASE_LIQUID)
 			reagent_data["quantity"]  = round(REAGENT_VOLUME(reagents, reagent),1)
 			reagent_data["scannable"] = reagent.scannable
 			.["reagents"] += list(reagent_data)
-
-		for(var/decl/material/reagent as anything in reagents.solid_volumes)
+		for(var/decl/material/reagent as anything in REAGENT_SOLID_VOLUMES(reagents))
 			var/list/reagent_data = list()
 			reagent_data["name"]      = reagent.get_reagent_name(reagents, MAT_PHASE_SOLID)
 			reagent_data["quantity"]  = round(REAGENT_VOLUME(reagents, reagent),1)
@@ -98,8 +97,8 @@
 	.["blood_pressure"] =   get_blood_pressure()
 	.["blood_o2"] =         get_blood_oxygenation()
 	if(vessel)
-		.["blood_volume"] =     vessel.total_volume
-		.["blood_volume_max"] = vessel.maximum_volume
+		.["blood_volume"] =     REAGENT_TOTAL_VOLUME(vessel)
+		.["blood_volume_max"] = REAGENT_MAXIMUM_VOLUME(vessel)
 
 /proc/display_medical_data_header(var/list/scan, skill_level = SKILL_DEFAULT)
 	//In case of problems, abort.

code/_helpers/text.dm

@@ -366,11 +366,22 @@ var/global/regex/starts_lowercase_regex = regex(@"^[a-z]")
 	return trim_left(trim_right(text))
 
 //Returns a string with the first element of the string capitalized.
+// NOTE: This will not work if there are any HTML tags.
 /proc/capitalize(text)
 	if(text)
 		text = uppertext(text[1]) + copytext(text, 1 + length(text[1]))
 	return text
 
+// Returns a string with the first alphabetical element of the string capitalized, skipping HTML tags.
+/proc/capitalize_proper_html(text)
+	var/static/regex/split_html_regex = regex(@"(^<[^>]*>)([A-Za-z])(.+)$")
+	if(!text)
+		return text
+	if(!split_html_regex.Find(text))
+		return capitalize(text)
+	split_html_regex.group[2] = uppertext(split_html_regex.group[2])
+	return JOINTEXT(split_html_regex.group)
+
 //Returns a string with the first element of the every word of the string capitalized.
 /proc/capitalize_words(text)
 	var/list/S = splittext(text, " ")
@@ -784,6 +795,48 @@ var/global/list/plural_words_unchanged = list(
 		word = "[jointext(splited, " ", 1, length(splited))] [word]"
 	return word
 
+var/global/list/copula_verbs = list("is" = TRUE, "am" = TRUE, "are" = TRUE)
+var/global/list/has_verbs = list("has" = TRUE, "have" = TRUE)
+var/global/list/does_verbs = list("does" = TRUE, "do" = TRUE)
+var/global/list/agreement_exception_verbs = list("can" = TRUE, "cannot" = TRUE, "can't" = TRUE, "will" = TRUE, "won't" = TRUE, "shall" = TRUE, "shan't" = TRUE, "may" = TRUE, "must" = TRUE, "ought" = TRUE, "could" = TRUE, "would" = TRUE, "should" = TRUE)
+/proc/verb_agree_with_pronouns(var/use_verb, var/decl/pronouns/use_pronouns, is_after_pronoun = TRUE)
+	// deal with compound verb phrases here!
+	// basically, skip all our adverbs, inflect only the first non-adverb word we find (which is hopefully a verb) and then keep everything after unchanged
+	// this will properly handle "successfully finish doing" and "properly manage to do"
+	// but not "somehow finish doing" which will get turned into "somehows finish doing" :(
+	// todo: fix that
+	var/list/words = splittext(use_verb, " ")
+	if(length(words) > 1)
+		var/last_adverb = 1
+		for(var/word_index in 1 to length(words))
+			if(text_ends_with(words[word_index], "ly"))
+				last_adverb = max(word_index, last_adverb)
+		use_verb = words[last_adverb]
+		// This overengineered nonsense ensures that we shouldn't end up with any doubled or missing spaces.
+		return jointext_no_nulls(list(jointext(words.Copy(1, last_adverb), " "), verb_agree_with_pronouns(use_verb, use_pronouns, is_after_pronoun = is_after_pronoun), jointext(words.Copy(last_adverb + 1, length(words) + 1), " ")), " ")
+	if(!is_after_pronoun && use_pronouns.pluralize_verb == /decl/pronouns::PLURALIZE_PSEUDO)
+		return use_verb // do not inflect pseudoplural unless after a pronoun
+	if(global.copula_verbs[use_verb])
+		return use_pronouns.is
+	else if(global.has_verbs[use_verb])
+		return use_pronouns.has
+	else if(global.does_verbs[use_verb])
+		return use_pronouns.does
+	else if(global.agreement_exception_verbs[use_verb])
+		return use_verb
+	// text_make_plural is intended for nouns, but should hopefully work for "fly" -> "flies" and similar.
+	switch(use_pronouns.pluralize_verb)
+		if(/decl/pronouns::PLURALIZE_NONE)
+			return use_verb
+		if(/decl/pronouns::PLURALIZE_PSEUDO)
+			// technically only the plural side can get hit here
+			// but better safe than sorry
+			return is_after_pronoun ? text_make_plural(use_verb) : use_verb
+		if(/decl/pronouns::PLURALIZE_ALL)
+			return text_make_plural(use_verb)
+		else
+			CRASH("Invalid value [use_pronouns.pluralize_verb] for [use_pronouns]!")
+
 // Surely we have this defined somewhere already??
 /proc/repeatstring(str, num)
 	. = list()

code/_helpers/unsorted.dm

@@ -765,15 +765,17 @@ var/global/list/WALLITEMS = list(
 
 /**Returns a number string with its ordinal suffix th, st, nd, rd */
 /proc/get_ordinal_string(var/num)
-	if(num < 10 && num > 20) //11, 12, 13 are exceptions in english, and just get 'th' like everything else
+	. = num
+	num %= 100
+	if(num < 10 || num > 20) //11, 12, 13 are exceptions in english, and just get 'th' like everything else
 		switch(num % 10)
 			if(1)
-				return "[num]st"
+				return "[.]st"
 			if(2)
-				return "[num]nd"
+				return "[.]nd"
 			if(3)
-				return "[num]rd"
-	return "[num]th"
+				return "[.]rd"
+	return "[.]th"
 
 ///A do nothing proc used to prevent empty block warnings
 ///In hot code (like atmos checks), use EMPTY_BLOCK_GUARD instead.

code/controllers/subsystems/event.dm

@@ -28,10 +28,11 @@ SUBSYSTEM_DEF(event)
 /datum/controller/subsystem/event/Initialize()
 
 	if(!event_containers)
+		// Order must conform to EVENT_LEVEL_MUNDANE, EVENT_LEVEL_MODERATE, EVENT_LEVEL_MAJOR.
 		event_containers = list(
-			EVENT_LEVEL_MUNDANE  = new global.using_map.event_container_mundane,
-			EVENT_LEVEL_MODERATE = new global.using_map.event_container_moderate,
-			EVENT_LEVEL_MAJOR    = new global.using_map.event_container_major
+			new global.using_map.event_container_mundane,
+			new global.using_map.event_container_moderate,
+			new global.using_map.event_container_major
 		)
 		all_events = null
 

code/controllers/subsystems/fluids.dm

@@ -100,7 +100,7 @@ SUBSYSTEM_DEF(fluids)
 		i++
 		current_fluid_holder = processing_fluids[i]
 
-		if(QDELETED(current_fluid_holder) || !current_fluid_holder.reagents?.total_volume)
+		if(QDELETED(current_fluid_holder) || !REAGENT_TOTAL_VOLUME(current_fluid_holder.reagents))
 			REMOVE_ACTIVE_FLUID(current_fluid_holder)
 			continue
 
@@ -110,7 +110,7 @@ SUBSYSTEM_DEF(fluids)
 
 		reagent_holder = current_fluid_holder.reagents
 		UPDATE_FLUID_BLOCKED_DIRS(current_fluid_holder)
-		current_depth = reagent_holder?.total_volume || 0
+		current_depth = REAGENT_TOTAL_VOLUME(reagent_holder)
 
 		// How is this happening
 		if(QDELETED(reagent_holder) || current_depth == -1.#IND || current_depth == 1.#IND)
@@ -123,7 +123,7 @@ SUBSYSTEM_DEF(fluids)
 			current_depth = current_fluid_holder.get_fluid_depth()
 
 		// Mimimum liquid depth for creation of slurries. Do this after evaporation since it may change the total depth.
-		if(reagent_holder?.total_liquid_volume < FLUID_SLURRY)
+		if(REAGENT_TOTAL_LIQUID_VOLUME(reagent_holder) < FLUID_SLURRY)
 			current_fluid_holder.dump_solid_reagents()
 			current_depth = current_fluid_holder.get_fluid_depth()
 
@@ -135,7 +135,7 @@ SUBSYSTEM_DEF(fluids)
 		// Wash our turf.
 		current_fluid_holder.fluid_act(reagent_holder)
 
-		if(isspaceturf(current_fluid_holder) || (istype(current_fluid_holder, /turf/floor) && (current_fluid_holder.turf_flags & TURF_FLAG_ABSORB_LIQUID) && (current_fluid_holder.reagents?.total_volume + current_fluid_holder.get_physical_height()) > 0))
+		if(isspaceturf(current_fluid_holder) || (istype(current_fluid_holder, /turf/floor) && (current_fluid_holder.turf_flags & TURF_FLAG_ABSORB_LIQUID) && (REAGENT_TOTAL_VOLUME(current_fluid_holder.reagents) + current_fluid_holder.get_physical_height()) > 0))
 			removing = round(current_depth * 0.5)
 			if(removing > 0)
 				current_fluid_holder.remove_fluids(removing, defer_update = TRUE)
@@ -154,8 +154,9 @@ SUBSYSTEM_DEF(fluids)
 			if(other_fluid_holder)
 				UPDATE_FLUID_BLOCKED_DIRS(other_fluid_holder)
 				if(!(other_fluid_holder.fluid_blocked_dirs & UP) && other_fluid_holder.CanFluidPass(UP))
-					if(!QDELETED(other_fluid_holder) && other_fluid_holder.reagents?.total_volume < FLUID_MAX_DEPTH)
-						current_fluid_holder.transfer_fluids_to(other_fluid_holder, min(floor(current_depth*0.5), FLUID_MAX_DEPTH - other_fluid_holder.reagents?.total_volume))
+					var/other_volume = REAGENT_TOTAL_VOLUME(other_fluid_holder.reagents)
+					if(!QDELETED(other_fluid_holder) && other_volume < FLUID_MAX_DEPTH)
+						current_fluid_holder.transfer_fluids_to(other_fluid_holder, min(floor(current_depth*0.5), FLUID_MAX_DEPTH - other_volume))
 						current_depth = current_fluid_holder.get_fluid_depth()
 
 		// Flow into the lowest level neighbor.
@@ -173,7 +174,7 @@ SUBSYSTEM_DEF(fluids)
 			if((neighbor.fluid_blocked_dirs & coming_from) || !neighbor.CanFluidPass(coming_from) || neighbor.is_flooded(absolute = TRUE) || !neighbor.CanFluidPass(global.reverse_dir[spread_dir]))
 				continue
 			other_fluid_holder = neighbor
-			neighbor_depth = (other_fluid_holder?.reagents?.total_volume || 0) + neighbor.get_physical_height()
+			neighbor_depth = (REAGENT_TOTAL_VOLUME(other_fluid_holder.reagents)) + neighbor.get_physical_height()
 			flow_amount = round((current_turf_depth - neighbor_depth)*0.5)
 			// TODO: multiply flow amount or minimum transfer amount by some
 			// viscosity calculation to allow for piles of jelly vs piles of water.
@@ -235,7 +236,7 @@ SUBSYSTEM_DEF(fluids)
 		if(current_fluid_holder.last_flow_strength >= 10)
 			// Catwalks mean items will be above the turf; subtract the turf height from our volume.
 			// TODO: somehow handle stuff that is on a catwalk or on the turf within the same turf.
-			var/effective_volume = current_fluid_holder.reagents?.total_volume
+			var/effective_volume = REAGENT_TOTAL_VOLUME(current_fluid_holder.reagents)
 			if(current_fluid_holder.get_supporting_platform())
 				// Depth is negative height, hence +=. TODO: positive heights? No idea how to handle that.
 				effective_volume += current_fluid_holder.get_physical_height()