DM Standard Library Documentation Thread

ID:1898015
 
Jul 17 2015, 10:49 am (Edited on Jul 17 2015, 4:36 pm)
This thread is intended for documenting the emerging DM StdLib standard features.

If you make changes to StdLib, please document them here. Please be patient while I document what each of these features and changes does.



Listing:
Jul 17 2015, 10:50 am (Edited on Jul 17 2015, 12:11 pm)
FPS

This is a global level definition that should be set in your project prior to the inclusion of StdLib. If you do not have this define set, StdLib will assume that your FPS is 25. To define this, simply include this line before the #include line for StdLib:

#define FPS 40


You will want to make certain that you use the FPS that your world is actually running at.


TICK_LAG

This is a global level definition that should be set in your project prior to the inclusion of StdLib. If you do not define this value, that is okay so long as FPS is defined. TICK_LAG defaults to 10/FPS. This is the amount of time in 1/10th seconds that each frame takes.

The reason that this is included is so that code from your project can be much more modular and the project's tick_lag value can be changed quickly and easily without interrupting development.

If your project depends on world.tick_lag changing dynamically during runtime, don't use this value.


TILE_WIDTH

This is a global level definition that should be set in your project prior to the inclusion of StdLib. If you do not define this value, StdLib will warn you that it is not set and set it to 32 by default.

The reason that this exists is so that your project's code can be more modular and changing the icon size on the map requires much less work from the developer.


TILE_HEIGHT

This is a global level definition that should be set in your project prior to the inclusion of StdLib. If you do not define this value, StdLib will warn you that it is not set and set it to 32 by default.

The reason that this exists is so that your project's code can be more modular and changing the icon size on the map requires much less work from the developer.


STDLIB

This will be set to 1 if StdLib has been included in your project. If you wish to make an addon to StdLib, you can check if StdLib has been included already by checking this value using preprocessors.

You can use this to warn users about load-order conflicts or dependency on StdLib.


STDLIB_NOWARN

STDLIB_NOWARN can be set to 1 prior to the inclusion of STDLIB to remove warnings from undefined global macros. This should probably be avoided.


STDLIB_KEYS

STDLIB_KEYS can be set to 1 prior to the inclusion of StdLib to enable the inclusion of the built-in Keyboard Module packaged with StdLib. This may be removed in the future in favor of the Key and Mouse module being packaged as separate addons to StdLib.


STDLIB_MOUSE

STDLIB_MOUSE can be set to 1 prior to the inclusion of StdLib to enable the inclusion of the built-in Mouse Module packaged with StdLib. This may be removed in the future in favor of the Key and Mouse module being packaged as separate addons to StdLib.


void

Void is a global variable that is simply a datum that is initialized at world startup. This variable is intended to imply "nothing" in situations where non-null and null values are both meaningful. For instance, let's say you have a loop that needs to wait for the return value of a function. If that function returns null, which may actually be a proper value, the loop will never know that the function has returned. There is no way around this problem if you use numbers or strings that don't incur extra processing and limits on what can be returned. Since void is a specific instance of a normal datum, it can be assumed that any use of void should always be interpreted as "nothing". Therefore, void is a safe value to use in place of null where null is also considered a value.
Jul 17 2015, 10:50 am (Edited on Jul 29 2015, 12:28 am)
decimal proc

Format:
  decimal(number)

Returns:
  The decimal component of the number.

Example:

var/a = 4.5
world << decimal(a)
world << decimal(a/2)
world << decimal(a*2)


The above example will output 0.5 first, and then 0.25 second, and finally 0.


to_places proc

Format:
  to_places(number,sigfigs)

Args:
  number: A number to be modified
  sigfigs: The number of significant figures to cap number to

Returns:
  The final number with values beyond the specified sigfigs removed.

Example:

mob
    var
        money = 0
    proc
        changeMoney(amt)
            money -= sigfigs(amt,2)

        setMoney(amt)
            money = sigfigs(amt,2)


In the above example, the mob has a certain amount of money. We'd like to measure this in dollars and cents. That means any values less than a single cent will be thrown away. By using the sigfigs proc to work with this variable, we can ensure that the amount of money this mob has is always represented in dollars and cents with no fractional pennies rolling around.


clamp proc

Format:
  clamp(value,minimum,maximum)

Args:
  value: A number.
  minimum: The lowest value can be.
  maximum: The highest value can be.

Returns:
  The number between minimum and maximum closest to value.

Example:

mob
    var
        health = 100
        max_health = 100
    proc
        takeDamage(amount)
            var/old_health = health
            health = clamp(health-damage,0,max_health)
            return old_health - health


The above example ensures that the mob's health always stays between 0 and max_health without having to use an if statement. The takeDamage proc in this case will return the amount of damage actually dealt to the mob.


floor proc

See also:
  ceil proc
  inner proc
  outer proc

Format:
  floor(value)

Args:
  value: A number to be rounded.

Returns:
  The nearest whole number to the left of value on a number line.

Example:

world << floor(10)
world << floor(5.5)
world << floor(-1.5)
world << floor(0.5)
world << floor(-0.5)
world << floor(-10)


The above example will output 10, 5, -2, 0, -1 and -10. This is because floor() always looks left on a number line, so the value returned by floor() must always be less than or equal to the value provided.


ceil proc

See also:
  floor proc
  inner proc
  outer proc

Format:
  ceil(value)

Args:
  value: A number to be rounded.

Returns:
  The nearest whole number to the right of value on a number line.

Example:

world << ceil(10)
world << ceil(5.5)
world << ceil(-1.5)
world << ceil(0.5)
world << ceil(-0.5)
world << ceil(-10)


The above example will output 10, 6, -1, 1, 0, and -10. This is because ceil() always looks right on a number line, so the value returned by ceil() must always be greater than or equal to the value provided.


inner proc

See also:
  ceil proc
  floor proc
  outer proc

Format:
  inner(value)

Args:
  value: A number to be rounded.

Returns:
  The nearest whole number toward zero on a number line.

Example:

world << inner(10)
world << inner(5.5)
world << inner(-1.5)
world << inner(0.5)
world << inner(-0.5)
world << inner(-10)


The above example will output 10, 5, -1, 0, 0, and -10. This is because inner() always looks toward zero on the number line, so the value returned by inner() must always be greater than or equal to the value provided when it is negative, and less than or equal to the value provided when it is positive.


outer proc

See also:
  ceil proc
  inner proc
  floor proc

Format:
  outer(value)

Args:
  value: A number to be rounded.

Returns:
  The nearest whole number away from zero on a number line.

Example:

world << outer(10)
world << outer(5.5)
world << outer(-1.5)
world << outer(0.5)
world << outer(-0.5)
world << outer(-10)


The above example will output 10, 6, -2, 1, -1, and -10. This is because inner() always looks away from zero on the number line, so the value returned by outer() must always be less than or equal to the value provided when it is negative, and greater than or equal to the value provided when it is positive.


left_x proc

See also:
  center_x proc
  right_x proc
  top_y proc
  center_y proc
  bottom_y proc

Format:
  left_x(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's left bound in world coordinates or null if no loc


Notes:
  This function will return the left x coordinate of the supplied atom, whether it is a movable or turf. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_x and icon width are not.


right_x proc

See also:
  left_x proc
  center_x proc
  top_y proc
  center_y proc
  bottom_y proc

Format:
  right_x(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's right bound in world coordinates or null if no loc


Notes:
  This function will return the right x coordinate of the supplied atom, whether it is a movable or turf. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_x and icon width are not.


center_x proc

See also:
  left_x proc
  right_x proc
  top_y proc
  center_y proc
  bottom_y proc

Format:
  center_x(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's center x bound in world coordinates or null if no loc


Notes:
  This function will return the center x coordinate of the supplied atom, whether it is a movable or turf. This function performs no rounding, so it is possible that the value will be a decimal if bound_width or TILE_WIDTH is an odd number. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_x and icon width are not.


top_y proc

See also:
  left_x proc
  center_x proc
  right_x proc
  center_y proc
  bottom_y proc

Format:
  top_y(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's top y bound in world coordinates or null if no loc


Notes:
  This function will return the top y coordinate of the supplied atom, whether it is a movable or turf. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_y and icon height are not.


bottom_y proc

See also:
  left_x proc
  center_x proc
  right_x proc
  top_y proc
  center_y proc


Format:
  bottom_y(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's bottom y bound in world coordinates or null if no loc


Notes:
  This function will return the bottom y coordinate of the supplied atom, whether it is a movable or turf. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_y and icon height are not.


center_y proc

See also:
  left_x proc
  center_x proc
  right_x proc
  top_y proc
  bottom_y proc


Format:
  center_y(ref)

Args:
  ref: An atom.

Returns:
  The absolute pixel position of the atom's center y bound in world coordinates or null if no loc


Notes:
  This function will return the center y coordinate of the supplied atom, whether it is a movable or turf. This function performs no rounding, so it is possible that the value will be a decimal if bound_width or TILE_WIDTH is an odd number. The bottom left coordinate of the world is 0,0 and the top-right coordinate of the world is: world.maxx*TILE_WIDTH-1,world.maxy*TILE_HEIGHT-1. Step and bounding variables for movable atoms are taken into account, but pixel_y and icon height are not.


tan proc

See also:
  cot proc
  sec proc
  csc proc
  arctan proc

Format:
  tan(X)

Returns:
  The tan of X, where X is in degrees.


cot proc

See also:
  tan proc
  sec proc
  csc proc
  arccot proc

Format:
  cot(X)

Returns:
  The cot of X, where X is in degrees.


sec proc

See also:
  tan proc
  cot proc
  csc proc
  arcsec proc

Format:
  sec(X)

Returns:
  The sec of X, where X is in degrees.


csc proc

See also:
  tan proc
  cot proc
  sec proc
  arccsc proc

Format:
  csc(X)

Returns:
  The csc of X, where X is in degrees.


arctan proc

See also:
  arccot proc
  arcsec proc
  arccsc proc
  tan proc

Format:
  arctan(X)

Returns:
  The inverse tan of X in degrees.


arccot proc

See also:
  arctan proc
  arcsec proc
  arccsc proc
  cot proc
Format:
  arccot(X)

Returns:
  The inverse cot of X in degrees.


arcsec proc

See also:
  arctan proc
  arccot proc
  arccsc proc
  sec proc

Format:
  arcsec(X)

Returns:
  The inverse sec of X in degrees.


arccsc proc

See also:
  arctan proc
  arccot proc
  arcsec proc
  csc proc

Format:
  arccsc(X)

Returns:
  The inverse csc of X in degrees.


atan2 proc

See also:
  getang proc

Format:
  atan2(x,y)

Args:
  x: The x offset of the point where 0 is the origin
  y: The y offset of the point where 0 is the origin

Returns:
  The angle of a line from the origin to the point x,y.

Notes:
  Angles are represented using the standard format in mathematics where 0 is east, 90 is north, 180 is west, and 270 is south. See the standard trigonometric unit circle for more information.


hypotenuse proc

Format:
  hypotenuse(adjacent,opposite)

Args:
  adjacent: The length of the adjacent side of a triangle
  opposite: The length of the opposite side of a triangle

Returns:
  The length of the hypotenuse (adjacent2 + opposite2).


findtext_all proc

See also:
  findtextEx_all proc

Format:
  findtext_all(Haystack,Needle)

Returns:
  A list containing every position of Needle in Haystack.

Args:
  Haystack: The text string to search.
  Needle: The sub-text to search for.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is findtextEx_all().


findtextEx_all proc

See also:
  findtext_all proc

Format:
  findtext_all(Haystack,Needle)

Returns:
  A list containing every position of Needle in Haystack.

Args:
  Haystack: The text string to search.
  Needle: The sub-text to search for.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is findtext_all().


str_ends_with proc

See also:
  str_begins_with proc
  str_ends_withEx proc

Format:
  str_ends_with(Text,Subtext)

Returns:
  1 if Text ends with Subtext, 0 otherwise.

Args:
  Text: The text string to check
  Subtext: The sub-text to check for.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is str_ends_withEx().


str_ends_withEx proc

See also:
  str_begins_withEx proc
  str_ends_with proc

Format:
  str_ends_withEx(Text,Subtext)

Returns:
  1 if Text ends with Subtext, 0 otherwise.

Args:
  Text: The text string to check
  Subtext: The sub-text to check for.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is str_ends_with().


str_begins_with proc

See also:
  str_ends_with proc
  str_begins_withEx proc

Format:
  str_begins_with(Text,Subtext)

Returns:
  1 if Text begins with Subtext, 0 otherwise.

Args:
  Text: The text string to check
  Subtext: The sub-text to check for.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is str_begins_withEx().


str_begins_withEx proc

See also:
  str_ends_withEx proc
  str_begins_with proc

Format:
  str_begins_withEx(Text,Subtext)

Returns:
  1 if Text begins with Subtext, 0 otherwise.

Args:
  Text: The text string to check
  Subtext: The sub-text to check for.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is str_begins_with().


str_copy_after proc

See also:
  str_copy_before proc
  str_copy_afterEx proc

Format:
  str_copy_after(Text,Subtext,Start=1)

Returns:
  The portion of the string following the first instance of Subtext found after the Start position or nothing if subtext is not found.

Args:
  Text: A text string.
  Subtext: The sub-text to search for.
  Start: The position to start searching for Subtext.

Notes:
  If the start position is negative, it counts backwards from the end of the string.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is str_copy_afterEx().


str_copy_afterEx proc

See also:
  str_copy_beforeEx proc
  str_copy_after proc

Format:
  str_copy_afterEx(Text,Subtext,Start=1)

Returns:
  The portion of the string following the first instance of Subtext found after the Start position or nothing if subtext is not found.

Args:
  Text: A text string.
  Subtext: The sub-text to search for.
  Start: The position to start searching for Subtext.

Notes:
  If the start position is negative, it counts backwards from the end of the string.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is str_copy_after().


str_copy_before proc

See also:
  str_copy_after proc
  str_copy_beforeEx proc

Format:
  str_copy_before(Text,Subtext,Start=1)

Returns:
  The portion of the string preceding the first instance of Subtext found after the Start position or the entire string if subtext is not found.

Args:
  Text: A text string.
  Subtext: The sub-text to search for.
  Start: The position to start searching for Subtext.

Notes:
  If the start position is negative, it counts backwards from the end of the string.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is str_copy_beforeEx().


str_copy_beforeEx proc

See also:
  str_copy_afterEx proc
  str_copy_before proc

Format:
  str_copy_beforeEx(Text,Subtext,Start=1)

Returns:
  The portion of the string preceding the first instance of Subtext found after the Start position or the entire string if subtext is not found.

Args:
  Text: A text string.
  Subtext: The sub-text to search for.
  Start: The position to start searching for Subtext.

Notes:
  If the start position is negative, it counts backwards from the end of the string.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is str_copy_before().


str_replace proc

See also:
  str_replaceEx proc

Format:
  str_replace(Haystack,FindNeedle,ReplaceNeedle)

Returns:
  The string Haystack with all instances of FindNeedle swapped out for ReplaceNeedle.

Args:
  Haystack: A text string.
  FindNeedle: The sub-text to search for.
  ReplaceNeedle: The sub-text to replace FindNeedle with.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is str_replaceEx().


str_replaceEx proc

See also:
  str_replace proc

Format:
  str_replaceEx(Haystack,FindNeedle,ReplaceNeedle)

Returns:
  The string Haystack with all instances of FindNeedle swapped out for ReplaceNeedle.

Args:
  Haystack: A text string.
  FindNeedle: The sub-text to search for.
  ReplaceNeedle: The sub-text to replace FindNeedle with.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is str_replace().


tokenize proc

See also:
  tokenizeEx proc

Format:
  tokenize(Haystack,Needle)

Returns:
  A list of strings found before each instance of Needle within Haystack. If no instances of Needle are found, the list will contain a single element that is the same as Haystack.

Args:
  Haystack: A text string.
  Needle: The sub-text to search for.

This instruction is NOT sensitive to the case of Haystack or Needle. The case-sensitive version is tokenizeEx().


tokenizeEx proc

See also:
  tokenize proc

Format:
  tokenizeEx(Haystack,Needle)

Returns:
&emps;&emps;A list of strings found before each instance of Needle within Haystack. If no instances of Needle are found, the list will contain a single element that is the same as Haystack.

Args:
  Haystack: A text string.
  Needle: The sub-text to search for.

This instruction is sensitive to the case of Haystack and Needle. The case-insensitive version is tokenize().


trim_whitespace proc

Format:
  trim_whitespace(Text)

Args:
  Text: A text string.

Returns:
  Text with any whitespace characters removed from the beginning and end.

Notes:
  Whitespace characters are ascii characters 9 (character tab), 32 (space), 10 (line feed), 11 (line tab), 12 (form feed), 13 (carriage return), 133 (next line), 160 (non-breaking space).


screen_loc2num proc

Format:
  screen_loc2num(ScreenLoc)

Args:
  ScreenLoc: A screen_loc string in the format: "tile_x:pixel_x,tile_y:pixel_y".

Returns:
  A list containing the x pixel coordinate in index 1 and y pixel coordinate in index 2.

Notes:
  Do not feed this the screen_loc of an object. This is only meant for use in reading mouse proc parameters. If you need to know the pixel coordinates of an object on the string, you should be storing that information yourself.


ismovable proc

Format:
  ismovable(Ref)

Args:
  Ref: An object instance.

Returns:
  1 if Ref is derived from /atom/movable; 0 otherwise.


islist proc

Format:
  islist(Ref)

Args:
  Ref: A value.

Returns:
  1 if Ref is a list of type /list; 0 otherwise.


ang2dir proc

See also:
  dir2ang proc

Format:
  ang2dir(X)

Args:
  X: A number in degrees.

Returns:
  The direction closest to X degrees on the unit circle where 0 is EAST, 90 is NORTH, 180 is WEST, and 270 is SOUTHWEST.

Notes:
  This function can take values greater than 360 and less than 0.


dir2ang proc

See also:
  ang2dir proc

Format:
  dir2ang(Dir)

Args:
  Dir: A direction or bitflag comprised of directions.

Returns:
  The angle associated with the supplied direction or null if the direction is invalid.

Notes:
  This function can take directions in the format of NORTH|SOUTH|EAST, but it will only return 0 in this case, as NORTH and SOUTH cancel out.


dir2text proc

See also:
  text2dir proc

Format:
  dir2text(Dir)

Args:
  Dir: A direction or bitflag comprised of directions.

Returns:
  The string name of the direction or null if the direction is invalid.

Notes:
  This function will return only the 8 compass directions' names.


text2dir proc

See also:
  dir2text proc

Format:
  text2dir(String)

Args:
  String: The name of a direction.

Returns:
  The direction associated with the string; null if not valid.

Notes:
  This function will return only the 8 compass directions. It is not case sensitive, but there must not be a space between component directions such as "northeast".


getang proc

See also:
  atan2 proc

Format:
  getang(srcRef,destRef)

Args:
  srcRef: The atom that is the source of the ray.
  destRef: The atom that is the destination of the ray.

Returns:
  The angle between the center of srcRef and destRef in degrees.
Jul 17 2015, 10:50 am (Edited on Jul 17 2015, 3:51 pm)
appearance interface

The appearance interface is a type that is useful for interacting with appearances. It contains all the same variables as an appearance so that you can access appearances that you get from atoms, images and overlays lists without resorting to the look-up operator ":", or casting the appearance to an incorrect type.

This is useful for avoiding runtime errors and also showing compiler errors where you have made mistakes in your code.

The appearance datum contains all the variables that internal appearances do. That includes the following:

  • alpha
  • blend_mode
  • color
  • density
  • desc
  • dir
  • gender
  • icon
  • icon_state
  • invisibility
  • infra_luminosity
  • layer
  • luminosity
  • maptext
  • maptext_width
  • maptext_height
  • maptext_x
  • maptext_y
  • mouse_over_pointer
  • mouse_drag_pointer
  • mouse_drop_pointer
  • mouse_drop_zone
  • mouse_opacity
  • name
  • opacity
  • list/overlays
  • override (image appearances only)
  • pixel_x
  • pixel_y
  • pixel_z
  • suffix
  • screen_loc
  • text
  • transform
  • list/underlays
  • list/verbs


Example:
mob
    verb
        debug_overlay_layers()
            var/appearance/a
            for(var/v in overlays)
                a = v
                world << a.layer

Note:
  This type should never be initialized. You should only use it for casting appearances. They will delete themselves instantly if you try to initialize one.
  Further, you should never change any of the values in an appearance because appearances are immutable. This type is only for cleaner, safer investigation of appearances.
  Finally, you cannot iterate through overlays or underlays using the for(var/appearance/a in overlays) pattern. The loop will fail because the datum type appearance is not the internal appearance type, and datum appearances cannot be added to overlays or underlays.
Jul 17 2015, 10:50 am (Edited on Jul 17 2015, 4:33 pm)
Cleanup proc (datum)

This proc is intended to be overidden. Any variable that needs to be cleared in order to cause an object to be garbage collected should be handled here. This is an alternative to calling del() on an object, because manual deletion of objects is incredibly slow.

When at all possible, store references circularly in order to make it easier to ensure that garbage collection is being done without the need for manual deletion.

It is also best to avoid storing mob or obj references directly in variables if they aren't intended to log off with the object that they are stored in. You should probably always store players in variables using indirect references using tags if they are meant to be long-lived. If that is unavoidable, use the circular reference pattern.

Format:
  Cleanup()

Default action:
  None

Example:
mob
    var/tmp
        mob/target
        list/targeters
    proc
        Target(mob/newtarget)
            //notify the old target it is no longer targeted
            if(target)
                target.Untargeted(src)
            target = newtarget
            //tell the new target that it's being targeted
            if(newtarget)
                newtarget.Targeted(src)

        Untarget(mob/oldtarget)
            if(target==oldtarget)
                target.Untargeted(src)
                target = null

        Targeted(mob/targeter)
            if(!targeters) //if targeters is not initialized
                targeters = list(targeter) //initialize it as a list
            else
                targeters += targeter //otherwise, add targeter to the list

        Untargeted(mob/targeter)
            targeters -= targeter //remove targeter from the list
            if(!targeters.len) //if the list is now empty
                targeters = null //deinitialize it

    Cleanup()
        target(null) //remove our target
        //manage the targeters list
        for(var/mob/m in targeters)
            m.Untarget(src)
        ..() //always call the parent function when you are done



Cleanup proc (client)

This proc is intended to be overridden. Any variable that needs to be cleared in order to cause a client to be garbage collected should be handled here. Since clients are never garbage collected, this function explicitly deletes the client.

While this function does nothing except call del src anyway, it is included for consistency's sake.

See also:
  Cleanup proc (datum)

Format:
  Cleanup()

Default Action:
  delete the client.


Cleanup proc (movable atom)

This proc is intended to be overridden. Any variable that needs to be cleared in order to cause this movable atom to be garbage collected should be managed here.

See also:
  Cleanup proc (datum)

Format:
  Cleanup()

Default Action:
  Sets the movable's loc to null.


Cleanup proc (turf)

This proc is intended to be overidden. Any variable that needs to be cleared in order to cause this turf to be garbage collected should be managed here. Since turfs are never truly garbage collected, all this function does is create a new turf of type world.turf in place of this one.

See also:
  Cleanup proc (datum)

Format:
  Cleanup()

Default Action:
  Create a new turf of type world.turf in place of this one.


Cleanup proc (area)

This proc is intended to be overidden. Any variable that needs to be cleared in order to cause this area to be garbage collected should be managed here. This is simply an alias that calls del src on the area.

See also:
  Cleanup proc (datum)

Format:
  Cleanup()

Default Action:
  Calls del src on the area
Jul 17 2015, 10:51 am
Reserved for Mouse Module
Jul 17 2015, 10:51 am
Reserved for Keyboard Module
Jul 17 2015, 5:07 pm
Alright, seven hours is enough for me. I'll get to the Mouse and Keyboard module when I can. Honestly, the mouse module probably needs to be scrapped completely because it's poorly designed.
Jul 18 2015, 3:49 pm
You are an animal! Great work so far!
Jul 20 2015, 7:46 am
What kind of stuff are you needing for the mouse module? I using a very efficient mouse tracking procedure for my project, maybe it couldn't hurt to look at?