(global)

Var Details

Debugger

StonedMC

Designed to properly split up a given tick among subsystems Note: if you read parts of this code and think "why is it doing it that way" Odds are, there is a reason

Failsafe

Failsafe

Pretty much pokes the MC to make sure it's still alive.

SSacid

The subsystem used to tick /datum/component/acid instances.

SSai_behaviors

The subsystem used to tick /datum/ai_behavior instances. Handling the individual actions an AI can take like punching someone in the fucking NUTS

SSai_controllers

The subsystem used to tick /datum/ai_controllers instances. Handling the re-checking of plans.

SSai_movement

The subsystem used to tick /datum/ai_movement instances. Handling the movement of individual AI instances

SSambience

The subsystem used to play ambience to users every now and then, makes them real excited.

SSasset_loading

Allows us to lazyload asset datums Anything inserted here will fully load if directly gotten So this just serves to remove the requirement to load assets fully during init

SSaura_healing

The subsystem used to tick /datum/component/aura_healing instances.

SSban_cache

Subsystem that batches a ban cache list for clients on initialize This way we don't need to do ban checks in series later in the code

SSclock_component

The subsystem used to tick /datum/component/acid instances.

SSearly_assets

Initializes any assets that need to be loaded ASAP. This houses preference menu assets, since they can be loaded at any time, most dangerously before the atoms SS initializes. Thus, we want it to fail consistently in CI as if it would've if a player opened it up early.

SSeigenstates

Subsystem used to teleport people to a linked web of itterative entries. If one entry is deleted, the 2 around it will forge a link instead.

SSfluids

A subsystem that processes the propagation and effects of a particular fluid.

Both fluid spread and effect processing are handled through a carousel system. Fluids being spread and fluids being processed are organized into buckets. Each fresh (non-resumed) fire one bucket of each is selected to be processed. These selected buckets are then fully processed. The next fresh fire selects the next bucket in each set for processing. If this would walk off the end of a carousel list we wrap back to the first element. This effectively makes each set a circular list, hence a carousel.

SSfoam

The subsystem responsible for processing foam propagation and effects.

SSid_access

Non-processing subsystem that holds various procs and data structures to manage ID cards, trims and access.

SSinit_profiler

Subsystem exists so we can separately log init time costs from the costs of general operation Hopefully this makes sorting out what causes problems when easier

SSlag_switch

The subsystem for controlling drastic performance enhancements aimed at reducing server load for a smoother albeit slightly duller gaming experience

SSlibrary

Manages library data, loading bookselves, etc

SSmouse_entered

Defers MouseEntered inputs to only apply to the most recently hovered over atom in the tick

SSmove_manager

Acts as a namespace for movement packet/type related procs

Exists to provide an in code implementation of movement looping Replaces things like walk() or walk_to(), among others

Because we're doing things in engine, we have a lot more control over how different operations are performed We also get more say in when things happen, so we can subject movements to the whims of the master controller Rather then using a fuck ton of cpu just moving mobs or meteors

The goal is to keep the loops themselves reasonably barebone, and implement more advanced behavior and control via the signals

This may be bypassed in cases where snowflakes are nessesary, or where performance is important. S not a hard and fast thing

Every atom can have a movement packet, which contains information and behavior about currently active loops, and queuing info Loops control how movement actually happens. So there's a "move in this direction" loop, a "move randomly" loop

You can find the logic for this control in this file

Specifics of how different loops operate can be found in the movement_types.dm file, alongside the add to loop helper procs that use them

SSpai

We get our awareness updated by the important recursive contents stuff, here we remove our membership We get our awareness updated by the important recursive contents stuff, here we remove our membership

SSpathfinder

Queues and manages JPS pathfinding steps

SSpoints_of_interest

Subsystem for managing all POIs.

SSsinguloprocess

Very rare subsystem, provides any active singularities with the timings and seclusion they need to succeed

SSsmoke

The subsystem responsible for processing smoke propagation and effects.

SSspatial_grid

a gamewide grid of spatial_grid_cell datums, each "covering" SPATIAL_GRID_CELLSIZE ^ 2 turfs. each spatial_grid_cell datum stores information about what is inside its covered area, so that searches through that area dont have to literally search through all turfs themselves to know what is within it since view() calls are expensive, and so is iterating through stuff you dont want. this allows you to only go through lists of what you want very cheaply.

you can also register to objects entering and leaving a spatial cell, this allows you to do things like stay idle until a player enters, so you wont have to use expensive view() calls or iteratite over the global list of players and call get_dist() on every one. which is fineish for a few things, but is k * n operations for k objects iterating through n players.

currently this system is only designed for searching for relatively uncommon things, small subsets of /atom/movable. dont add stupid shit to the cells please, keep the information that the cells store to things that need to be searched for often

The system currently implements two different "classes" of spatial type

The first exists to support important_recursive_contents. So if a client is inside a locker and the locker crosses a boundary, you'll still get a signal from the spatial grid. These types are SPATIAL_GRID_CONTENTS_TYPE_HEARING and SPATIAL_GRID_CONTENTS_TYPE_CLIENTS

The second pattern is more paired down, and supports more wide use. Rather then the object and anything the object is in being sensitive, it's limited to just the object itself Currently only SPATIAL_GRID_CONTENTS_TYPE_ATMOS uses this pattern. This is because it's far more common, and so worth optimizing

SSspeech_controller

the next unallocated /mob/oranges_ear that we try to allocate to assigned_atom's turf the next atom in atoms_that_need_ears an ear assigned to it the turf loc of the current assigned_atom. turfs are used to track oranges_ears already assigned to one location so we dont allocate more than one because allocating more than one oranges_ear to a given loc wastes view iterations verb_manager subsystem just for handling say's

SStgui

tgui subsystem

Contains all tgui state and subsystem code.

SStimer

Handles creation, callbacks, and destruction of timed events.

It is important to understand the buckets used in the timer subsystem are just a series of doubly-linked lists. The object at a given index in bucket_list is a /datum/timedevent, the head of a list, which has prev and next references for the respective elements in that bucket's list.

SSverb_manager

SSverb_manager, a subsystem that runs every tick and runs through its entire queue without yielding like SSinput. this exists because of how the byond tick works and where user inputted verbs are put within it.

see TICK_ORDER.md for more info on how the byond tick is structured.

The way the MC allots its time is via TICK_LIMIT_RUNNING, it simply subtracts the cost of SendMaps (MAPTICK_LAST_INTERNAL_TICK_USAGE) plus TICK_BYOND_RESERVE from the tick and uses up to that amount of time (minus the percentage of the tick used by the time it executes subsystems) on subsystems running cool things like atmospherics or Life or SSInput or whatever.

Without this subsystem, verbs are likely to cause overtime if the MC uses all of the time it has alloted for itself in the tick, and SendMaps uses as much as its expected to, and an expensive verb ends up executing that tick. This is because the MC is completely blind to the cost of verbs, it can't account for it at all. The only chance for verbs to not cause overtime in a tick where the MC used as much of the tick as it alloted itself and where SendMaps costed as much as it was expected to is if the verb(s) take less than TICK_BYOND_RESERVE percent of the tick, which isnt much. Not to mention if SendMaps takes more than 30% of the tick and the MC forces itself to take at least 70% of the normal tick duration which causes ticks to naturally overrun even in the absence of verbs.

With this subsystem, the MC can account for the cost of verbs and thus stop major overruns of ticks. This means that the most important subsystems like SSinput can start at the same time they were supposed to, leading to a smoother experience for the player since ticks arent riddled with minor hangs over and over again.

SSwardrobe

This subsystem strives to make loading large amounts of select objects as smooth at execution as possible It preloads a set of types to store, and caches them until requested Doesn't catch everything mind, this is intentional. There's many types that expect to either A: Not sit in a list for 2 hours, or B: have extra context passed into them, or for their parent to be their location You should absolutely not spam this system, it will break things in new and wonderful ways S close enough for government work though. Fuck you goonstation

SSwiremod_composite

This subsystem is to handle creating and storing composite templates that are used to create composite datatypes for integrated circuits

See: https://en.wikipedia.org/wiki/Composite_data_type

atlas

A massive nested associative list that tracks type instances, set by the below macros.

atmospherics

Contains all atmospheric machinery, only used if DEBUG_MAPS is defined.

cable_list

Is a real global for speed

csrfz_check

"Can safely remove from zone"

gzn_check

"Get zone neighbors"

ipc_chassis_options

Global list of player-friendly name to iconstate prefix.

neighbor_typecache

Typecache of all objects that we seek out to apply a neighbor stripe overlay

Proc Details

Atan2

The 2-argument arctangent of x and y

GUID

returns a GUID like identifier (using a mostly made up record format) guids are not on their own suitable for access or security tokens, as most of their bits are predictable. (But may make a nice salt to one)

GenerateRoundAsteroid

Generates a circular asteroid.

GetBestWeapon

Returns either the best weapon from the given choices or null if held weapons are better

Gibberish

Turn text into complete gibberish!

text is the inputted message, replace_characters will cause original letters to be replaced and chance are the odds that a character gets modified.

HandleUserlessProcCall

Handles a userless proccall, used by circuits.

Arguments:

• user - a string used to identify the user
• target - the target to proccall on
• proc - the proc to call
• arguments - any arguments

HandleUserlessSDQL

Handles a userless sdql, used by circuits and tgs.

Arguments:

• user - a string used to identify the user
• query_text - the query text

HeapPathWeightCompare

TODO: Macro this to reduce proc overhead

Interpolate

Returns a linear interpolation from a to b according to weight. weight 0 is a, weight 1 is b, weight 0.5 is half-way between the two.

IsEdible

returns if something can be consumed, drink or food

Mean

Returns the mean of either a list or variadic arguments: Mean(list(1, 2, 3)) = 2 , Mean(1, 2, 3) = 2

REF

\ref behaviour got changed in 512 so this is necesary to replicate old behaviour. If it ever becomes necesary to get a more performant REF(), this lies here in wait #define REF(thing) (thing && istype(thing, /datum) && (thing:datum_flags & DF_USE_TAG) && thing:tag ? "[thing:tag]" : "\ref[thing]")

ReserveTurfsForAsteroidGeneration

Sanitizes a block of turfs to prevent writing over undesired locations

RoundDiagBar

Diagnostic HUDs!

VecMag

Returns the euclidian magnitude of a vector of either a list or variadic arguments: VecMag(list(3, 4)) = 5 , VecMag(3, 4) = 5

VecSquareMag

Returns the euclidian square magnitude of a vector of either a list or variadic arguments: VecSquareMag(list(1, 2, 3)) = 14 , VecSquareMag(1, 2, 3) = 14

WEAKREF

Creates a weakref to the given input. See /datum/weakref's documentation for more information.

WrapAdminProcCall

Wrapper for proccalls where the datum is flagged as vareditted

___TraitAdd

DO NOT USE ___TraitAdd OR ___TraitRemove as a replacement for ADD_TRAIT / REMOVE_TRAIT defines. To be used explicitly for callback.

___TraitRemove

DO NOT USE ___TraitAdd OR ___TraitRemove as a replacement for ADD_TRAIT / REMOVE_TRAIT defines. To be used explicitly for callback.

______qdel_list_wrapper

the underscores are to encourage people not to use this directly.

_addtimer

Create a new timer and insert it in the queue. You should not call this directly, and should instead use the addtimer macro, which includes source information.

Arguments:

• callback the callback to call on timer finish
• wait deciseconds to run the timer for
• flags flags for this timer, see: code__DEFINES\subsystems.dm
• timer_subsystem the subsystem to insert this timer into

_alert_drones

Broadcast a message to all drones in a faction

Arguments:

• msg - The message to send
• dead_can_hear - Boolean that determines if ghosts can hear the message (FALSE by default)
• source - /atom source that created the message
• faction_checked_mob - /mob/living to determine faction matches from
• exact_faction_match - Passed to /mob/proc/faction_check_mob

_pick_list

Allow me to explain for some reason, if pick() is passed arglist(args) directly and args contains only one list it considers it to be a list of lists this means something like _pick(list) would fail need to do this instead

I hate this timeline

_queue_verb

queue a callback for the given verb/verblike proc and any given arguments to the specified verb subsystem, so that they process in the next tick. intended to only work with verbs or verblike procs called directly from client input, use as part of TRY_QUEUE_VERB() and co.

returns TRUE if the queuing was successful, FALSE otherwise.

aas_mass_pda_message

Get an announcement system and call mass_pda_message()

aas_pda_message

Get an announcement system and call pda_message()

aas_pda_message_department

Send an ASS pda message to an entire department

aas_pda_message_name

Send an ASS pda message to a given name

above_neck

Would this zone be above the neck

actionspeed_data_null_check

Checks if a action speed modifier is valid and not missing any data

active_free_borgs

Silicon Mob Procs

add_keybinding

Adds an instanced keybinding to the global tracker

add_verb

handles adding verbs and updating the stat panel browser

pass the verb type path to this instead of adding it directly to verbs so the statpanel can update Arguments:

• target - Who the verb is being added to, client or mob typepath
• verb - typepath to a verb, or a list of verbs, supports lists of lists
• bypass_restricted - Whether or not to bypass client.restricted_mode

admin_pm_href

Returns an adminpm link with the inserted HTML.

adminscrub

Runs STRIP_HTML_SIMPLE and byond's sanitization proc.

alone_in_area

Checks if the mob provided (must_be_alone) is alone in an area

announce_arrival

Send a message in common radio when a player arrives

anyprob

chances are 1:value. anyprob(1) will always return true

assert_sorted

Runtimes if the passed in list is not sorted

assoc_to_keys

Turns an associative list into a flat list of keys

atmos_scan

Outputs a message to the user describing the target's gasmixes.

Gets called by analyzer_act, which in turn is called by tool_act. Also used in other chat-based gas scans.

avoid_assoc_duplicate_keys

takes an input_key, as text, and the list of keys already used, outputting a replacement key in the format of "[input_key] ([number_of_duplicates])" if it finds a duplicate use this for lists of things that might have the same name, like mobs or objects, that you plan on giving to a player as input

baseturfs_string_list

A wrapper for baseturf string lists, to offer support of non list values, and a stack_trace if we have major issues

begin_the_end

Begins the process of ending the round via cult narsie win Consists of later called procs (in order of called):

• [/proc/narsie_end_begin_check()]
• [/proc/narsie_end_second_check()]
• [/proc/narsie_start_destroy_station()]
• [/proc/narsie_apocalypse()]
• [/proc/narsie_last_second_win()]
• [/proc/cult_ending_helper()]

bit_count

counts the number of bits in Byond's 16-bit width field, in constant time and memory!

bitfield_to_list

Converts a bitfield to a list of numbers (or words if a wordlist is provided)

body_zone2cover_flags

For finding out what body parts a body zone covers, the inverse of the below basically

build_exploration_site_ui_data

Helper proc for exploration site listings in ui.

build_medicine_reagents

Just grab every craftable medicine you can think off

calculate_projectile_angle_and_pixel_offsets

Calculates the pixel offsets and angle that a projectile should be launched at.

Arguments:

• source: The thing that the projectile is being shot from.
• target: (Optional) The thing that the projectile is being shot at.
  • If this is not provided the source atom must be a mob with a client.
• modifiers: A list of click parameters used to modify the shot angle.

call_emergency_meeting

If the announcer overrides alert messages, use that message. Summon the crew for an emergency meeting

Teleports the crew to a specified area, and tells everyone (via an announcement) who called the meeting. Should only be used during april fools! Arguments:

• user - Mob who called the meeting
• button_zone - Area where the meeting was called and where everyone will get teleported to

callback_select

Runs a list of callbacks asyncronously, returning only when all have finished

Callbacks can be repeated, to call it multiple times

Arguments:

• list/callbacks the list of callbacks to be called
• list/callback_args the list of lists of arguments to pass into each callback
• savereturns Optionally save and return the list of returned values from each of the callbacks
• resolution The number of byond ticks between each time you check if all callbacks are complete

can_see

Step-towards method of determining whether one atom can see another. Similar to viewers() note: this is a line of sight algorithm, view() does not do any sort of raycasting and cannot be emulated by it accurately

center_image

Center's an image. Requires: The Image The x dimension of the icon file used in the image The y dimension of the icon file used in the image eg: center_image(image_to_center, 32,32) eg2: center_image(image_to_center, 96,96)

chatter_speak

We're going to take a list that dictates the pace of speech, and a sentence fragment to say Then say() that fragment at that pace You can pass in a starting delay to wait before speaking the next sound

cheap_hypotenuse

Calculate the hypotenuse cheaply (this should be in maths.dm)

check_asay_links

Checks a given message to see if any of the words are something we want to treat specially, as detailed below.

There are 3 cases where a word is something we want to act on

1. Admin pings, like @adminckey. Pings the admin in question, text is not clickable
2. Datum refs, like @0x2001169 or @mob_23. Clicking on the link opens up the VV for that datum
3. Ticket refs, like #3. Displays the status and ahelper in the link, clicking on it brings up the ticket panel for it. Returns a list being used as a tuple. Index ASAY_LINK_NEW_MESSAGE_INDEX contains the new message text (with clickable links and such) while index ASAY_LINK_PINGED_ADMINS_INDEX contains a list of pinged admin clients, if there are any.

Arguments:

• msg - the message being scanned

check_target_facings

Returns the direction that the initiator and the target are facing

check_wall_item

Check if there is already a wall item on the turf loc floor_loc = floor tile in front of the wall dir_toward_wall = direction from the floor tile in front of the wall towards the wall check_external = truthy if we should be checking against items coming out of the wall, rather than visually on top of the wall.

chem_splash

The basic chemical bomb proc. Combines a set of reagent holders into one holder and reacts it. If there are any reagents left over it spreads them across the surrounding environment. The maximum volume of the holder is temporarily adjusted to allow for reactions which increase total volume to work at full effectiveness. The maximum volume of the holder is then reset to its original value.

Arguments:

• epicenter: The epicenter of the splash if some of the reagents aren't consumed.
• holder: The holder to combine all of the reagents into. A temporary one is created if this is null.
• [reactants][/list/datum/reagents]: The set of reagent holders to combine.
• extra_heat: Some amount to heat the combined reagents by before reacting them.
• threatscale: A multiplier for the reagent quantities involved.
• adminlog: Whether to alert the admins that this has occured.

circle_range

Returns all atoms present in a circle around the center

circle_range_turfs

Returns a list of turfs around a center based on RANGE_TURFS()

circle_view

Returns all atoms present in a circle around the center but uses view() instead of range() (Currently not used)

circle_view_turfs

Returns a list of turfs around a center based on view()

cmp_bodypart_by_body_part_asc

Orders bodyparts by their body_part value, ascending.

cmp_bodyparts_display_order

Orders bodyparts by how they should be shown to players in a UI

cmp_codex_name

Orders codex entries by name alphabetically

cmp_crafting_req_priority

Sorts crafting recipe requirements before the crafting recipe is inserted into GLOB.crafting_recipes

Prioritises /datum/reagent to ensure reagent requirements are always processed first when crafting. This prevents any reagent_containers from being consumed before the reagents they contain, which can lead to runtimes and item duplication when it happens.

cmp_design_name

Orders designs by name

cmp_fusion_reaction_des

Orders R-UST fusion by priority

cmp_heretic_knowledge

Orders heretic knowledge by priority

cmp_list_length

Orders lists by the size of lists in their contents

cmp_port_order_asc

Orders by integrated circuit weight

cmp_pref_modules

Sort modules by priority

cmp_uplink_category_desc

Orders by uplink category weight

cmp_zm_render_order

Sort by plane, then by layer. Approximately BYOND rendering order.

color_list_to_string

Turns a list such as ("#FFFFFF", #00FFFF) into a color string of "#FFFFFF#00FFFF"

color_string_to_list

Turns a color string such as "#FFFFFF#00FFFF" into a list of ("#FFFFFF", #00FFFF)

color_to_full_rgba_matrix

Converts RGB shorthands into RGBA matrices complete of constants rows (ergo a 20 keys list in byond). if return_identity_on_fail is true, stack_trace is called instead of CRASH, and an identity is returned.

colorize_string

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

compare_list

compare two lists, returns TRUE if they are the same

considered_afk

Checks if a player is considered AFK

considered_alive

Returns true if the mob that a player is controlling is alive

considered_exiled

Exiled check

Checks if the current body of the mind has an exile implant and is currently in an away mission. Returns FALSE if any of those conditions aren't met.

construct_phobia_regex

Creates a regular expression to match against the given phobia Capture group 2 = the scary word Capture group 3 = an optional suffix on the scary word

convert_integer_to_words

Takes an integer up to 999,999,999 and returns it in words. Works with negative numbers and 0.

Arguments:

• number - Integer up to 999,999,999 to convert.
• capitalise - Whether the number it returns should be capitalised or not, e.g. "Eighty Million" vs. "eighty million".

convert_ph_to_readable_color

Converts the pH into a tgui readable color - i.e. white and black text is readable over it. This is NOT the colourwheel for pHes however.

count_by_type

return the amount of items of the same type inside a list

create_mafia_game

Creates the global datum for playing mafia games, destroys the last if that's required and returns the new.

create_strippable_list

Creates an assoc list of keys to /datum/strippable_item

cult_ending_helper

Selects cinematic to play as part of the cult end depending on the outcome then ends the round afterward called either when narsie eats everyone, or when [/proc/begin_the_end()] reaches it's conclusion

cut_relative_direction

Takes a screen_loc string and cut out any directions like NORTH or SOUTH

debug_variable

Get displayed variable in VV variable list

deep_compare_list

Compares 2 lists, returns TRUE if they are the same

deep_copy_list

Copies a list, and all lists inside it recusively Does not copy any other reference type

default_ui_state

The sane defaults for a UI such as a computer or a machine.

delete_all_SS_and_recreate_master

Delete all existing SS to basically start over

deltimer

Delete a timer

Arguments:

• id a timerid or a /datum/timedevent

deprecise_zone

Takes a zone and returns it's "parent" zone, if it has one.

dice_outcome_map

Certified LummoxJR code, this returns an array which is a map of outcomes to roll [index] value.

dice_probability

Returns a number between 0 and 100 to roll the desired value when rolling the given dice.

display_energy

Format an energy value measured in Power Cell units.

display_joules

Format an energy value in J, kJ, MJ, or GJ. 1W = 1J/s.

display_power

Format a power value in W, kW, MW, or GW.

do_after

Timed action involving one mob user. Target is optional, defaulting to user.

Checks that user does not move, change hands, get stunned, etc. for the given time. 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.

do_after_mob

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.

do_chem_smoke

Helper to quickly create a cloud of reagent smoke

do_smoke

A helper proc used to spawn small puffs of smoke.

Arguments:

• range: The amount of smoke to produce as number of steps from origin covered.
• amount: The amount of smoke to produce as the total desired coverage area. Autofilled from the range arg if not set.
• location: Where to produce the smoke cloud.
• smoke_type: The smoke typepath to spawn.

dview

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).

dyn_explosion

Using default dyn_ex scale:

100 explosion power is a (5, 10, 20) explosion. 75 explosion power is a (4, 8, 17) explosion. 50 explosion power is a (3, 7, 14) explosion. 25 explosion power is a (2, 5, 10) explosion. 10 explosion power is a (1, 3, 6) explosion. 5 explosion power is a (0, 1, 3) explosion. 1 explosion power is a (0, 0, 1) explosion.

Arguments:

• epicenter: Turf the explosion is centered at.
• power - Dyn explosion power. See reference above.
• flame_range: Flame range. Equal to the equivalent of the light impact range multiplied by this value.
• flash_range: The range at which the explosion flashes people. Equal to the equivalent of the light impact range multiplied by this value.
• adminlog: Whether to log the explosion/report it to the administration.
• ignorecap: Whether to ignore the relevant bombcap. Defaults to FALSE.
• flame_range: The range at which the explosion should produce hotspots.
• silent: Whether to generate/execute sound effects.
• smoke: Whether to generate a smoke cloud provided the explosion is powerful enough to warrant it.
• explosion_cause: [Optional] The atom that caused the explosion, when different to the origin. Used for logging.

ellipsis

Inline script for an animated ellipsis

emissive_appearance

Produces a mutable appearance glued to the EMISSIVE_PLANE dyed to be the EMISSIVE_COLOR.

emissive_blocker

Produces a mutable appearance glued to the EMISSIVE_PLANE dyed to be the EM_BLOCK_COLOR.

encode_text_and_nulls

Returns a copy of a list where text values (except assoc-keys and string representations of lua-only values) are wrapped in quotes and existing quote marks are escaped, and nulls are replaced with the string "null"

end_cooldown

Callback called by a timer to end an associative-list-indexed cooldown.

Arguments:

• source - datum storing the cooldown
• index - string index storing the cooldown on the cooldowns associative list

This sends a signal reporting the cooldown end.

english_list

Returns a list in plain english as a string

expand_three_digit_color

Given a 3 character color (no hash), converts it into #RRGGBB (with hash)

expand_weights

Takes a weighted list (see above) and expands it into raw entries This eats more memory, but saves time when actually picking from it

explosion

Makes a given atom explode.

Arguments:

• origin: The atom that's exploding.
• devastation_range: The range at which the effects of the explosion are at their strongest.
• heavy_impact_range: The range at which the effects of the explosion are relatively severe.
• light_impact_range: The range at which the effects of the explosion are relatively weak.
• flash_range: The range at which the explosion flashes people.
• adminlog: Whether to log the explosion/report it to the administration.
• ignorecap: Whether to ignore the relevant bombcap. Defaults to FALSE.
• flame_range: The range at which the explosion should produce hotspots.
• silent: Whether to generate/execute sound effects.
• smoke: Whether to generate a smoke cloud provided the explosion is powerful enough to warrant it.
• explosion_cause: [Optional] The atom that caused the explosion, when different to the origin. Used for logging.

filter_gas

Just transfer it, who really cares at a scale this small.

find_obstruction_free_location

Find an obstruction free turf that's within the range of the center. Can also condition on if it is of a certain area type.

find_reagent

Returns reagent datum from typepath

findname

Find if the message has the real name of any user mob in the mob_list

firing_squad

firing_squad is a proc for the :B:erforate smite to shoot each individual bullet at them, so that we can add actual delays without sleep() nonsense

Hilariously, if you drag someone away mid smite, the bullets will still chase after them from the original spot, possibly hitting other people. Too funny to fix imo

Arguments:

• target- guy we're shooting obviously
• source_turf- where the bullet begins, preferably on a turf next to the target
• body_zone- which bodypart we're aiming for, if there is one there
• damage- the damage we're assigning to the bullet, since we don't care about the base one

first_day_of_month

Returns the first day of the given year and month in number format, from 1 (monday) - 7 (sunday).

flash_color

Flash a color on the client

flatten_list

Flattens a keyed list into a list of it's contents

flick_overlay

Add an image to a list of clients and calls a proc to remove it after a duration

flick_overlay_static

Flickers an overlay on an atom

flick_overlay_view

wrapper for flick_overlay(), flicks to everyone who can see the target atom

flop_animation

This animation should be applied to actual parent atom instead of vc_object.

format_frequency

Format frequency by moving the decimal.

format_text

Properly format a string of text by using replacetext()

gas_mixture_parser

• A simple rudimentary gasmix to information list converter. Can be used for UIs.
• Args:
• • gasmix: /datum/gas_mixture
• • name: String used to name the list, optional.
• Returns: A list parsed_gasmixes with the following structure:
• • parsed_gasmixes Value: Assoc List Desc: The thing we return
• -- Key: name Value: String Desc: Gasmix Name
• -- Key: temperature Value: Number Desc: Temperature in kelvins
• -- Key: volume Value: Number Desc: Volume in liters
• -- Key: pressure Value: Number Desc: Pressure in kPa
• -- Key: ref Value: String Desc: The reference for the instantiated gasmix.
• -- Key: gases Value: Numbered list Desc: List of gasses in our gasmix
• --- Key: 1 Value: String Desc: gas id var from the gas
• --- Key: 2 Value: String Desc: Human readable gas name.
• --- Key: 3 Value: Number Desc: Mol amount of the gas.
• -- Key: gases Value: Numbered list Desc: Assoc list of reactions that occur inside.
• --- Key: 1 Value: String Desc: reaction id var from the gas.
• --- Key: 2 Value: String Desc: Human readable reaction name.
• --- Key: 3 Value: Number Desc: The number associated with the reaction.
• Returned list should always be filled with keys even if value are nulls.

generate_and_hash_rsc_file

generates a filename for a given asset. like generate_asset_name(), except returns the rsc reference and the rsc file hash as well as the asset name (sans extension) used so that certain asset files dont have to be hashed twice

generate_asset_name

Generate a filename for this asset The same asset will always lead to the same asset name (Generated names do not include file extention.)

generate_autowiki_output

When the AUTOWIKI define is enabled, will generate an output file for tools/autowiki/autowiki.js to consume. Autowiki code intentionally still exists even without the define, to ensure developers notice when they break it immediately, rather than until CI or worse, call time. Returns a string of the autowiki output file

generate_bitfields

Turns /datum/bitfield subtypes into a list for use in debugging

generate_chemwiki_line

Generate the big list of reagent based reactions. style='background-color:#FFEE88;'|{{anchor|Synthetic-derived growth factor}}Synthetic-derived growth factor▮

generate_cult_rune_types

Returns an associated list of rune types. [rune.cultist_name] = [typepath]

generate_generator_index

Creates generator__id => type map.

generate_icon_alpha_mask

Helper proc to generate a cutout alpha mask out of an icon.

Why is it a helper if it's so simple?

Because BYOND's documentation is hot garbage and I don't trust anyone to actually figure this out on their own without sinking countless hours into it. Yes, it's that simple, now enjoy.

But why not use filters?

Filters do not allow for masks that are not the exact same on every dir. An example of a need for that can be found in [/proc/generate_left_leg_mask()].

Arguments:

• icon_to_mask - The icon file you want to generate an alpha mask out of.
• icon_state_to_mask - The specific icon_state you want to generate an alpha mask out of.

Returns an /icon that is the alpha mask of the provided icon and icon_state.

generate_items_inside

Creates new items inside an atom based on a list

generate_paperwork

We only send to one fax machine in an area

generate_selectable_species

Generates species available to choose in character setup at roundstart

This proc generates which species are available to pick from in character setup. If there are no available roundstart species, defaults to human.

get

Returns the atom type in the specified loc

getFlatIcon

Only the first argument is required.

get_active_player_count

Get active players who are playing in the round

get_adjacent_areas

Returns a list of all areas that are adjacent to the center atom's area, clear the list of nulls at the end.

get_adjacent_open_areas

Returns a list with all the adjacent areas by getting the adjacent open turfs

get_adjacent_open_turfs

Returns a list with all the adjacent open turfs.

get_airlock_overlay

Overlay cache. Why isn't this just in /obj/machinery/door/airlock? Because its used just a tiny bit in door_assembly.dm Refactored so you don't have to make a null copy of airlock to get to the damn thing Someone, for the love of god, profile this. Is there a reason to cache mutable_appearance if so, why are we JUST doing the airlocks when we can put this in mutable_appearance.dm for everything

get_allowed_instrument_ids

Get all non admin_only instruments as a list of text ids.

get_angle

Calculate the angle between two points and the west|east coordinate

get_area_name

Returns the name of the area the atom is in

get_areas_in_range

Returns a list with the names of the areas around a center at a certain distance Returns the local area if no distance is indicated Returns an empty list if the center is null

get_atom_on_turf

Returns the top-most atom sitting on the turf. For example, using this on a disk, which is in a bag, on a mob, will return the mob because it's on the turf.

Arguments

• something_in_turf - a movable within the turf, somewhere.
• stop_type - optional - stops looking if stop_type is found in the turf, returning that type (if found).

get_bbox_of_atoms

Get a bounding box of a list of atoms.

Arguments:

• atoms - List of atoms. Can accept output of view() and range() procs.

Returns: list(x1, y1, x2, y2)

get_cached_actionspeed_modifier

Grabs a STATIC MODIFIER datum from cache. YOU MUST NEVER EDIT THESE DATUMS, OR IT WILL AFFECT ANYTHING ELSE USING IT TOO!

get_cached_movespeed_modifier

Grabs a STATIC MODIFIER datum from cache. YOU MUST NEVER EDIT THESE DATUMS, OR IT WILL AFFECT ANYTHING ELSE USING IT TOO!

get_cardinal_dir

Get the cardinal direction between two atoms

get_chem_id

Returns reagent datum from reagent name string

get_closest_atom

Returns the closest atom of a specific type in a list from a source

get_consistent_feature_entry

Takes in an accessory list and returns the first entry from that list, ensuring that we dont return SPRITE_ACCESSORY_NONE in the process.

get_ctf_voting_controller

Returns the existing /datum/ctf_voting_controller for the given ID, or makes one

get_dist_euclidean

Returns the distance between two atoms

get_dist_manhattan

Returns the manhattan distance between two atoms. Returns INFINITY if either are not on a turf, for BYOND get_dist() parity.

get_distribution

This is a pretty complicated algorithm, but it's one I'm rather proud of.

This is the function that is responsible for taking the list of preferences, and spitting out what to put them in.

However, it should, wherever possible, prevent solo departments. That means that if there's one medical officer, and one engineering officer, that they should be put onto the same department (either medical or engineering).

The first step is to get the "distribution". This describes how many officers should be in each department, no matter what they are. This is handled in get_distribution. Examples of inputs/outputs are: get_distribution(1, 4) => [1] get_distribution(2, 4) => [2] get_distribution(3, 4) => [3] # If this returned [2, 1], then we'd get a loner. get_distribution(4, 4) => [2, 2] # We have enough to put into a separate group

Once this distribution is received, the next step is to figure out where to put everyone.

If all members have no preference, just make one an unused department (from the departments argument). Then, call ourselves again.

Order the groups from most populated to least.

If the top group has enough officers who actually want that department, then we give it to them. If there are any leftovers (for example, if 3 officers want medical, but we only want 2), then we update those to have no preference instead.

If the top group does NOT have enough officers, then we kill the least popular group by setting them all to have no preference.

Anyone in the most popular group will be removed from the list, and the final tally will be updated. In the case of not having enough officers, this is a no-op, as there won't be any in the most popular group yet.

If there are any candidates left, then we call the algorithm again, but for everyone who hasn't been selected yet. We take the results from that run, and put them in the correct order.

As an example, let's assume we have the following preferences: [engineer, medical, medical, medical, medical, cargo]

The distribution of this is [2, 2, 2], meaning there will be 3 departments chosen and they will have 2 each. We order from most popular to least popular and get:

• medical: 4
• engineer: 1
• cargo: 1

We need 2 to fill the first group. There are enough medical staff to do it. Thus, we take the first 2 medical staff and update the output, making it now: [engineer, medical, medical, ?, ?, cargo].

The remaining two want-to-be-medical officers are now updated to act as no preference. We run the algorithm again. This time, are candidates are [engineer, none, none, cargo]. The distribution of this is [2, 2]. The frequency is:

• engineer: 1
• cargo: 1
• no preference: 2

We need 2 to fill the engineering group, but only have one who wants to do it. We have enough no preferences for it, making our result: [engineer, engineer, none, cargo]. We run the algorithm again, but this time with: [none, cargo]. Frequency is:

• cargo: 1
• no preference: 1 Enough to fill cargo, etc, and we get [cargo, cargo].

These are all then compounded into one list.

In the case that all are no preference, it will pop the last department, and use that. For example, if departments is [engi, medical, cargo], and we have the preferences: [none, none, none]... Then we will just give them all cargo.

One of the most important parts of this algorithm is IT IS DETERMINISTIC. That means that this proc is 100% testable. Instead, to get random results, the preferences and departments are shuffled before the proc is ever called.

get_edge_target_turf

Returns the turf located at the map edge in the specified direction relative to target_atom used for mass driver

get_element_by_var

return first thing in L which has var/varname == value this is typecaste as list/L, but you could actually feed it an atom instead. completely safe to use

get_first_open_turf_in_area

Iterates over all turfs in the target area and returns the first non-dense one

get_flat_existing_human_icon

A simpler version of get_flat_human_icon() that uses an existing human as a base to create the icon. Does not feature caching yet, since I could not think of a good way to cache them without having a possibility of using the cached version when we don't want to, so only use this proc if you just need this flat icon generated once and handle the caching yourself if you need to access that icon multiple times, or refactor this proc to feature caching of icons.

Arguments:

• existing_human - The human we want to get a flat icon out of.
• directions_to_output - The directions of the resulting flat icon, defaults to all cardinal directions.

get_hear

Like view but bypasses luminosity check

get_hearers_in_LOS

Returns a list of movable atoms that are hearing sensitive in view_radius and line of sight to source the majority of the work is passed off to the spatial grid if view_radius > 0 because view() isnt a raycasting algorithm, this does not hold symmetry to it. something in view might not be hearable with this. if you want that use get_hearers_in_view() - however thats significantly more expensive

• view_radius - what radius search circle we are using, worse performance as this increases but not as much as it used to
• source - object at the center of our search area. everything in get_turf(source) is guaranteed to be part of the search area

get_hearers_in_radio_ranges

Returns an associative list-of-lists of radio : hearers

get_hearers_in_view

returns every hearaing movable in view to the turf of source not taking into account lighting useful when you need to maintain always being able to hear something if a sound is emitted from it and you can see it (and youre in range). otherwise this is just a more expensive version of get_hearers_in_LOS()

• view_radius - what radius search circle we are using, worse performance as this increases
• source - object at the center of our search area. everything in get_turf(source) is guaranteed to be part of the search area

get_icon_dmi_path

given an icon object, dmi file path, or atom/image/mutable_appearance, attempts to find and return an associated dmi file path. a weird quirk about dm is that /icon objects represent both compile-time or dynamic icons in the rsc, but stringifying rsc references returns a dmi file path ONLY if that icon represents a completely unchanged dmi file from when the game was compiled. so if the given object is associated with an icon that was in the rsc when the game was compiled, this returns a path. otherwise it returns ""

get_line

Get a list of turfs in a line from starting_atom to ending_atom.

Uses the ultra-fast Bresenham Line-Drawing Algorithm.

get_mob_by_ckey

returns a mob type controlled by a specified ckey

get_mob_by_key

Return the mob type that is being controlled by a ckey

get_mob_or_brainmob

Returns the occupant mob or brain from a specified input

get_nested_locs

Returns a list of all locations (except the area) the movable is within.

get_officer_departments

Returns the distribution of splitting the given security officers into departments. Return value is an assoc list of candidate => SEC_DEPT_*.

get_offset_target_turf

returns turf relative to target_atom offset in dx and dy tiles, bound to map limits

get_oov_turf

Returns a turf that is barely out of view of the target.

get_open_turf_in_dir

Returns the open turf next to the center in a specific direction

get_perceived_radiation_danger

Gets the perceived "danger" of radiation pulse, given the threshold to the target. Returns a RADIATION_DANGER_* define, see code/__DEFINES/radiation.dm

get_pixel_angle

for getting the angle when animating something's pixel_x and pixel_y

get_pixel_distance

Finds the distance between two atoms, in pixels centered = FALSE counts from turf edge to edge centered = TRUE counts from turf center to turf center of course mathematically this is just adding world.icon_size on again

get_policy

Null is the value that will consider angles to match the defender's dir

get_powernet_info_from_source

Save any queued packets Extracts the powernet and cell of the provided power source

get_preferences_in_priority_order

Returns a flat list of preferences in order of their priority

get_radio_icon

Pass in a frequency, get a file name. See chat_icons.dm

get_random_drink

Gets a random drink excluding the blocked type

get_random_food

Get a random food item exluding the blocked ones

get_random_jumpskirt

Returns a random, acceptable jumpskirt typepath

get_random_jumpsuit

Returns a random, acceptable jumpsuit typepath

get_random_perimeter_turf

returns a turf at the outer edge of a given radius

get_random_reagent_id

Returns a random reagent object minus blacklisted reagents

get_random_station_turf

Returns a random turf on the station

get_ranged_target_turf_direct

Get ranged target turf, but with direct targets as opposed to directions

Starts at atom starting_atom and gets the exact angle between starting_atom and target Moves from starting_atom with that angle, Range amount of times, until it stops, bound to map size Arguments:

• starting_atom - Initial Firer / Position
• target - Target to aim towards
• range - Distance of returned target turf from starting_atom
• offset - Angle offset, 180 input would make the returned target turf be in the opposite direction

get_reagent_type_from_product_string

Returns a list of chemical_reaction datums that have the input STRING as a product

get_recipe_from_reagent_product

Takes a type in and returns a list of associated recipes

get_relative_attack_angle

Returns an angle between 0 and 180, where 0 is the attacker is directly infront of the defender, 180 for directly behind.

get_safe_random_station_turf

Returns a random turf on the station, excludes dense turfs (like walls) and areas that have valid_territory set to FALSE

get_selectable_species

Gets a list of all species available to choose in roundstart.

get_sorted_areas

Returns a sorted version of GLOB.areas, by name

get_species_augments

Returns a tree of species > category > slot > item path

get_start_landmark_for

Helper for getting start landmarks.

get_teleport_loc

Returns location. Returns null if no location was found.

get_temp_change_amount

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

get_turf_pixel

Lets the turf this atom's ICON appears to inhabit it takes into account: Pixel_x/y Matrix x/y NOTE: if your atom has non-standard bounds then this proc will handle it, but: if the bounds are even, then there are an even amount of "middle" turfs, the one to the EAST, NORTH, or BOTH is picked this may seem bad, but you're atleast as close to the center of the atom as possible, better than byond's default loc being all the way off) if the bounds are odd, the true middle turf of the atom is returned

get_valid_screen_location

Returns a valid location to place a screen object without overflowing the viewport

• target: The target location as a purely number based screen_loc string "+-left-offset:+-pixel,+-bottom-offset:+-pixel"
• target_offset: The amount we want to offset the target location by. We explictly don't care about direction here, we will try all 4
• view: The view variable of the client we're doing this for. We use this to get the size of the screen

Returns a screen loc representing the valid location

give_admin_popup

Tries to give the target an admin popup. If it fails, will send the error to the passed admin.

goonchem_vortex

Magical move-wooney that happens sometimes.

Simulates a vortex that moves nearby movable atoms towards or away from the turf T. Range also determines the strength of the effect. High values cause nearby objects to be thrown. Arguments:

• T - turf where it happens
• setting_type - does it suck or does it blow?
• range - range.

gradient_text

Make a color a repeating gradient between two colors. Note: This is inaccurate because its a linear transformation, but human eyes do not perceive color this way.

greatest_common_factor

Takes a list of numbers as input, returns the highest value that is cleanly divides them all Note: this implementation is expensive as heck for large numbers, I only use it because most of my usecase Is < 10 ints

honkerblast

Unleashes a honkerblast similar to the honkmech weapon, but with more granular control.

hsv2rgb

Converts a list storing hsva into an rgb color string

htmlrendertext

Perform a whitespace cleanup on the text, similar to what HTML renderers do

This is useful if you want to better predict how text is going to look like when displaying it to a user. HTML renderers collapse multiple whitespaces into one, trims prepending and appending spaces, among other things. This proc attempts to do the same thing. HTML5 defines whitespace pretty much exactly like regex defines the \s group, [ \t\r\n\f].

Arguments:

• t - The text to "render"

icon2base64

Converts an icon to base64. Operates by putting the icon in the iconCache savefile, exporting it as text, and then parsing the base64 from that. (This relies on byond automatically storing icons in savefiles as base64)

icon_element

Display a DM icon in a a browser.

icon_exists

Checks if the given iconstate exists in the given file, caching the result. Setting scream to TRUE will print a stack trace ONCE.

inLineOfSight

Calculate if two atoms are in sight, returns TRUE or FALSE

init_crafting_recipes

Inits the crafting recipe list, sorting crafting recipe requirements in the process.

init_keybindings

Creates and sorts all the keybinding datums

init_subtypes_w_path_keys

Functions like init_subtypes, but uses the subtype's path as a key for easy access

initialize_starting_knowledge

Returns a list of all heretic knowledge TYPEPATHS that have route set to PATH_START.

int_to_words

Takes a 1, 2 or 3 digit number and returns it in words. Don't call this directly, use convert_integer_to_words() instead.

Arguments:

• number - 1, 2 or 3 digit number to convert.
• carried_string - Text to append after number is converted to words, e.g. "million", as in "eighty million".
• capitalise - Whether the number it returns should be capitalised or not, e.g. "Eighty-Eight" vs. "eighty-eight".

invert_HTML_colour

Inverts the colour of an HTML string

ion_num

Picks a string of symbols to display as the law number for hacked or ion laws is at the start to prevent us from changing say modes via get_message_mode()

isAdminGhostAI

Is the passed in mob an admin ghost WITH AI INTERACT enabled

isAdminObserver

Is the passed in mob a ghost with admin powers, doesn't check for AI interact like isAdminGhost() used to

is_admin

Returns if the given client is an admin, REGARDLESS of if they're deadminned or not.

is_color_dark

Given a color in the format of "#RRGGBB", will return if the color is dark.

is_convertable_to_cult

Returns whether the given mob is convertable to the blood cult

is_guest_key

Returns whether or not a player is a guest using their ckey as an input

is_ic_filtered

Given a text, will return what word is on the IC filter, with the reason. Returns null if the message is OK.

is_ic_filtered_for_pdas

Given a text, will return what word is on the IC filter, ignoring words allowed on the PDA, with the reason. Returns null if the message is OK.

is_ooc_filtered

Given a text, will return what word is on the OOC filter, with the reason. Returns null if the message is OK.

is_path_in_list

Checks for specific paths in a list.

If using zebra mode the list should be an assoc list with truthy/falsey values. The check short circuits so earlier entries in the input list will take priority. Ergo, subpaths should come before parent paths. Notice that this is the opposite priority of /proc/typecacheof.

Arguments:

• path_to_check: A typepath to check.
• list_to_check: A list of typepaths to check the path_to_check against.
• zebra: Whether to use the value of the mathing path in the list instead of just returning true when a match is found.

is_safe_turf

Checks if a given turf is a "safe" location

is_soft_ic_filtered

Given a text, will return what word is on the soft IC filter, with the reason. Returns null if the message is OK.

is_soft_ic_filtered_for_pdas

Given a text, will return what word is on the soft IC filter, ignoring words allowed on the PDA, with the reason. Returns null if the message is OK.

is_soft_ooc_filtered

Given a text, will return that word is on the soft OOC filter, with the reason. Returns null if the message is OK.

is_source_facing_target

Compare source's dir, the clockwise dir of source and the anticlockwise dir of source To the opposite dir of the dir returned by get_dir(target,source) If one of them is a match, then source is facing target

is_special_character

Returns TRUE if the game has started and we're either an AI with a 0th law, or we're someone with a special role/antag datum

is_type_in_list

Checks for specific types in a list.

If using zebra mode the list should be an assoc list with truthy/falsey values. The check short circuits so earlier entries in the input list will take priority. Ergo, subtypes should come before parent types. Notice that this is the opposite priority of /proc/typecacheof.

Arguments:

• type_to_check: An instance to check.
• list_to_check: A list of typepaths to check the type_to_check against.
• zebra: Whether to use the value of the mathing type in the list instead of just returning true when a match is found.

is_valid_dmi_file

given a text string, returns whether it is a valid dmi icons folder path

is_valid_src

Check if a datum has not been deleted and is a valid source

ishumanbasic

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.

isvineimmune

Used to determine whether the mob is immune to actions by the vine. Use cases: Stops vine from attacking itself, other plants.

item_heal_robotic

Heal a robotic body part on a mob

jps_path_to

These are generally cheaper than looping contents so they go first This file contains the stuff you need for using JPS (Jump Point Search) pathing, an alternative to A* that skips over large numbers of uninteresting tiles resulting in much quicker pathfinding solutions. Mind that diagonals cost the same as cardinal moves currently, so paths may look a bit strange, but should still be optimal.

This is the proc you use whenever you want to have pathfinding more complex than "try stepping towards the thing". If no path was found, returns an empty list, which is important for bots like medibots who expect an empty list rather than nothing. It will yield until a path is returned, using magic

Arguments:

• caller: The movable atom that's trying to find the path
• end: What we're trying to path to. It doesn't matter if this is a turf or some other atom, we're gonna just path to the turf it's on anyway
• max_distance: The maximum number of steps we can take in a given path to search (default: 30, 0 = infinite)
• mintargetdistance: Minimum distance to the target before path returns, could be used to get near a target, but not right to it - for an AI mob with a gun, for example.
• access: A list representing what access we have and what doors we can open.
• simulated_only: Whether we consider turfs without atmos simulation (AKA do we want to ignore space)
• exclude: If we want to avoid a specific turf, like if we're a mulebot who already got blocked by some turf
• skip_first: Whether or not to delete the first item in the path. This would be done because the first item is the starting tile, which can break movement for some creatures.
• diagonal_handling: defines how we handle diagonal moves. see __DEFINES/path.dm

json_deserialize_datum

Convert a list of json to datum

json_serialize_datum

Convert a datum into a json blob

kvpify_list

Converts a list into a list of assoc lists of the form ("key" = key, "value" = value) so that list keys that are themselves lists can be fully json-encoded

lightningbolt

this is the actual bolt effect and damage, made into its own proc because it is used elsewhere

living_player_count

Returns the amount of currently living players

load_adventures

Loads all adventures from DB

load_default_map_config

Proc that simply loads the default map config, which should always be functional.

load_map

Shortcut function to parse a map and apply it to the world.

• dmm_file: A .dmm file to load (Required).
• x_offset, y_offset, z_offset: Positions representign where to load the map (Optional).
• cropMap: When true, the map will be cropped to fit the existing world dimensions (Optional).
• measureOnly: When true, no changes will be made to the world (Optional).
• no_changeturf: When true, [/turf/proc/AfterChange] won't be called on loaded turfs
• x_lower, x_upper, y_lower, y_upper: Coordinates (relative to the map) to crop to (Optional).
• placeOnTop: Whether to use [/turf/proc/PlaceOnTop] rather than [/turf/proc/ChangeTurf] (Optional).

load_map_config

Proc handling the loading of map configs. Will return the default map config using /proc/load_default_map_config if the loading of said file fails for any reason whatsoever, so we always have a working map for the server to run.

Arguments:

• filename - Name of the config file for the map we want to load. The .json file extension is added during the proc, so do not specify filenames with the extension.
• directory - Name of the directory containing our .json - Must be in MAP_DIRECTORY_WHITELIST. We default this to MAP_DIRECTORY_MAPS as it will likely be the most common usecase. If no filename is set, we ignore this.
• log_missing - Bool that says whether failing to load the config for the map will be logged in log_world or not as it's passed to LoadConfig().
• log_whitelist - Bool that says whether the directory not being in MAP_DIRECTORY_WHITELIST will be logged in log_world.

Returns the config for the map to load.

load_poll_data

Loads all current and future server polls and their options to store both as datums.

log_atmos

Logs the contents of the gasmix to the game log, prefixed by text

log_combat

Log a combat message in the attack log

Arguments:

• atom/user - argument is the actor performing the action
• atom/target - argument is the target of the action
• what_done - is a verb describing the action (e.g. punched, throwed, kicked, etc.)
• atom/object - is a tool with which the action was made (usually an item)
• addition - is any additional text, which will be appended to the rest of the log line

log_directed_talk

Helper for logging of messages with only one sender and receiver

log_filter

Logs to the filter log with the given message, match, and scope

log_suspicious_login

Writes to a special log file if the log_suspicious_login config flag is set, which is intended to contain all logins that failed under suspicious circumstances.

Mirrors this log entry to log_access when access_log_mirror is TRUE, so this proc doesn't need to be used alongside log_access and can replace it where appropriate.

log_tgui

Appends a tgui-related log entry. All arguments are optional.

make_associative

Make a normal list an associative one

make_body

Uses stripped down and bastardized code from respawn character

make_datum_references_lists

Initial Building

make_tuple

Returns the name of the mathematical tuple of same length as the number arg (rounded down).

md5asfile

Save file as an external file then md5 it. Used because md5ing files stored in the rsc sometimes gives incorrect md5 results.

md5filepath

Returns the md5 of a file at a given path.

message_centcom

Used by communications consoles to message CentCom

message_syndicate

Used by communications consoles to message the Syndicate

message_to_html

Message-related procs

Message format (/list):

• type - Message type, must be one of defines in code/__DEFINES/chat.dm
• text - Plain message text
• html - HTML message text
• Optional metadata, can be any key/value pair.

Copyright (c) 2020 Aleksej Komarov SPDX-License-Identifier: MIT

move_element

Move a single element from position from_index within a list, to position to_index All elements in the range [1,to_index) before the move will be before the pivot afterwards All elements in the range [to_index, L.len+1) before the move will be after the pivot afterwards In other words, it's as if the range [from_index,to_index) have been rotated using a <<< operation common to other languages. from_index and to_index must be in the range [1,L.len+1] This will preserve associations ~Carnie

move_range

Move elements [from_index,from_index+len) to [to_index-len, to_index) Same as moveElement but for ranges of elements This will preserve associations ~Carnie

mutable_appearance

Helper similar to image()

narsie_apocalypse

Third crew last second win check and flufftext for [/proc/begin_the_end()]

narsie_end_begin_check

First crew last second win check and flufftext for [/proc/begin_the_end()]

narsie_end_second_check

Second crew last second win check and flufftext for [/proc/begin_the_end()]

narsie_last_second_win

Called only if the crew managed to destroy narsie at the very last second for [/proc/begin_the_end()]

narsie_start_destroy_station

security level and shuttle lockdowns for [/proc/begin_the_end()]

next_list_item

Returns the next item in a list

noop

A do nothing proc

notify_ghosts

Fancy notifications for ghosts

The kitchen sink of notification procs

Arguments:

• message
• ghost_sound sound to play
• enter_link Href link to enter the ghost role being notified for
• source The source of the notification
• alert_overlay The alert overlay to show in the alert message
• action What action to take upon the ghost interacting with the notification, defaults to NOTIFY_JUMP
• flashwindow Flash the byond client window
• ignore_key Ignore keys if they're in the GLOB.poll_ignore list
• header The header of the notifiaction
• notify_suiciders If it should notify suiciders (who do not qualify for many ghost roles)
• notify_volume How loud the sound should be to spook the user

nuke_request

Used by communications consoles to request the nuclear launch codes

offer_control

Offer control of the passed in mob to dead player

Automatic logging and uses poll_candidates_for_mob, how convenient

offset_to_screen_loc

Takes a list in the form (x_offset, y_offset) And converts it to a screen loc string Accepts an optional view string/size to force the screen_loc around, so it can't go out of scope

overlays2text

Converts an overlay list into text for debug printing Of note: overlays aren't actually mutable appearances, they're just appearances Don't have access to that type tho, so this is the best you're gonna get

parse_caught_click_modifiers

Returns a turf based on text inputs, original turf and viewing client

parse_slot_flags

Returns a list of strings for a given slot flag.

parse_zone

Return a string for the specified body zone. Should be used for parsing non-instantiated bodyparts, otherwise use /obj/item/bodypart/var/plaintext_zone

pathfinding_finished

Uses funny pass by reference bullshit to take the path created by pathfinding, and insert it into a return list We'll be able to use this return list to tell a sleeping proc to continue execution

peek

Returns the top (last) element from the list, does not remove it from the list. Stack functionality.

pick_closest_path

Returns a chosen path that is the closest to a list of matches

pick_n_take

Pick a random element from the list and remove it from the list.

pick_weight

Picks a random element from a list based on a weighting system. For example, given the following list: A = 6, B = 3, C = 1, D = 0 A would have a 60% chance of being picked, B would have a 30% chance of being picked, C would have a 10% chance of being picked, and D would have a 0% chance of being picked. You should only pass integers in.

piglatin_sentence

runs piglatin_word() proc on each word in a sentence. preserves caps and punctuation

piglatin_word

takes "word", and returns it piglatinized.

play_fov_effect

Plays a visual effect representing a sound cue for people with vision obstructed by FOV or blindness

playsound

playsound is a proc used to play a 3D sound in a specific range. This uses SOUND_RANGE + extra_range to determine that.

source - Origin of sound. soundin - Either a file, or a string that can be used to get an SFX. vol - The volume of the sound, excluding falloff and pressure affection. vary - bool that determines if the sound changes pitch every time it plays. extrarange - modifier for sound range. This gets added on top of SOUND_RANGE. falloff_exponent - Rate of falloff for the audio. Higher means quicker drop to low volume. Should generally be over 1 to indicate a quick dive to 0 rather than a slow dive. frequency - playback speed of audio. channel - The channel the sound is played at. pressure_affected - Whether or not difference in pressure affects the sound (E.g. if you can hear in space). ignore_walls - Whether or not the sound can pass through walls. falloff_distance - Distance at which falloff begins. Sound is at peak volume (in regards to falloff) aslong as it is in this range.

podspawn

One proc for easy spawning of pods in the code to drop off items before whizzling (please don't proc call this in game, it will destroy you)

Arguments:

• specifications: special mods to the pod, see non var edit specifications for details on what you should fill this with Non var edit specifications:
• target = where you want the pod to drop
• path = a special specific pod path if you want, this can save you a lot of var edits
• style = style of the pod, defaults to the normal pod
• spawn = spawned path or a list of the paths spawned, what you're sending basically Returns the pod spawned, in case you want to spawn items yourself and modify them before putting them in.

poll_candidates

Calls the show_candidate_poll_window() to all eligible ghosts

poll_candidates_for_mob

Returns a list of ghosts that are eligible to take over and wish to be considered for a mob.

Arguments:

• question - question to show players as part of poll
• jobban_type - Type of jobban to use to filter out potential candidates.
• be_special_flag - Unknown/needs further documentation.
• poll_time - Length of time in deciseconds that the poll input box exists before closing.
• target_mob - The mob that is being polled for.
• ignore_category - Unknown/needs further documentation.

poll_candidates_for_mobs

Returns a list of ghosts that are eligible to take over and wish to be considered for a mob.

Arguments:

• question - question to show players as part of poll
• jobban_type - Type of jobban to use to filter out potential candidates.
• be_special_flag - Unknown/needs further documentation.
• poll_time - Length of time in deciseconds that the poll input box exists before closing.
• mobs - The list of mobs being polled for. This list is mutated and invalid mobs are removed from it before the proc returns.
• ignore_category - Unknown/needs further documentation.

poll_ghost_candidates

Wrapper to send all ghosts the poll to ask them if they want to be considered for a mob.

pop

Returns the top(last) element from the list and removes it from the list (typical stack function)

populate_editable_sign_types

This proc populates GLOBAL_LIST_EMPTY(editable_sign_types)

The first time a pen is used on any sign, this populates GLOBAL_LIST_EMPTY(editable_sign_types), creating a global list of all the signs that you can set a sign backing to with a pen.

power_fail

Disable power in the station APCs

previous_list_item

Returns the previous item in a list

priority_announce

Create an announcement to send globally or to a specified list of players.

args:

• text (string) The body of the announcement
• title (string) The title of the announcement. Default: "Staton Announcement"
• sound_type (string OR sound) The sound to play alongside the message. If given a string like PA_COMMAND, it will pick the sound for you.
• send_to_newscaster (boolean) Whether or not to post this to newscasters
• do_not_modify (boolean) Whether or not station announcers can add to this message.
• players (list or null) The players we're sending to. If null, send to all players.

process_teleport_locs

Generate a list of turfs you can teleport to from the areas list

Includes areas if they're not a shuttle or not not teleport or have no contents

The chosen turf is the first item in the areas contents that is a station level

The returned list of turfs is sorted by name

propagate_network

remove the old powernet and replace it with a new one throughout the network.

pull_apart_damage_states

This exists purely to import sprites from a codebase like Citadel RP.

pump_gas

obj/machinery/atmospherics/var/debug = 0

qdel

Should be treated as a replacement for the 'del' keyword.

Datums passed to this will be given a chance to clean up references to allow the GC to collect them.

radiation_pulse

Sends out a pulse of radiation, eminating from the source. Radiation is performed by collecting all radiatables within the max range (0 means source only, 1 means adjacent, etc), then makes their way towards them. A number, starting at 1, is multiplied by the insulation amounts of whatever is in the way (for example, walls lowering it down). If this number hits equal or below the threshold, then the target can no longer be irradiated. If the number is above the threshold, then the chance is the chance that the target will be irradiated. As a consumer, this means that max_range going up usually means you want to lower the threshold too, as well as the other way around. If max_range is high, but threshold is too high, then it usually won't reach the source at the max range in time. If max_range is low, but threshold is too low, then it basically guarantees everyone nearby, even if there's walls and such in the way, can be irradiated. You can also pass in a minimum exposure time. If this is set, then this radiation pulse will not irradiate the source unless they have been around any radioactive source for that period of time.

ran_zone

Return the zone or randomly, another valid zone

Do not use this if someone is intentionally trying to hit a specific body part. Use get_zone_with_miss_chance() for that.

random_capital_letter

handles thousands

random_colour

Returns a random color picked from a list, has 2 modes (0 and 1), mode 1 doesn't pick white, black or gray

random_fish_type

Returns random fish, using random_case_rarity probabilities.

random_nukecode

Returns a string for a random nuke code

random_step

Forces the atom to take a step in a random direction

rcd_result_with_memory

Produces a new RCD result from the given one if it can be calculated that the RCD should speed up with the remembered form.

rcd_scan

Global proc that generates RCD hologram in a range.

Arguments:

• source - The atom the scans originate from
• scan_range - The range of turfs we grab from the source
• fade_time - The time for RCD holograms to fade

recover_all_SS_and_recreate_master

Recreate all SSs which will still cause data survive due to Recover(), the new Master will then find and take them from global.vars

recursive_list_resolve

Returns a list with all weakrefs resolved

recursive_list_resolve_element

Helper for recursive_list_resolve()

recursive_loc_check

Recursively checks if an item is inside a given type, even through layers of storage. Returns the atom if it finds it.

recursive_organ_check

• recursive_organ_check
• inputs: first_object (object to start with)
• outputs:
• description: A pseudo-recursive loop based off of the recursive mob check, this check looks for any organs held
• within 'first_object', toggling their frozen flag. This check excludes items held within other safe organ
• storage units, so that only the lowest level of container dictates whether we do or don't decompose

refify_list

Returns a copy of the list where any element that is a datum or the world is converted into a ref

reject_bad_chattext

The procedure to check the text of the entered text on ntnrc_client.dm

This procedure is designed to check the text you type into the chat client. It checks for invalid characters and the size of the entered text.

reject_bad_name

Filters out undesirable characters from names.

• strict - return null immidiately instead of filtering out
• allow_numbers - allows numbers and common special characters - used for silicon/other weird things names

reject_bad_text

Returns the text if properly formatted, or null else.

Things considered improper:

• Larger than max_length.
• Presence of non-ASCII characters if asci_only is set to TRUE.
• Only whitespaces, tabs and/or line breaks in the text.
• Presence of the <, >, \ and / characters.
• Presence of ASCII special control characters (horizontal tab and new line not included).

remove_all_tags

Removes all tags in a string of text. May result in some formatting errors, floating whitespace. Not perfect.

remove_clunky_diagonals

Processes a path (list of turfs), removes any diagonal moves that would lead to a weird bump

path - The path to process down pass_info - Holds all the info about what this path attempt can go through simulated_only - If we are not allowed to pass space turfs avoid - A turf to be avoided

remove_diagonals

Processes a path (list of turfs), removes any diagonal moves

path - The path to process down pass_info - Holds all the info about what this path attempt can go through simulated_only - If we are not allowed to pass space turfs avoid - A turf to be avoided

remove_image_from_client

Removes an image from a client's .images. Useful as a callback.

remove_images_from_clients

Like remove_image_from_client, but will remove the image from a list of clients

remove_non_canon_overlays

Recursively removes overlays that do not render to the game plane from an appearance.

remove_verb

handles removing verb and sending it to browser to update, use this for removing verbs

pass the verb type path to this instead of removing it from verbs so the statpanel can update Arguments:

• target - Who the verb is being removed from, client or mob typepath
• verb - typepath to a verb, or a list of verbs, supports lists of lists

reset_cooldown

Proc used by stoppable timers to end a cooldown before the time has ran out.

Arguments:

• source - datum storing the cooldown
• index - string index storing the cooldown on the cooldowns associative list

This sends a signal reporting the cooldown end, passing the time left as an argument.

resolve_ai_icon_sync

A form of resolve_ai_icon that is guaranteed to never sleep. Not always accurate, but always synchronous.

retrieve_ban_cache

Gets the ban cache of the passed in client If the cache has not been generated, we start off a query If we still have a query going for this request, we just sleep until it's recieved back

return_generator_args

returns the arguments given to a generator and manually extracts them from the internal byond object returns:

• flat list of strings for args given to the generator.
• Note: this means things like "list(1,2,3)" will need to be processed

return_unused_frequency

returns a random unused frequency between MIN_FREE_FREQ & MAX_FREE_FREQ if free = TRUE, and MIN_FREQ & MAX_FREQ if FALSE

reverse_range

replaces reverseList ~Carnie

rgb2hsv

Converts an rgb color into a list storing hsva Exists because it's useful to have a guarenteed alpha value

rustg_get_version

Gets the version of rust_g

rustg_unix_timestamp

Returns the timestamp as a string

sanitize

Runs byond's html encoding sanitization proc, after replacing new-lines and tabs for the # character.

sanitize_color

Makes sure the input color is text with a # at the start followed by 6 hexadecimal characters. Examples: "#ff1234", "#A38321", COLOR_GREEN_GRAY

sanitize_css_class_name

Removes all non-alphanumerics from the text, keep in mind this can lead to id conflicts

sanitize_filepath

Sanitizes the name of each node in the path.

Im case you are wondering when to use this proc and when to use SANITIZE_FILENAME,

You use SANITIZE_FILENAME to sanitize the name of a file [e.g. example.txt]

You use sanitize_filepath sanitize the path of a file [e.g. root/node/example.txt]

If you use SANITIZE_FILENAME to sanitize a file path things will break.

sanitize_frequency

Ensure the frequency is within bounds of what it should be sending/receiving at

sanitize_name

returns nothing with an alert instead of the message if it contains something in the ic filter, and sanitizes normally if the name is fine. It returns nothing so it backs out of the input the same way as if you had entered nothing.

scramble_message_replace_chars

Slightly expensive proc to scramble a message using equal probabilities of character replacement from a list. DOES NOT SUPPORT HTML!

scramble_text

Scramble a string up. intensity = number of times we recursively call ourselves to scramble.

screen_loc_to_offset

Takes a screen loc string in the format "+-left-offset:+-pixel,+-bottom-offset:+-pixel" Where the :pixel is optional, and returns A list in the format (x_offset, y_offset) We require context to get info out of screen locs that contain relative info, so NORTH, SOUTH, etc

screen_text

Return an object with a new maptext (not currently in use)

seedify

Finds and extracts seeds from an object

Checks if the object is such that creates a seed when extracted. Used by seed extractors or posably anything that would create seeds in some way. The seeds are dropped either at the extractor, if it exists, or where the original object was and it qdel's the object

Arguments:

• O - Object containing the seed, can be the loc of the dumping of seeds
• t_max - Amount of seed copies to dump, -1 is ranomized
• extractor - Seed Extractor, used as the dumping loc for the seeds and seed multiplier
• user - checks if we can remove the object from the inventory

send2adminchat

Sends a message to TGS admin chat channels.

category - The category of the mssage. message - The message to send.

send2chat

Sends a message to TGS chat channels.

message - The message to send. channel_tag - Required. If "", the message with be sent to all connected (Game-type for TGS3) channels. Otherwise, it will be sent to TGS4 channels with that tag (Delimited by ','s). admin_only - Determines if this communication can only be sent to admin only channels.

send2otherserver

Sends a message to a set of cross-communications-enabled servers using world topic calls

Arguments:

• source - Who sent this message
• msg - The message body
• type - The type of message, becomes the topic command under the hood
• target_servers - A collection of servers to send the message to, defined in config
• additional_data - An (optional) associated list of extra parameters and data to send with this world topic call

send_tip_of_the_round

Sends a round tip to a target. If selected_tip is null, a random tip will be sent instead (5% chance of it being silly). Tips that starts with the @ character won't be html encoded. That's necessary for any tip containing markup tags, just make sure they don't also have html characters like <, > and ' which will be garbled.

send_to_playing_players

sends a whatever to all playing players; use instead of to_chat(world, where needed)

serialize_antag_name

Serializes an antag name to be used for preferences UI

setup_mod_themes

Global proc that sets up all MOD themes as singletons in a list and returns it.

shake_camera

Shake the camera of the person viewing the mob SO REAL! Takes the mob to shake, the time span to shake for, and the amount of tiles we're allowed to shake by in tiles Duration isn't taken as a strict limit, since we don't trust our coders to not make things feel shitty. So it's more like a soft cap.

should_have_space_before_emote

Returns a boolean based on whether or not the string contains a comma or an apostrophe, to be used for emotes to decide whether or not to have a space between the name of the user and the emote.

Requires the message to be HTML decoded beforehand. Not doing it here for performance reasons.

Returns TRUE if there should be a space, FALSE if there shouldn't.

show_candidate_poll_window

Show the poll window to the candidate mobs

shuffle

Randomize: Return the list in a random order

shuffle_inplace

same as shuffle, but returns nothing and acts on list in place

siunit

Formats a number to human readable form with the appropriate SI unit.

Supports SI exponents between 1e-15 to 1e15, but properly handles numbers outside that range as well. Examples:

• siunit(1234, "Pa", 1) -> "1.2 kPa"

• siunit(0.5345, "A", 0) -> "535 mA"

• siunit(1000, "Pa", 4) -> "1 kPa" Arguments:

• value - The number to convert to text. Can be positive or negative.

• unit - The base unit of the number, such as "Pa" or "W".

• maxdecimals - Maximum amount of decimals to display for the final number. Defaults to 1.

• For pressure conversion, use proc/siunit_pressure() below

siunit_pressure

• The game code never uses Pa, but kPa, since 1 Pa is too small to reasonably handle
• Thus, to ensure correct conversion from any kPa in game code, this value needs to be multiplied by 10e3 to get Pa, which the siunit() proc expects
• Args:
• • value_in_kpa - Value that should be converted to readable text in kPa
• • maxdecimals - maximum number of decimals that are displayed, defaults to 1 in proc/siunit()

slapcraft_examine_hints_for_type

Gets examine hints for this item type for slap crafting.

slapcraft_recipes_for_type

Gets cached recipes for a type. This is a method of optimizating recipe lookup. Ugly but gets the job done. also WARNING: This will make it so all recipes whose first step is not type checked will not work, which all recipes that I can think of will be. If you wish to remove this and GLOB.slapcraft_firststep_recipe_cache should this cause issues, replace the return with GLOB.slapcraft_recipes

sort_key

for sorting clients or mobs by ckey

sort_list

sort any value in a list

sort_mobs

Orders mobs by type then by name. Accepts optional arg to sort a custom list, otherwise copies GLOB.mob_list.

sort_names

uses sort_list() but uses the var's name specifically. This should probably be using mergeAtom() instead

sort_record

Specifically for record datums in a list.

spawn_express_pods

Spawns express pod(s) at a given location. Landing_loc can be a list in the case of an emagged console.

special_list_filter

Returns a list with items filtered from a list that can call callback

spiral_range

similar function to range(), but with no limitations on the distance; will search spiralling outwards from the center

spiral_range_turfs

similar function to RANGE_TURFS(), but will search spiralling outwards from the center (like the above, but only turfs)

spread_reagents

Exposes all accessible atoms within some distance of an epicenter to some reagents. Does not clear the source reagent holder; that must be done manually if it is desired.

Arguments:

• source: The reagents to spread around.
• epicenter: The epicenter/source location of the reagent spread.
• spread_range: The range in which to spread the reagents.

stack_trace

gives us the stack trace from CRASH() without ending the current proc.

stars

Convert random parts of a passed in message to stars

• phrase - the string to convert
• probability - probability any character gets changed

This proc is dangerously laggy, avoid it or die

station_time

Generate a game-world time value in deciseconds.

stoplag

returns the number of ticks slept

string_list

Caches lists with non-numeric stringify-able values (text or typepath).

stringmerge

This proc replaces all instances of the "replace" character in "text" with the character in the same position within the "compare" string "FFFFFFFFFFFFFFFFF***" and "FFFFFFFFFFFFFFF*****************FFFFFFFFFFFFFFFFFF" is "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

strip_html

Runs STRIP_HTML_SIMPLE and sanitize.

stripped_input

Used to get a properly sanitized input, of max_length no_trim is self explanatory but it prevents the input from being trimed if you intend to parse newlines or whitespace.

swap_range

Move elements from [from_index, from_index+len) to [to_index, to_index+len) Move any elements being overwritten by the move to the now-empty elements, preserving order Note: if the two ranges overlap, only the destination order will be preserved fully, since some elements will be within both ranges ~Carnie

syndies_escaped

Returns whether or not syndicate operatives escaped.

tesla_zap_target

Zap a single target with a tesla beam. Returns a leftover power value.

test_whiteship_sizes

Helper proc that tests to ensure all whiteship templates can spawn at their docking port, and logs their sizes This should be a unit test, but too much of our other code breaks during shuttle movement, so not yet, not yet.

text_preview

Provides a preview of [string] up to [len - 3], after which it appends "..." if it pasts the length.

tgalert

DEPRECATED: USE tgui_alert(...) INSTEAD

Designed as a drop in replacement for alert(); functions the same. (outside of needing User specified) Arguments:

• User - The user to show the alert to.
• Message - The textual body of the alert.
• Title - The title of the alert's window.
• Button1 - The first button option.
• Button2 - The second button option.
• Button3 - The third button option.
• StealFocus - Boolean operator controlling if the alert will steal the user's window focus.
• Timeout - The timeout of the window, after which no responses will be valid.

tgui_Topic

Middleware for /client/Topic.

return bool If TRUE, prevents propagation of the topic call.

tgui_alert

Creates a TGUI alert window and returns the user's response.

This proc should be used to create alerts that the caller will wait for a response from. Arguments:

• user - The user to show the alert to.
• message - The content of the alert, shown in the body of the TGUI window.
• title - The of the alert modal, shown on the top of the TGUI window.
• buttons - The options that can be chosen by the user, each string is assigned a button on the UI.
• timeout - The timeout of the alert, after which the modal will close and qdel itself. Set to zero for no timeout.
• autofocus - The bool that controls if this alert should grab window focus.

tgui_alert_async

Creates an asynchronous TGUI alert window with an associated callback.

This proc should be used to create alerts that invoke a callback with the user's chosen option. Arguments:

• user - The user to show the alert to.
• message - The content of the alert, shown in the body of the TGUI window.
• title - The of the alert modal, shown on the top of the TGUI window.
• buttons - The options that can be chosen by the user, each string is assigned a button on the UI.
• callback - The callback to be invoked when a choice is made.
• timeout - The timeout of the alert, after which the modal will close and qdel itself. Disabled by default, can be set to seconds otherwise.
• autofocus - The bool that controls if this alert should grab window focus.

tgui_input_list

Creates a TGUI input list window and returns the user's response.

This proc should be used to create alerts that the caller will wait for a response from. Arguments:

• user - The user to show the input box to.
• message - The content of the input box, shown in the body of the TGUI window.
• title - The title of the input box, shown on the top of the TGUI window.
• items - The options that can be chosen by the user, each string is assigned a button on the UI.
• default - If an option is already preselected on the UI. Current values, etc.
• timeout - The timeout of the input box, after which the menu will close and qdel itself. Set to zero for no timeout.

tgui_input_list_async

Client does NOT have tgui_input on: Returns regular input Creates an asynchronous TGUI input list window with an associated callback.

This proc should be used to create inputs that invoke a callback with the user's chosen option. Arguments:

• user - The user to show the input box to.
• message - The content of the input box, shown in the body of the TGUI window.
• title - The title of the input box, shown on the top of the TGUI window.
• items - The options that can be chosen by the user, each string is assigned a button on the UI.
• default - If an option is already preselected on the UI. Current values, etc.
• callback - The callback to be invoked when a choice is made.
• timeout - The timeout of the input box, after which the menu will close and qdel itself. Set to zero for no timeout.

tgui_input_number

Creates a TGUI window with a number input. Returns the user's response as num | null.

This proc should be used to create windows for number entry that the caller will wait for a response from. If tgui fancy chat is turned off: Will return a normal input. If a max or min value is specified, will validate the input inside the UI and ui_act.

Arguments:

• user - The user to show the number input to.
• message - The content of the number input, shown in the body of the TGUI window.
• title - The title of the number input modal, shown on the top of the TGUI window.
• default - The default (or current) value, shown as a placeholder. Users can press refresh with this.
• max_value - Specifies a maximum value. If none is set, any number can be entered. Pressing "max" defaults to 1000.
• min_value - Specifies a minimum value. Often 0.
• timeout - The timeout of the number input, after which the modal will close and qdel itself. Set to zero for no timeout.
• round_value - whether the inputted number is rounded down into an integer.

tgui_input_number_async

Creates an asynchronous TGUI number input window with an associated callback.

This proc should be used to create number inputs that invoke a callback with the user's entry.

Arguments:

• user - The user to show the number input to.
• message - The content of the number input, shown in the body of the TGUI window.
• title - The title of the number input modal, shown on the top of the TGUI window.
• default - The default (or current) value, shown as a placeholder. Users can press refresh with this.
• max_value - Specifies a maximum value. If none is set, any number can be entered. Pressing "max" defaults to 1000.
• min_value - Specifies a minimum value. Often 0.
• callback - The callback to be invoked when a choice is made.
• timeout - The timeout of the number input, after which the modal will close and qdel itself. Set to zero for no timeout.
• round_value - whether the inputted number is rounded down into an integer.

tgui_input_text

Creates a TGUI window with a text input. Returns the user's response.

This proc should be used to create windows for text entry that the caller will wait for a response from. If tgui fancy chat is turned off: Will return a normal input. If max_length is specified, will return stripped_multiline_input.

Arguments:

• user - The user to show the text input to.
• message - The content of the text input, shown in the body of the TGUI window.
• title - The title of the text input modal, shown on the top of the TGUI window.
• default - The default (or current) value, shown as a placeholder.
• max_length - Specifies a max length for input. MAX_MESSAGE_LEN is default (1024)
• multiline - Bool that determines if the input box is much larger. Good for large messages, laws, etc.
• encode - Toggling this determines if input is filtered via html_encode. Setting this to FALSE gives raw input.
• timeout - The timeout of the textbox, after which the modal will close and qdel itself. Set to zero for no timeout.

tgui_input_text_async

Creates an asynchronous TGUI text input window with an associated callback.

This proc should be used to create text inputs that invoke a callback with the user's entry. Arguments:

• user - The user to show the text input to.
• message - The content of the text input, shown in the body of the TGUI window.
• title - The title of the text input modal, shown on the top of the TGUI window.
• default - The default (or current) value, shown as a placeholder.
• max_length - Specifies a max length for input.
• multiline - Bool that determines if the input box is much larger. Good for large messages, laws, etc.
• encode - If toggled, input is filtered via html_encode. Setting this to FALSE gives raw input.
• callback - The callback to be invoked when a choice is made.

time_to_twelve_hour

Converts a time expressed in deciseconds (like world.time) to the 12-hour time format. the format arg is the format passed down to time2text() (e.g. "hh:mm" is hours and minutes but not seconds).

timeleft

Get the remaining deciseconds on a timer

Arguments:

• id a timerid or a /datum/timedevent

to_chat

Sends the message to the recipient (target).

Recommended way to write to_chat calls:

to_chat(client,
    type = MESSAGE_TYPE_INFO,
    html = "You have found <strong>[object]</strong>")

to_chat_immediate

Circumvents the message queue and sends the message to the recipient (target) as soon as possible.

tool_behaviour_name

returns an ic name of the tool needed Arguments:

• tool_behaviour: the tool described!

truncate

Truncate a string to the given length

Will only truncate if the string is larger than the length and ignores unicode concerns

This exists soley because trim does other stuff too.

Arguments:

• text - String
• max_length - integer length to truncate at

try_move_adjacent

Tries to move an atom to an adjacent turf, return TRUE if successful

typecache_filter_list

returns a new list with only atoms that are in the typecache list

typecache_filter_list_reverse

return a new list with atoms that are not in the typecache list

typecache_filter_multi_list_exclusion

similar to typecache_filter_list and typecache_filter_list_reverse but it supports an inclusion list and and exclusion list

typecacheof

Like typesof() or subtypesof(), but returns a typecache instead of a list.

Arguments:

• path: A typepath or list of typepaths.
• only_root_path: Whether the typecache should be specifically of the passed types.
• ignore_root_path: Whether to ignore the root path when caching subtypes.

ui_status_only_living

Returns a UI status such that the dead will be able to watch, but not interact.

ui_status_silicon_has_access

Returns a UI status such that silicons will be able to interact with whatever they would have access to if this was a machine. For example, AIs can interact if there's cameras with wireless control is enabled.

ui_status_user_has_free_hands

Returns a UI status such that those without blocked hands will be able to interact, but everyone else can only watch.

ui_status_user_is_abled

Returns a UI status such that users with debilitating conditions, such as being dead or not having power for silicons, will not be able to interact. Being dead will disable UI, being incapacitated will continue updating it, and anything else will make it interactive.

ui_status_user_is_adjacent

Returns a UI status such that users adjacent to source will be able to interact, far away users will be able to see, and anyone farther won't see anything. Dead users will receive updates no matter what, though you likely want to add a [ui_status_only_living] check for finer observer interactions.

ui_status_user_is_advanced_tool_user

Returns a UI status such that advanced tool users will be able to interact, but everyone else can only watch.

ui_status_user_is_conscious_and_lying_down

Returns UI_INTERACTIVE if the user is conscious and lying down. Returns UI_UPDATE otherwise.

ui_status_user_strictly_adjacent

Return UI_INTERACTIVE if the user is strictly adjacent to the target atom, whether they can see it or not. Return UI_CLOSE otherwise.

unformat_frequency

Opposite of format, returns as a number

unique_list

Return a list with no duplicate entries

unique_list_in_place

same as unique_list, but returns nothing and acts on list in place (also handles associated values properly)

urange

ultra range (no limitations on distance, faster than range for distances > 8); including areas drastically decreases performance

url2htmlloader

Return html to load a url. for use inside of browse() calls to html assets that might be loaded on a cdn.

valid_window_location

Checks whether the target turf is in a valid state to accept a directional window or other directional pseudo-dense object such as railings.

Returns FALSE if the target turf cannot accept a directional window or railing. Returns TRUE otherwise.

Arguments:

• dest_turf - The destination turf to check for existing windows and railings
• test_dir - The prospective dir of some atom you'd like to put on this turf.
• is_fulltile - Whether the thing you're attempting to move to this turf takes up the entire tile or whether it supports multiple movable atoms on its tile.

view_to_pixels

Takes a string or num view, and converts it to pixel width/height in a list(pixel_width, pixel_height)

voice_of_god

VOICE OF GOD

weakrefify_list

Returns a copy of the list where any element that is a datum is converted into a weakref

weekday_to_iso

Returns a string day as an integer in ISO format 1 (Monday) - 7 (Sunday)

weight_class_to_text

Returns a string based on the weight class define used as argument

window_flash

Flash the window of a player

zebra_typecacheof

Like typesof() or subtypesof(), but returns a typecache instead of a list. This time it also uses the associated values given by the input list for the values of the subtypes.

Latter values from the input list override earlier values. Thus subtypes should come after parent types in the input list. Notice that this is the opposite priority of /proc/is_type_in_list and /proc/is_path_in_list.

Arguments:

• path: A typepath or list of typepaths with associated values.
• single_value: The assoc value used if only a single path is passed as the first variable.
• only_root_path: Whether the typecache should be specifically of the passed types.
• ignore_root_path: Whether to ignore the root path when caching subtypes.
• clear_nulls: Whether to remove keys with null assoc values from the typecache after generating it.

zstep

A step() variant that allows passing z_movement_flags. Normal step() is fine if you do not need special movement flags.