cyberpresidentvanellope/Bubberstation
1
0
Fork 0
mirror of https://github.com/Bubberstation/Bubberstation.git synced 2026-02-07 14:59:13 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
94dece8e5a8dbf3eebbcc07a8658840957e88359
Bubberstation/code/__HELPERS/mobs.dm
LemonInTheDark 23bfdec8f4 Multiz Rework: Human Suffering Edition (Contains PLANE CUBE) (#69115) 
About The Pull Request

I've reworked multiz. This was done because our current implementation of multiz flattens planes down into just the openspace plane. This breaks any effects we attach to plane masters (including lighting), but it also totally kills the SIDE_MAP map format, which we NEED for wallening (A major 3/4ths resprite of all wall and wall adjacent things, making them more then one tile high. Without sidemap we would be unable to display things both in from of and behind objects on map. Stupid.)

This required MASSIVE changes. Both to all uses of the plane var for reasons I'll discuss later, and to a ton of different systems that interact with rendering.

I'll do my best to keep this compact, but there's only so much I can do. Sorry brother.
Core idea

OK: first thing.
vis_contents as it works now squishes the planes of everything inside it down into the plane of the vis_loc.
This is bad. But how to do better?

It's trivially easy to make copies of our existing plane masters but offset, and relay them to the bottom of the plane above. Not a problem. The issue is how to get the actual atoms on the map to "land" on them properly.

We could use FLOAT_PLANE to offset planes based off how they're being seen, in theory this would allow us to create lens for how objects are viewed.
But that's not a stable thing to do, because properly "landing" a plane on a desired plane master would require taking into account every bit of how it's being seen, would inherently break this effect.

Ok so we need to manually edit planes based off "z layer" (IE: what layer of a z stack are you on).

That's the key conceit of this pr. Implementing the plane cube, and ensuring planes are always offset properly.
Everything else is just gravy.
About the Plane Cube

Each plane master (except ones that opt out) is copied down by some constant value equal to the max absolute change between the first and the last plane.
We do this based off the max z stack size detected by SSmapping. This is also where updates come from, and where all our updating logic will live.

As mentioned, plane masters can choose to opt out of being mirrored down. In this case, anything that interacts with them assuming that they'll be offset will instead just get back the valid plane value. This works for render targets too, since I had to work them into the system as well.

Plane masters can also be temporarily hidden from the client's screen. This is done as an attempt at optimization, and applies to anything used in niche cases, or planes only used if there's a z layer below you.
About Plane Master Groups

BYOND supports having different "maps" on screen at once (IE: groups of items/turfs/etc)
Plane masters cannot cover 2 maps at once, since their location is determined by their screen_loc.
So we need to maintain a mirror of each plane for every map we have open.

This was quite messy, so I've refactored it (and maps too) to be a bit more modular.

Rather then storing a list of plane masters, we store a list of plane master group datums.
Each datum is in charge of the plane masters for its particular map, both creating them, and managing them.

Like I mentioned, I also refactored map views. Adding a new mapview is now as simple as newing a /atom/movable/screen/map_view, calling generate_view with the appropriate map id, setting things you want to display in its vis_contents, and then calling display_to on it, passing in the mob to show ourselves to.

Much better then the hardcoded pattern we used to use. So much duplicated code man.

Oh and plane master controllers, that system we have that allows for applying filters to sets of plane masters? I've made it use lookups on plane master groups now, rather then hanging references to all impacted planes. This makes logic easier, and prevents the need to manage references and update the controllers.

image

In addition, I've added a debug ui for plane masters.
It allows you to view all of your own plane masters and short descriptions of what they do, alongside tools for editing them and their relays.

It ALSO supports editing someone elses plane masters, AND it supports (in a very fragile and incomplete manner) viewing literally through someone else's eyes, including their plane masters. This is very useful, because it means you can debug "hey my X is yorked" issues yourself, on live.

In order to accomplish this I have needed to add setters for an ungodly amount of visual impacting vars. Sight flags, eye, see_invis, see_in_dark, etc.

It also comes with an info dump about the ui, and plane masters/relays in general.

Sort of on that note. I've documented everything I know that's niche/useful about our visual effects and rendering system. My hope is this will serve to bring people up to speed on what can be done more quickly, alongside making my sin here less horrible.
See https://github.com/LemonInTheDark/tgstation/blob/multiz-hell/.github/guides/VISUALS.md.
"Landing" planes

Ok so I've explained the backend, but how do we actually land planes properly?
Most of the time this is really simple. When a plane var is set, we need to provide some spokesperson for the appearance's z level. We can use this to derive their z layer, and thus what offset to use.

This is just a lot of gruntwork, but it's occasionally more complex.
Sometimes we need to cache a list of z layer -> effect, and then use that.
Also a LOT of updating on z move. So much z move shit.

Oh. and in order to make byond darkness work properly, I needed to add SEE_BLACKNESS to all sight flags.
This draws darkness to plane 0, which means I'm able to relay it around and draw it on different z layers as is possible. fun darkness ripple effects incoming someday

I also need to update mob overlays on move.
I do this by realiizing their appearances, mutating their plane, and then readding the overlay in the correct order.

The cost of this is currently 3N. I'm convinced this could be improved, but I've not got to it yet.
It can also occasionally cause overlays to corrupt. This is fixed by laying a protective ward of overlays.Copy in the sand, but that spell makes the compiler confused, so I'll have to bully lummy about fixing it at some point.
Behavior changes

We've had to give up on the already broken gateway "see through" effect. Won't work without managing gateway plane masters or something stupid. Not worth it.
So instead we display the other side as a ui element. It's worse, but not that bad.

Because vis_contents no longer flattens planes (most of the time), some uses of it now have interesting behavior.
The main thing that comes to mind is alert popups that display mobs. They can impact the lighting plane.
I don't really care, but it should be fixable, I think, given elbow grease.

Ah and I've cleaned up layers and plane defines to make them a bit easier to read/reason about, at least I think.
Why It's Good For The Game
<visual candy>

Fixes #65800
Fixes #68461
Changelog

cl
refactor: Refactored... well a lot really. Map views, anything to do with planes, multiz, a shit ton of rendering stuff. Basically if you see anything off visually report it
admin: VV a mob, and hit View/Edit Planes in the dropdown to steal their view, and modify it as you like. You can do the same to yourself using the Edit/Debug Planes verb
/cl
2022-09-27 20:11:04 +13:00

949 lines
30 KiB
Plaintext
Raw Blame History

//check_target_facings() return defines
/// Two mobs are facing the same direction
#define FACING_SAME_DIR 1
/// Two mobs are facing each others
#define FACING_EACHOTHER 2
/// Two mobs one is facing a person, but the other is perpendicular
#define FACING_INIT_FACING_TARGET_TARGET_FACING_PERPENDICULAR 3 //Do I win the most informative but also most stupid define award?
/proc/random_blood_type()
return pick(4;"O-", 36;"O+", 3;"A-", 28;"A+", 1;"B-", 20;"B+", 1;"AB-", 5;"AB+")
/proc/random_eye_color()
switch(pick(20;"brown",20;"hazel",20;"grey",15;"blue",15;"green",1;"amber",1;"albino"))
if("brown")
return "#663300"
if("hazel")
return "#554422"
if("grey")
return pick("#666666","#777777","#888888","#999999","#aaaaaa","#bbbbbb","#cccccc")
if("blue")
return "#3366cc"
if("green")
return "#006600"
if("amber")
return "#ffcc00"
if("albino")
return "#" + pick("cc","dd","ee","ff") + pick("00","11","22","33","44","55","66","77","88","99") + pick("00","11","22","33","44","55","66","77","88","99")
else
return "#000000"
/proc/random_underwear(gender)
if(!GLOB.underwear_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/underwear, GLOB.underwear_list, GLOB.underwear_m, GLOB.underwear_f)
switch(gender)
if(MALE)
return pick(GLOB.underwear_m)
if(FEMALE)
return pick(GLOB.underwear_f)
else
return pick(GLOB.underwear_list)
/proc/random_undershirt(gender)
if(!GLOB.undershirt_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/undershirt, GLOB.undershirt_list, GLOB.undershirt_m, GLOB.undershirt_f)
switch(gender)
if(MALE)
return pick(GLOB.undershirt_m)
if(FEMALE)
return pick(GLOB.undershirt_f)
else
return pick(GLOB.undershirt_list)
/proc/random_socks()
if(!GLOB.socks_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/socks, GLOB.socks_list)
return pick(GLOB.socks_list)
/proc/random_backpack()
return pick(GLOB.backpacklist)
/proc/random_features()
if(!GLOB.tails_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/tails/, GLOB.tails_list, add_blank = TRUE)
if(!GLOB.tails_list_human.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/tails/human, GLOB.tails_list_human, add_blank = TRUE)
if(!GLOB.tails_list_lizard.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/tails/lizard, GLOB.tails_list_lizard, add_blank = TRUE)
if(!GLOB.snouts_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/snouts, GLOB.snouts_list)
if(!GLOB.horns_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/horns, GLOB.horns_list)
if(!GLOB.ears_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/ears, GLOB.horns_list)
if(!GLOB.frills_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/frills, GLOB.frills_list)
if(!GLOB.spines_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/spines, GLOB.spines_list)
if(!GLOB.legs_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/legs, GLOB.legs_list)
if(!GLOB.body_markings_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/body_markings, GLOB.body_markings_list)
if(!GLOB.wings_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/wings, GLOB.wings_list)
if(!GLOB.moth_wings_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/moth_wings, GLOB.moth_wings_list)
if(!GLOB.moth_antennae_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/moth_antennae, GLOB.moth_antennae_list)
if(!GLOB.moth_markings_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/moth_markings, GLOB.moth_markings_list)
if(!GLOB.pod_hair_list.len)
init_sprite_accessory_subtypes(/datum/sprite_accessory/pod_hair, GLOB.pod_hair_list)
//For now we will always return none for tail_human and ears. | "For now" he says.
return(list(
"mcolor" = "#[pick("7F","FF")][pick("7F","FF")][pick("7F","FF")]",
"ethcolor" = GLOB.color_list_ethereal[pick(GLOB.color_list_ethereal)],
"tail_cat" = "None",
"tail_lizard" = "Smooth",
"wings" = "None",
"snout" = pick(GLOB.snouts_list),
"horns" = pick(GLOB.horns_list),
"ears" = "None",
"frills" = pick(GLOB.frills_list),
"spines" = pick(GLOB.spines_list),
"body_markings" = pick(GLOB.body_markings_list),
"legs" = "Normal Legs",
"caps" = pick(GLOB.caps_list),
"moth_wings" = pick(GLOB.moth_wings_list),
"moth_antennae" = pick(GLOB.moth_antennae_list),
"moth_markings" = pick(GLOB.moth_markings_list),
"tail_monkey" = "None",
"pod_hair" = pick(GLOB.pod_hair_list),
))
/proc/random_hairstyle(gender)
switch(gender)
if(MALE)
return pick(GLOB.hairstyles_male_list)
if(FEMALE)
return pick(GLOB.hairstyles_female_list)
else
return pick(GLOB.hairstyles_list)
/proc/random_facial_hairstyle(gender)
switch(gender)
if(MALE)
return pick(GLOB.facial_hairstyles_male_list)
if(FEMALE)
return pick(GLOB.facial_hairstyles_female_list)
else
return pick(GLOB.facial_hairstyles_list)
/proc/random_unique_name(gender, attempts_to_find_unique_name=10)
for(var/i in 1 to attempts_to_find_unique_name)
if(gender==FEMALE)
. = capitalize(pick(GLOB.first_names_female)) + " " + capitalize(pick(GLOB.last_names))
else
. = capitalize(pick(GLOB.first_names_male)) + " " + capitalize(pick(GLOB.last_names))
if(!findname(.))
break
/proc/random_unique_lizard_name(gender, attempts_to_find_unique_name=10)
for(var/i in 1 to attempts_to_find_unique_name)
. = capitalize(lizard_name(gender))
if(!findname(.))
break
/proc/random_unique_plasmaman_name(attempts_to_find_unique_name=10)
for(var/i in 1 to attempts_to_find_unique_name)
. = capitalize(plasmaman_name())
if(!findname(.))
break
/proc/random_unique_ethereal_name(attempts_to_find_unique_name=10)
for(var/i in 1 to attempts_to_find_unique_name)
. = capitalize(ethereal_name())
if(!findname(.))
break
/proc/random_unique_moth_name(attempts_to_find_unique_name=10)
for(var/i in 1 to attempts_to_find_unique_name)
. = capitalize(pick(GLOB.moth_first)) + " " + capitalize(pick(GLOB.moth_last))
if(!findname(.))
break
/proc/random_skin_tone()
return pick(GLOB.skin_tones)
GLOBAL_LIST_INIT(skin_tones, sort_list(list(
"albino",
"caucasian1",
"caucasian2",
"caucasian3",
"latino",
"mediterranean",
"asian1",
"asian2",
"arab",
"indian",
"african1",
"african2"
)))
GLOBAL_LIST_INIT(skin_tone_names, list(
"african1" = "Medium brown",
"african2" = "Dark brown",
"albino" = "Albino",
"arab" = "Light brown",
"asian1" = "Ivory",
"asian2" = "Beige",
"caucasian1" = "Porcelain",
"caucasian2" = "Light peach",
"caucasian3" = "Peach",
"indian" = "Brown",
"latino" = "Light beige",
"mediterranean" = "Olive",
))
/// An assoc list of species IDs to type paths
GLOBAL_LIST_EMPTY(species_list)
/proc/age2agedescription(age)
switch(age)
if(0 to 1)
return "infant"
if(1 to 3)
return "toddler"
if(3 to 13)
return "child"
if(13 to 19)
return "teenager"
if(19 to 30)
return "young adult"
if(30 to 45)
return "adult"
if(45 to 60)
return "middle-aged"
if(60 to 70)
return "aging"
if(70 to INFINITY)
return "elderly"
else
return "unknown"
///Timed action involving two mobs, the user and the target. interaction_key is the assoc key under which the do_after is capped under, and the max interaction count is how many of this interaction you can do at once.
/proc/do_mob(mob/user, mob/target, time = 3 SECONDS, timed_action_flags = NONE, progress = TRUE, datum/callback/extra_checks, interaction_key, max_interact_count = 1)
if(!user || !target)
return FALSE
var/user_loc = user.loc
var/drifting = FALSE
if(SSmove_manager.processing_on(user, SSspacedrift))
drifting = TRUE
var/target_loc = target.loc
if(!interaction_key && target)
interaction_key = target //Use the direct ref to the target
if(interaction_key) //Do we have a interaction_key now?
var/current_interaction_count = LAZYACCESS(user.do_afters, interaction_key) || 0
if(current_interaction_count >= max_interact_count) //We are at our peak
return
LAZYSET(user.do_afters, interaction_key, current_interaction_count + 1)
var/holding = user.get_active_held_item()
var/datum/progressbar/progbar
if (progress)
progbar = new(user, time, target)
if(target.pixel_x != 0) //shifts the progress bar if target has an offset sprite
progbar.bar.pixel_x -= target.pixel_x
if(!(timed_action_flags & IGNORE_SLOWDOWNS))
time *= user.cached_multiplicative_actions_slowdown
var/endtime = world.time+time
var/starttime = world.time
. = TRUE
while (world.time < endtime)
stoplag(1)
if(!QDELETED(progbar))
progbar.update(world.time - starttime)
if(drifting && !SSmove_manager.processing_on(user, SSspacedrift))
drifting = FALSE
user_loc = user.loc
if(
QDELETED(user) || QDELETED(target) \
|| (!(timed_action_flags & IGNORE_USER_LOC_CHANGE) && !drifting && user.loc != user_loc) \
|| (!(timed_action_flags & IGNORE_TARGET_LOC_CHANGE) && target.loc != target_loc) \
|| (!(timed_action_flags & IGNORE_HELD_ITEM) && user.get_active_held_item() != holding) \
|| (!(timed_action_flags & IGNORE_INCAPACITATED) && HAS_TRAIT(user, TRAIT_INCAPACITATED)) \
|| (extra_checks && !extra_checks.Invoke()) \
)
. = FALSE
break
if(!QDELETED(progbar))
progbar.end_progress()
if(interaction_key)
LAZYREMOVE(user.do_afters, interaction_key)
//some additional checks as a callback for for do_afters that want to break on losing health or on the mob taking action
/mob/proc/break_do_after_checks(list/checked_health, check_clicks)
if(check_clicks && next_move > world.time)
return FALSE
return TRUE
//pass a list in the format list("health" = mob's health var) to check health during this
/mob/living/break_do_after_checks(list/checked_health, check_clicks)
if(islist(checked_health))
if(health < checked_health["health"])
return FALSE
checked_health["health"] = health
return ..()
/**
* Timed action involving one mob user. Target is optional.
*
* Checks that `user` does not move, change hands, get stunned, etc. for the
* given `delay`. Returns `TRUE` on success or `FALSE` on failure.
* Interaction_key is the assoc key under which the do_after is capped, with max_interact_count being the cap. Interaction key will default to target if not set.
*/
/proc/do_after(mob/user, delay, atom/target, timed_action_flags = NONE, progress = TRUE, datum/callback/extra_checks, interaction_key, max_interact_count = 1)
if(!user)
return FALSE
var/atom/target_loc = null
if(target && !isturf(target))
target_loc = target.loc
if(!interaction_key && target)
interaction_key = target //Use the direct ref to the target
if(interaction_key) //Do we have a interaction_key now?
var/current_interaction_count = LAZYACCESS(user.do_afters, interaction_key) || 0
if(current_interaction_count >= max_interact_count) //We are at our peak
return
LAZYSET(user.do_afters, interaction_key, current_interaction_count + 1)
var/atom/user_loc = user.loc
var/drifting = FALSE
if(SSmove_manager.processing_on(user, SSspacedrift))
drifting = TRUE
var/holding = user.get_active_held_item()
if(!(timed_action_flags & IGNORE_SLOWDOWNS))
delay *= user.cached_multiplicative_actions_slowdown
var/datum/progressbar/progbar
if(progress)
progbar = new(user, delay, target || user)
var/endtime = world.time + delay
var/starttime = world.time
. = TRUE
while (world.time < endtime)
stoplag(1)
if(!QDELETED(progbar))
progbar.update(world.time - starttime)
if(drifting && !SSmove_manager.processing_on(user, SSspacedrift))
drifting = FALSE
user_loc = user.loc
if(
QDELETED(user) \
|| (!(timed_action_flags & IGNORE_USER_LOC_CHANGE) && !drifting && user.loc != user_loc) \
|| (!(timed_action_flags & IGNORE_HELD_ITEM) && user.get_active_held_item() != holding) \
|| (!(timed_action_flags & IGNORE_INCAPACITATED) && HAS_TRAIT(user, TRAIT_INCAPACITATED)) \
|| (extra_checks && !extra_checks.Invoke()) \
)
. = FALSE
break
if(
!(timed_action_flags & IGNORE_TARGET_LOC_CHANGE) \
&& !drifting \
&& !QDELETED(target_loc) \
&& (QDELETED(target) || target_loc != target.loc) \
&& ((user_loc != target_loc || target_loc != user)) \
)
. = FALSE
break
if(!QDELETED(progbar))
progbar.end_progress()
if(interaction_key)
LAZYREMOVE(user.do_afters, interaction_key)
///Timed action involving at least one mob user and a list of targets. interaction_key is the assoc key under which the do_after is capped under, and the max interaction count is how many of this interaction you can do at once.
/proc/do_after_mob(mob/user, list/targets, time = 3 SECONDS, timed_action_flags = NONE, progress = TRUE, datum/callback/extra_checks, interaction_key, max_interact_count = 1)
if(!user)
return FALSE
if(!islist(targets))
targets = list(targets)
if(!length(targets))
return FALSE
var/user_loc = user.loc
if(!(timed_action_flags & IGNORE_SLOWDOWNS))
time *= user.cached_multiplicative_actions_slowdown
var/drifting = FALSE
if(SSmove_manager.processing_on(user, SSspacedrift))
drifting = TRUE
var/list/originalloc = list()
for(var/atom/target in targets)
originalloc[target] = target.loc
if(interaction_key)
var/current_interaction_count = LAZYACCESS(user.do_afters, interaction_key) || 0
if(current_interaction_count >= max_interact_count) //We are at our peak
to_chat(user, span_warning("You can't do this at the moment!"))
return
LAZYSET(user.do_afters, interaction_key, current_interaction_count + 1)
var/holding = user.get_active_held_item()
var/datum/progressbar/progbar
if(progress)
progbar = new(user, time, targets[1])
var/endtime = world.time + time
var/starttime = world.time
. = TRUE
while(world.time < endtime)
stoplag(1)
if(!QDELETED(progbar))
progbar.update(world.time - starttime)
if(QDELETED(user) || !length(targets))
. = FALSE
break
if(drifting && !SSmove_manager.processing_on(user, SSspacedrift))
drifting = FALSE
user_loc = user.loc
if(
(!(timed_action_flags & IGNORE_USER_LOC_CHANGE) && !drifting && user_loc != user.loc) \
|| (!(timed_action_flags & IGNORE_HELD_ITEM) && user.get_active_held_item() != holding) \
|| (!(timed_action_flags & IGNORE_INCAPACITATED) && HAS_TRAIT(user, TRAIT_INCAPACITATED)) \
|| (extra_checks && !extra_checks.Invoke()) \
)
. = FALSE
break
for(var/t in targets)
var/atom/target = t
if(
(QDELETED(target)) \
|| (!(timed_action_flags & IGNORE_TARGET_LOC_CHANGE) && originalloc[target] != target.loc) \
)
. = FALSE
break
if(!.) // In case the for-loop found a reason to break out of the while.
break
if(!QDELETED(progbar))
progbar.end_progress()
if(interaction_key)
LAZYREMOVE(user.do_afters, interaction_key)
/proc/is_species(A, species_datum)
. = FALSE
if(ishuman(A))
var/mob/living/carbon/human/H = A
if(H.dna && istype(H.dna.species, species_datum))
. = TRUE
/// Returns if the given target is a human. Like, a REAL human.
/// Not a moth, not a felinid (which are human subtypes), but a human.
/proc/ishumanbasic(target)
if (!ishuman(target))
return FALSE
var/mob/living/carbon/human/human_target = target
return human_target.dna?.species?.type == /datum/species/human
/proc/spawn_atom_to_turf(spawn_type, target, amount, admin_spawn=FALSE, list/extra_args)
var/turf/T = get_turf(target)
if(!T)
CRASH("attempt to spawn atom type: [spawn_type] in nullspace")
var/list/new_args = list(T)
if(extra_args)
new_args += extra_args
var/atom/X
for(var/j in 1 to amount)
X = new spawn_type(arglist(new_args))
if (admin_spawn)
X.flags_1 |= ADMIN_SPAWNED_1
return X //return the last mob spawned
/proc/spawn_and_random_walk(spawn_type, target, amount, walk_chance=100, max_walk=3, always_max_walk=FALSE, admin_spawn=FALSE)
var/turf/T = get_turf(target)
var/step_count = 0
if(!T)
CRASH("attempt to spawn atom type: [spawn_type] in nullspace")
var/list/spawned_mobs = new(amount)
for(var/j in 1 to amount)
var/atom/movable/X
if (istype(spawn_type, /list))
var/mob_type = pick(spawn_type)
X = new mob_type(T)
else
X = new spawn_type(T)
if (admin_spawn)
X.flags_1 |= ADMIN_SPAWNED_1
spawned_mobs[j] = X
if(always_max_walk || prob(walk_chance))
if(always_max_walk)
step_count = max_walk
else
step_count = rand(1, max_walk)
for(var/i in 1 to step_count)
step(X, pick(NORTH, SOUTH, EAST, WEST))
return spawned_mobs
// Displays a message in deadchat, sent by source. source is not linkified, message is, to avoid stuff like character names to be linkified.
// Automatically gives the class deadsay to the whole message (message + source)
/proc/deadchat_broadcast(message, source=null, mob/follow_target=null, turf/turf_target=null, speaker_key=null, message_type=DEADCHAT_REGULAR, admin_only=FALSE)
message = span_deadsay("[source][span_linkify(message)]")
for(var/mob/M in GLOB.player_list)
var/chat_toggles = TOGGLES_DEFAULT_CHAT
var/toggles = TOGGLES_DEFAULT
var/list/ignoring
if(M.client?.prefs)
var/datum/preferences/prefs = M.client?.prefs
chat_toggles = prefs.chat_toggles
toggles = prefs.toggles
ignoring = prefs.ignoring
if(admin_only)
if (!M.client?.holder)
return
else
message += span_deadsay(" (This is viewable to admins only).")
var/override = FALSE
if(M.client?.holder && (chat_toggles & CHAT_DEAD))
override = TRUE
if(HAS_TRAIT(M, TRAIT_SIXTHSENSE) && message_type == DEADCHAT_REGULAR)
override = TRUE
if(SSticker.current_state == GAME_STATE_FINISHED)
override = TRUE
if(isnewplayer(M) && !override)
continue
if(M.stat != DEAD && !override)
continue
if(speaker_key && (speaker_key in ignoring))
continue
switch(message_type)
if(DEADCHAT_DEATHRATTLE)
if(toggles & DISABLE_DEATHRATTLE)
continue
if(DEADCHAT_ARRIVALRATTLE)
if(toggles & DISABLE_ARRIVALRATTLE)
continue
if(DEADCHAT_LAWCHANGE)
if(!(chat_toggles & CHAT_GHOSTLAWS))
continue
if(DEADCHAT_LOGIN_LOGOUT)
if(!(chat_toggles & CHAT_LOGIN_LOGOUT))
continue
if(isobserver(M))
var/rendered_message = message
if(follow_target)
var/F
if(turf_target)
F = FOLLOW_OR_TURF_LINK(M, follow_target, turf_target)
else
F = FOLLOW_LINK(M, follow_target)
rendered_message = "[F] [message]"
else if(turf_target)
var/turf_link = TURF_LINK(M, turf_target)
rendered_message = "[turf_link] [message]"
to_chat(M, rendered_message, avoid_highlighting = speaker_key == M.key)
else
to_chat(M, message, avoid_highlighting = speaker_key == M.key)
//Used in chemical_mob_spawn. Generates a random mob based on a given gold_core_spawnable value.
/proc/create_random_mob(spawn_location, mob_class = HOSTILE_SPAWN)
var/static/list/mob_spawn_meancritters = list() // list of possible hostile mobs
var/static/list/mob_spawn_nicecritters = list() // and possible friendly mobs
if(mob_spawn_meancritters.len <= 0 || mob_spawn_nicecritters.len <= 0)
for(var/T in typesof(/mob/living/simple_animal))
var/mob/living/simple_animal/SA = T
switch(initial(SA.gold_core_spawnable))
if(HOSTILE_SPAWN)
mob_spawn_meancritters += T
if(FRIENDLY_SPAWN)
mob_spawn_nicecritters += T
for(var/mob/living/basic/basic_mob as anything in typesof(/mob/living/basic))
switch(initial(basic_mob.gold_core_spawnable))
if(HOSTILE_SPAWN)
mob_spawn_meancritters += basic_mob
if(FRIENDLY_SPAWN)
mob_spawn_nicecritters += basic_mob
var/chosen
if(mob_class == FRIENDLY_SPAWN)
chosen = pick(mob_spawn_nicecritters)
else
chosen = pick(mob_spawn_meancritters)
var/mob/living/spawned_mob = new chosen(spawn_location)
return spawned_mob
/proc/passtable_on(target, source)
var/mob/living/L = target
if (!HAS_TRAIT(L, TRAIT_PASSTABLE) && L.pass_flags & PASSTABLE)
ADD_TRAIT(L, TRAIT_PASSTABLE, INNATE_TRAIT)
ADD_TRAIT(L, TRAIT_PASSTABLE, source)
L.pass_flags |= PASSTABLE
/proc/passtable_off(target, source)
var/mob/living/L = target
REMOVE_TRAIT(L, TRAIT_PASSTABLE, source)
if(!HAS_TRAIT(L, TRAIT_PASSTABLE))
L.pass_flags &= ~PASSTABLE
/proc/dance_rotate(atom/movable/AM, datum/callback/callperrotate, set_original_dir=FALSE)
set waitfor = FALSE
var/originaldir = AM.dir
for(var/i in list(NORTH,SOUTH,EAST,WEST,EAST,SOUTH,NORTH,SOUTH,EAST,WEST,EAST,SOUTH))
if(!AM)
return
AM.setDir(i)
callperrotate?.Invoke()
sleep(1)
if(set_original_dir)
AM.setDir(originaldir)
///////////////////////
///Silicon Mob Procs///
///////////////////////
//Returns a list of unslaved cyborgs
/proc/active_free_borgs()
. = list()
for(var/mob/living/silicon/robot/borg in GLOB.silicon_mobs)
if(borg.connected_ai || borg.shell)
continue
if(borg.stat == DEAD)
continue
if(borg.emagged || borg.scrambledcodes)
continue
. += borg
//Returns a list of AI's
/proc/active_ais(check_mind=FALSE, z = null)
. = list()
for(var/mob/living/silicon/ai/ai as anything in GLOB.ai_list)
if(ai.stat == DEAD)
continue
if(ai.control_disabled)
continue
if(check_mind)
if(!ai.mind)
continue
if(z && !(z == ai.z) && (!is_station_level(z) || !is_station_level(ai.z))) //if a Z level was specified, AND the AI is not on the same level, AND either is off the station...
continue
. += ai
//Find an active ai with the least borgs. VERBOSE PROCNAME HUH!
/proc/select_active_ai_with_fewest_borgs(z)
var/mob/living/silicon/ai/selected
var/list/active = active_ais(FALSE, z)
for(var/mob/living/silicon/ai/A in active)
if(!selected || (selected.connected_robots.len > A.connected_robots.len))
selected = A
return selected
/proc/select_active_free_borg(mob/user)
var/list/borgs = active_free_borgs()
if(borgs.len)
if(user)
. = input(user,"Unshackled cyborg signals detected:", "Cyborg Selection", borgs[1]) in sort_list(borgs)
else
. = pick(borgs)
return .
/proc/select_active_ai(mob/user, z = null)
var/list/ais = active_ais(FALSE, z)
if(ais.len)
if(user)
. = input(user,"AI signals detected:", "AI Selection", ais[1]) in sort_list(ais)
else
. = pick(ais)
return .
/**
* Used to get the amount of change between two body temperatures
*
* When passed the difference between two temperatures returns the amount of change to temperature to apply.
* The change rate should be kept at a low value tween 0.16 and 0.02 for optimal results.
* vars:
* * temp_diff (required) The differance between two temperatures
* * change_rate (optional)(Default: 0.06) The rate of range multiplyer
*/
/proc/get_temp_change_amount(temp_diff, change_rate = 0.06)
if(temp_diff < 0)
return -(BODYTEMP_AUTORECOVERY_DIVISOR / 2) * log(1 - (temp_diff * change_rate))
return (BODYTEMP_AUTORECOVERY_DIVISOR / 2) * log(1 + (temp_diff * change_rate))
#define ISADVANCEDTOOLUSER(mob) (HAS_TRAIT(mob, TRAIT_ADVANCEDTOOLUSER) && !HAS_TRAIT(mob, TRAIT_DISCOORDINATED_TOOL_USER))
#define IS_IN_STASIS(mob) (mob.has_status_effect(/datum/status_effect/grouped/stasis))
/// Gets the client of the mob, allowing for mocking of the client.
/// You only need to use this if you know you're going to be mocking clients somewhere else.
#define GET_CLIENT(mob) (##mob.client || ##mob.mock_client)
///Orders mobs by type then by name. Accepts optional arg to sort a custom list, otherwise copies GLOB.mob_list.
/proc/sort_mobs()
var/list/moblist = list()
var/list/sortmob = sort_names(GLOB.mob_list)
for(var/mob/living/silicon/ai/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/camera/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/silicon/pai/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/silicon/robot/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/carbon/human/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/brain/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/carbon/alien/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/dead/observer/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/dead/new_player/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/simple_animal/slime/mob_to_sort in sortmob)
moblist += mob_to_sort
for(var/mob/living/simple_animal/mob_to_sort in sortmob)
// We've already added slimes.
if(isslime(mob_to_sort))
continue
moblist += mob_to_sort
for(var/mob/living/basic/mob_to_sort in sortmob)
moblist += mob_to_sort
return moblist
///returns a mob type controlled by a specified ckey
/proc/get_mob_by_ckey(key)
if(!key)
return
var/list/mobs = sort_mobs()
for(var/mob/mob in mobs)
if(mob.ckey == key)
return mob
///Return a string for the specified body zone. Should be used for parsing non-instantiated bodyparts, otherwise use [/obj/item/bodypart/var/plaintext_zone]
/proc/parse_zone(zone)
switch(zone)
if(BODY_ZONE_CHEST)
return "chest"
if(BODY_ZONE_HEAD)
return "head"
if(BODY_ZONE_PRECISE_R_HAND)
return "right hand"
if(BODY_ZONE_PRECISE_L_HAND)
return "left hand"
if(BODY_ZONE_L_ARM)
return "left arm"
if(BODY_ZONE_R_ARM)
return "right arm"
if(BODY_ZONE_L_LEG)
return "left leg"
if(BODY_ZONE_R_LEG)
return "right leg"
if(BODY_ZONE_PRECISE_L_FOOT)
return "left foot"
if(BODY_ZONE_PRECISE_R_FOOT)
return "right foot"
if(BODY_ZONE_PRECISE_GROIN)
return "groin"
else
return zone
///Takes a zone and returns it's "parent" zone, if it has one.
/proc/deprecise_zone(precise_zone)
switch(precise_zone)
if(BODY_ZONE_PRECISE_GROIN)
return BODY_ZONE_CHEST
if(BODY_ZONE_PRECISE_EYES)
return BODY_ZONE_HEAD
if(BODY_ZONE_PRECISE_R_HAND)
return BODY_ZONE_R_ARM
if(BODY_ZONE_PRECISE_L_HAND)
return BODY_ZONE_L_ARM
if(BODY_ZONE_PRECISE_L_FOOT)
return BODY_ZONE_L_LEG
if(BODY_ZONE_PRECISE_R_FOOT)
return BODY_ZONE_R_LEG
else
return precise_zone
///Returns the direction that the initiator and the target are facing
/proc/check_target_facings(mob/living/initiator, mob/living/target)
/*This can be used to add additional effects on interactions between mobs depending on how the mobs are facing each other, such as adding a crit damage to blows to the back of a guy's head.
Given how click code currently works (Nov '13), the initiating mob will be facing the target mob most of the time
That said, this proc should not be used if the change facing proc of the click code is overridden at the same time*/
if(!isliving(target) || target.body_position == LYING_DOWN)
//Make sure we are not doing this for things that can't have a logical direction to the players given that the target would be on their side
return FALSE
if(initiator.dir == target.dir) //mobs are facing the same direction
return FACING_SAME_DIR
if(is_source_facing_target(initiator,target) && is_source_facing_target(target,initiator)) //mobs are facing each other
return FACING_EACHOTHER
if(initiator.dir + 2 == target.dir || initiator.dir - 2 == target.dir || initiator.dir + 6 == target.dir || initiator.dir - 6 == target.dir) //Initating mob is looking at the target, while the target mob is looking in a direction perpendicular to the 1st
return FACING_INIT_FACING_TARGET_TARGET_FACING_PERPENDICULAR
///Returns the occupant mob or brain from a specified input
/proc/get_mob_or_brainmob(occupant)
var/mob/living/mob_occupant
if(isliving(occupant))
mob_occupant = occupant
else if(isbodypart(occupant))
var/obj/item/bodypart/head/head = occupant
mob_occupant = head.brainmob
else if(isorgan(occupant))
var/obj/item/organ/internal/brain/brain = occupant
mob_occupant = brain.brainmob
return mob_occupant
///Generalised helper proc for letting mobs rename themselves. Used to be clname() and ainame()
/mob/proc/apply_pref_name(preference_type, client/requesting_client)
if(!requesting_client)
requesting_client = client
var/oldname = real_name
var/newname
var/loop = 1
var/safety = 0
var/random = CONFIG_GET(flag/force_random_names) || (requesting_client ? is_banned_from(requesting_client.ckey, "Appearance") : FALSE)
while(loop && safety < 5)
if(!safety && !random)
newname = requesting_client?.prefs?.read_preference(preference_type)
else
var/datum/preference/preference = GLOB.preference_entries[preference_type]
newname = preference.create_informed_default_value(requesting_client.prefs)
for(var/mob/living/checked_mob in GLOB.player_list)
if(checked_mob == src)
continue
if(!newname || checked_mob.real_name == newname)
newname = null
loop++ // name is already taken so we roll again
break
loop--
safety++
if(newname)
fully_replace_character_name(oldname, newname)
return TRUE
return FALSE
///Returns the amount of currently living players
/proc/living_player_count()
var/living_player_count = 0
for(var/mob in GLOB.player_list)
if(mob in GLOB.alive_mob_list)
living_player_count += 1
return living_player_count
GLOBAL_DATUM_INIT(dview_mob, /mob/dview, new)
///Version of view() which ignores darkness, because BYOND doesn't have it (I actually suggested it but it was tagged redundant, BUT HEARERS IS A T- /rant).
/proc/dview(range = world.view, center, invis_flags = 0)
if(!center)
return
GLOB.dview_mob.loc = center
GLOB.dview_mob.set_invis_see(invis_flags)
. = view(range, GLOB.dview_mob)
GLOB.dview_mob.loc = null
/mob/dview
name = "INTERNAL DVIEW MOB"
invisibility = 101
density = FALSE
see_in_dark = 1e6
move_resist = INFINITY
var/ready_to_die = FALSE
/mob/dview/Initialize(mapload) //Properly prevents this mob from gaining huds or joining any global lists
SHOULD_CALL_PARENT(FALSE)
if(flags_1 & INITIALIZED_1)
stack_trace("Warning: [src]([type]) initialized multiple times!")
flags_1 |= INITIALIZED_1
return INITIALIZE_HINT_NORMAL
/mob/dview/Destroy(force = FALSE)
if(!ready_to_die)
stack_trace("ALRIGHT WHICH FUCKER TRIED TO DELETE *MY* DVIEW?")
if (!force)
return QDEL_HINT_LETMELIVE
log_world("EVACUATE THE SHITCODE IS TRYING TO STEAL MUH JOBS")
GLOB.dview_mob = new
return ..()
#define FOR_DVIEW(type, range, center, invis_flags) \
GLOB.dview_mob.loc = center; \
GLOB.dview_mob.set_invis_see(invis_flags); \
for(type in view(range, GLOB.dview_mob))
#define FOR_DVIEW_END GLOB.dview_mob.loc = null
///Makes a call in the context of a different usr. Use sparingly
/world/proc/push_usr(mob/user_mob, datum/callback/invoked_callback, ...)
var/temp = usr
usr = user_mob
if (length(args) > 2)
. = invoked_callback.Invoke(arglist(args.Copy(3)))
else
. = invoked_callback.Invoke()
usr = temp
#undef FACING_SAME_DIR
#undef FACING_EACHOTHER
#undef FACING_INIT_FACING_TARGET_TARGET_FACING_PERPENDICULAR
Reference in New Issue View Git Blame Copy Permalink