Simul_efun(3)                                                    Simul_efun(3)



NNAAMMEE
       Simul_efun - Defines 'simulated external functions' which may be called
       from any object.

SSYYNNOOPPSSIISS
   PPuubblliicc MMeetthhooddss
       void ccrreeaattee ()
       object ffiinndd__ppllaayyeerr (string name)
       int iiss__lliivviinngg (object ob)
       void iinnsseerrtt__lliivviinngg (string name, object ob)
       protected void sseett__lliivviinngg__nnaammee (string name)
       nomask varargs object ffiinndd__lliivviinngg (string name, object env)
       nomask object * aallll__lliivviinngg (string name)
       nomask string * aallll__lliivviinngg__nnaammeess ()
       int ffiillee__ttiimmee (string path)
       void lloogg__ffiillee (string file, string str)
       varargs string ggeett__llooccaattiioonn (object whome, object fromme)
       string vveerrssiioonn ()
       public object * aallll__eennvviirroonnmmeenntt (object ob)
       public varargs string bbrreeaakk__ssttrriinngg (string str, int width, int indent)
       int iiss__cclloonnee (mixed ob)
       varargs void ddeebbuugg (string words, string channel)
       string ffiillee__nnaammee (object ob)
       string ssttiimmee (int time)
       string iinntt__ttoo__ttiimmee (int x)
       mixed * aarrrraayy__ddeelleettee (mixed *arr, int i)
       void sseett__ttaarrggeett (object ob)
       void sseett__aaccttoorr (object ob)
       object qquueerryy__ttaarrggeett ()
       object qquueerryy__aaccttoorr ()
       void sseett__ddiirreeccttiioonn (string str)
       string qquueerryy__ddiirreeccttiioonn ()
       void sseett__aaddvveerrbb (string x)
       string qquueerryy__aaddvveerrbb ()
       void sseett__lliisstteenneerr (object who)
       varargs string pprroocceessss__ggrraammmmaarr (string fmt, object dest)
       varargs string pprroocceessss__aannssii (string fmt, object dest)
       varargs void tteellll__rroooomm (object ob, string str)
       object qquueerryy__mmeesssseennggeerr ()
       varargs void mmssgg (string words, int indent)
       varargs string pprroocceessss__ccooddeess (string words)
       varargs void mmssgg__bbaarree (string words)
       varargs void mmssgg__oobbjjeecctt (object ob, string words, int indent)
       varargs void mmssgg__aallll (string words, int indent)
       varargs void mmssgg__rroooomm (object ob, string words, int indent)
       void aannnnoouunnccee (string words)
       string ttaabb (string tabstr, int count)
       int ccssttrrlleenn (string str)
       string ppaadd (string str, int count, int just)
       string ccoommmmaa__lliisstt (mixed in)
       varargs object * aallll__pprreesseenntt (string id, object env, object
           *ignored_objects)
       string iinnvveennttoorryy__ssttrriinngg (object *oblist)
       varargs void aadddd__iinntteerrffaaccee (string name, string prompt)
       varargs void sshhiifftt__iinntteerrffaaccee (string name, string prompt)
       void ddrroopp__iinntteerrffaaccee ()
       void sseett__iinntteerrffaaccee__ccaattcchh (int enable)
       int qquueerryy__ttoo__iinntt__ffaaiill ()
       int ttoo__iinntt (mixed num)
       string aass__ssttrriinngg (mixed s)
       string cclleeaannuupp__ssttrriinngg (string str)
       int lleeggaall__ffiilleennaammee (string fname)
       int vvaalliidd__mmaanniippuullaattee (object actor, object env)
       int ffiillee__eexxiissttss (string path)
       varargs int qquueerryy__rreeaadd__aacccceessss (string file, object whose)
       varargs int qquueerryy__wwrriittee__aacccceessss (string file, object whose)
       void ssttrriinngg__eeddiitt (string func, string data)
       void sseett__gglloobbaall__ddeesscc__vvaarr (string var, mixed val)
       mixed qquueerryy__gglloobbaall__ddeesscc__vvaarr (string var)
       protected string eevvaall__ddeesscc__vvaarr (string var, object env)
       protected string * sspplliitt__eexxpp (string exp)
       protected string eevvaall__ccoonndd__eexxpp (string exp, object env)
       varargs string eevvaall__eexxpp (string exp, object env)
       int sseenndd__iimm (string name, string message)
       varargs mixed aass__llppcc (mixed var, int simple)
       varargs object ffiinndd__rroooomm (string addr, object startpoint)
       varargs nomask int ccoommmmaanndd (string comm, object dest)
       varargs object pprreesseenntt (mixed str, object env)
       varargs object ssiinnggllee__pprreesseenntt (string str, object env, object
           *exclude_objects)
       varargs string ffiinndd__ppaatthh (string map, int startx, int starty, int
           goalx, int goaly, mapping costs, int map_width)
       object * lliimmiitt__wweeiigghhtt (object *oblist, int weight)
       object * lliimmiitt__bbuullkk (object *oblist, int bulk)

   PPuubblliicc AAttttrriibbuutteess
       mapping nnaammee__lliivviinngg__mm = ([])
       mapping lliivviinngg__nnaammee__mm = ([])
       string EESSCCAAPPEE
       mapping ddeesscc__vvaarrss
       string vvaalliidd__cchhaarrss
       mapping pprroonnoouunnss
       mapping aannssiittaabb
       mapping nnooaannssiittaabb
       string ssppaaccee__ppaadd
       mapping __mmoonntthhss
       object __ttaarrggeett
       object __aaccttoorr
       string __ddiirreeccttiioonn
       object __lliisstteenneerr
       object __mmeesssseennggeerr
       int wwrraapp__wwiiddtthh
       nosave private int iinntt__ffaaiill__ffllaagg

DDEETTAAIILLEEDD DDEESSCCRRIIPPTTIIOONN
       Defines 'simulated external functions' which may be called from any
       object.

       The simul_efun file defines functions that may be used anywhere. It is
       not a normal object and, as such, shouldn't be cloned or inherited. You
       may use these functions directly, as if they were built into the
       MUDlib. This allows the MUDs functionality to be extended easily.

       This is a mudlib file. It belongs in /secure/simul_efun.c. The master
       object (generally /secure/master.c) will load it as one of its first
       actions.

       Note: Originally this was a simul_efun from some lib included with
       Amylaar's 3.2.1 driver. However, to my knowledge, not a single line of
       code remains from that original file; it's all been either rewritten or
       pruned.

       You may destruct/reload the simul_efun object without harmful effects
       -- upon destruction, it stores its most important variables (the living
       mappings) on the master object, and upon reloading, it retrieves them.

       Definition at line 33 of file simul_efun.c.

MMEEMMBBEERR FFUUNNCCTTIIOONN DDOOCCUUMMEENNTTAATTIIOONN
   vvaarraarrggss vvooiidd aadddd__iinntteerrffaaccee ((ssttrriinngg nnaammee,, ssttrriinngg pprroommpptt))
       Adds an interface to this_player().

       PPaarraammeetteerrss::

       _n_a_m_e   The function used for the interface. Prefix '@' to the function
              name if you want a character-by-character interface.

       _p_r_o_m_p_t (Not needed for char-by-char) The prompt printed to the player.

       Definition at line 1703 of file simul_efun.c.

   ppuubblliicc oobbjjeecctt** aallll__eennvviirroonnmmeenntt ((oobbjjeecctt oobb))
       Gives an array of all containers which an object is in, i.e. match in
       matchbox in bigbox in chest in room, would for the match give:
       matchbox, bigbox, chest, room

       PPaarraammeetteerrss::

       _o_b     The object

       RReettuurrnnss::
           The array of containers.

       Definition at line 346 of file simul_efun.c.

   nnoommaasskk oobbjjeecctt** aallll__lliivviinngg ((ssttrriinngg nnaammee))
       RReettuurrnnss::
           An array of all living objects whose living_name is _n_a_m_e. If there
           are no living objects with that name, 0 is returned.

       Definition at line 257 of file simul_efun.c.

       References name_living_m.

   nnoommaasskk ssttrriinngg** aallll__lliivviinngg__nnaammeess (())
       RReettuurrnnss::
           An array of all the names of all the living objects in the world.
           To get more information on them, use ffiinndd__lliivviinngg(()) or aallll__lliivviinngg(()),
           passing in the name.

       Definition at line 273 of file simul_efun.c.

       References name_living_m.

   vvaarraarrggss oobbjjeecctt** aallll__pprreesseenntt ((ssttrriinngg iidd,, oobbjjeecctt eennvv,, oobbjjeecctt **
       iiggnnoorreedd__oobbjjeeccttss))
       Returns a list of objects identified by the string id. The types of
       descriptors that can be recognized are defined as follows:

       <simple> -- A simple object reference.

       Example: table

       <location> -- A locational object reference. Uses PREP_EXP to get a
       list of valid prepositions for object locations. The format is <simple>
       [<preposition> <location>]. Note that evaluation of environment
       <simple>'s doesn't currently handle plural objects, only singular ones
       (so 'get all the fish from the bags on the table' would only look in
       the first bag on the table).

       Example: the bag on the table

       <numobj> -- [all [of]] [the|The] [<num>] [nearest|furthest|farthest]
       <location>

       Example: the second dog --- third fish --- all five potions --- the
       three nearest potions

       <objlist> -- <numobj> | <numobj>, <objlist> | <numobj> and <objlist> |
       <numobj>, and <objlist>

       Example: table, dog, and cat --- table and dog, cat --- table, dog and
       cat

       Evaluation:

       <simple> -- Find the first object whose iidd(()) returns true. If the
       query_is_plural() doesn't match the search string, stop looking,
       otherwise keep going and grab all the rest of the objects whose iidd(())
       strings match. Plural evaluation may be forced.

       <location> -- Search through the word list looking for any
       prepositions. If any are found, search for the surrounding halves as if
       they were simple expressions. Plural evaluation may be forced if a
       query_is_plural() matches.

       <numobj> -- If 'all' or 'all of' occur as a prefix they force a plural
       evaluation of the <location> object reference. Numeric references may
       be of these types:

       #.<location>

       <numword> <location> where numword is any of 'first, second, third...'
       etc.

       <num> <location> where num is any of '1st, 2nd, 3rd, 4th...' etc.

       <count> <location> where num is any of 'one, two, three...' or '1, 2,
       3...'. In this case, you should count off however many objects before
       stopping evaluation. If a direct article occurs before the 'number
       word' it is simply stripped.

       <objlist> -- A list of object references. The <numobj> grammar is used
       for evaluating individual objects in a list. These should be split
       before being passed on, using ',' ', and' and 'and' as delimiters.

       PPaarraammeetteerrss::

       _i_d     The string to be checked for, i.e. 'all the apples on the table'

       _e_n_v    (Optional) The object in which you wish the search to begin.
              Usually the room the player is in, or the player himself. If
              omitted, defaults to the player himself (inventory).

       _i_g_n_o_r_e_d___o_b_j_e_c_t_s
              (Optional) An array of objects which will be quietly ignored.
              Useful for a 'wield' command that wishes to ignore already
              wielded weapons, for example.

       NNoottee::
           This function doesn't solve all your problems, it is just a tool.
           For example, a 'get' function would still need to implement 'from'
           as a keyword for getting objects from inside other objects;
           however, it could parse the remainder of the expression by passing
           the phrases on either side of from to this function. In addition,
           since this function looks for objects that are already present, a
           'put' expression would need to find a preposition and parse to
           either side of it, since the object is not yet present in the place
           specified.

       Definition at line 1456 of file simul_efun.c.

       References present(), and pronouns.

       Referenced by single_present().

   vvooiidd aannnnoouunnccee ((ssttrriinngg wwoorrddss))
       Sends a message to everyone listening to the 'announce' channel. The
       standard [Announce] prefix is NOT added.

       Definition at line 1074 of file simul_efun.c.

   mmiixxeedd** aarrrraayy__ddeelleettee ((mmiixxeedd ** aarrrr,, iinntt ii))
       Returns _a_r_r with the ith element deleted. Unlike exclude_element, this
       leaves the remaining elements unshuffled (they are scooted down).

       Definition at line 538 of file simul_efun.c.

   vvaarraarrggss mmiixxeedd aass__llppcc ((mmiixxeedd vvaarr,, iinntt ssiimmppllee))
       Similar to the as_string function, with the difference that this one's
       strings can be converted back into code when you're done. For example,
       if you have this string:

       \'Can you see me?\' says the clown.'


       Note that this function does not work with closures.

       TTooddoo::
           This function will currently recurse forever if passed a recursive
           array or mapping (a fool thing to do in any case). I'd rather it
           did something intelligent, such as fill in recursing arrays or
           mappings with '<RECURSE>' or something.

       If you pass in true for the optional _s_i_m_p_l_e flag, it will give you a
       less decorated display of arrays and mappings (unindented, no
       comments).

       Definition at line 2173 of file simul_efun.c.

       References as_string().

   ssttrriinngg aass__ssttrriinngg ((mmiixxeedd ss))
       Converts any data type to a string. Even works for arrays and mappings!

       Definition at line 1807 of file simul_efun.c.

       Referenced by as_lpc(), and comma_list().

   ppuubblliicc vvaarraarrggss ssttrriinngg bbrreeaakk__ssttrriinngg ((ssttrriinngg ssttrr,, iinntt wwiiddtthh,, iinntt iinnddeenntt))
       Breaks a continous string without newlines into a string with newlines
       inserted at regular intervalls replacing spaces Each newline separeted
       string can be indented with a given number of spaces.

       PPaarraammeetteerrss::

       _s_t_r    Original message

       _w_i_d_t_h  The total maximum width of each line.

       _i_n_d_e_n_t (optional) How many spaces to indent with. Maximum 80
              characters.

       RReettuurrnnss::
           A string with newline separated strings

       NNoottee::
           Recently updated to ignore ANSI codes. It should now ignore all
           types of codes, although note that codes to clear the screen, etc.,
           will still do odd things to word-wrapping.

       Definition at line 376 of file simul_efun.c.

       References ESCAPE.

       Referenced by msg(), and msg_object().

   ssttrriinngg cclleeaannuupp__ssttrriinngg ((ssttrriinngg ssttrr))
       Removes control codes from a string, excepting
        and \r. This function is optimized quite heavily, so may be used on
       larger strings. The purpose of this function is to take a string
       containing unknown characters (such as the contents of a file) and
       allow you to send it to a terminal without side effects. I created this
       function when I found out certain of the codes stored in player files
       were attempting to trigger my terminal's ZModem download capabilities.

       Definition at line 1823 of file simul_efun.c.

       References valid_chars.

   ssttrriinngg ccoommmmaa__lliisstt ((mmiixxeedd iinn))
       Passed either an array of strings or a '

       For example, comma_list('one\ntwo\nthree'); would return 'one, two and
       three'

       PPaarraammeetteerrss::

       _i_n     The list you wish to be converted to a comma- separated list.
              Either a string * or a string.

       Definition at line 1141 of file simul_efun.c.

       References as_string().

       Referenced by eval_exp(), and inventory_string().

   vvaarraarrggss nnoommaasskk iinntt ccoommmmaanndd ((ssttrriinngg ccoommmm,, oobbjjeecctt ddeesstt))
       Hopefully patch the whole left by the ccoommmmaanndd(()) efun.

       Definition at line 2345 of file simul_efun.c.

   vvooiidd ccrreeaattee (())
       Not callable externally. This function is used to build some useful
       global variables used in simul_efun.

       WARNING! This is a highly sensitive function! You cannot put very much
       in here, and that includes call_other functions. Be very careful!

       Definition at line 80 of file simul_efun.c.

       References ansitab, desc_vars, ESCAPE, living_name_m, name_living_m,
       noansitab, pronouns, space_pad, and valid_chars.

   iinntt ccssttrrlleenn ((ssttrriinngg ssttrr))
       RReettuurrnnss::
           strlen(str) after stripping out color codes (~CXYZ and ~[###).

       Definition at line 1087 of file simul_efun.c.

   vvaarraarrggss vvooiidd ddeebbuugg ((ssttrriinngg wwoorrddss,, ssttrriinngg cchhaannnneell))
       Sends a message on the debug channel. Messages are delayed by about two
       seconds (to avoid certain kinds of recursion). You must have the debug
       channel enabled to hear debug messages.

       Debug has been altered to bypass the mudwide chat system. As a result,
       I don't know if problems of aforementioned recursion might present
       themselves - Al [6/26/03]

       Definition at line 452 of file simul_efun.c.

       References msg_object().

       Referenced by file_name().

   vvooiidd ddrroopp__iinntteerrffaaccee (())
       Drops this_player()'s current interface, reverting to the previous one.
       Interfaces are stackable.

       Definition at line 1736 of file simul_efun.c.

   pprrootteecctteedd ssttrriinngg eevvaall__ccoonndd__eexxpp ((ssttrriinngg eexxpp,, oobbjjeecctt eennvv))
       Used by eevvaall__eexxpp(()) to evaluate conditional expressions of the form
       ?(...), with the ? and () already stripped.

       Definition at line 2027 of file simul_efun.c.

       References desc_vars, eval_desc_var(), and eval_exp().

       Referenced by eval_exp().

   pprrootteecctteedd ssttrriinngg eevvaall__ddeesscc__vvaarr ((ssttrriinngg vvaarr,, oobbjjeecctt eennvv))
       Looks up the description variable recorded for _v_a_r. If _v_a_r does not
       exist, false (0) will be returned. Otherwise, the behavior will depend
       on the datatype of _v_a_r:

       int: The integer will be converted to a string and returned.

       string: The string is returned.

       closure: The closure is evaluated, and its value is returned. You may
       pass a single string parameter to the closure by including it in
       parentheses as part of _v_a_r, i.e. 'OBJECT(small dog)'. If you pass
       arguments to any other datatype, it will be ignored.

       array of strings: A random string from the array is returned. Invalid
       datatypes will return the string '<inval:varname>' with varname giving
       the value of _v_a_r.


       Definition at line 1985 of file simul_efun.c.

       References desc_vars.

       Referenced by eval_cond_exp(), and eval_exp().

   vvaarraarrggss ssttrriinngg eevvaall__eexxpp ((ssttrriinngg eexxpp,, oobbjjeecctt eennvv))
       Evaluates a conditional description. This is a recursive descent
       parser, so statements may be embedded within other statements. This is
       a (simple) sample statement:

       The weather is ?(SUNNY:sunny)?(!SUNNY:not sunny).

       This reads the value of SUNNY (a description variable, see
       sseett__gglloobbaall__ddeesscc__vvaarr(())); if it is true (set), then the statement
       evalutes to 'sunny', otherwise it evaluates to 'not sunny'. Here is a
       quick syntax rundown:

       ?(CONDITON_LIST:true result) -- where CONDITION_LIST is a comma
       separated list of conditions which are evaluated using a short-circuit
       boolean AND. If all the conditions are true, then the 'true result'
       string is returned, otherwise the empy string is returned. Conditions
       are of the form [!]COND[(args)], where args is any string (though it
       may not have parentheses () or commas , in it). Note that the
       true_result and false_result strings will also be run through eval_exp,
       so they may contain nested expressions.

       There is a shorthand for 'else' statements. Whenever an expression is
       evaluated, it sets the _LASTCOND variable to 1 (if the evaluation
       succeeded) or 0 (if it did not). You can enter

       :(any expression here)

       as a shorthand for

       ?(!_LASTCOND:any expression here)

       This is generally faster than re-evaluating the expression, and is a
       huge help if the original expression is complex and hard to invert.

       Another useful addition is the possibility of using an 'OR' marker. To
       do this, simply prefix a '|' (pipe character) to the front of your
       expression, like this:

       ?(|SUNNY, |!RAINY:exp)

       exp is used if SUNNY is true *or* if RAINY is false. Note that the OR
       '|' symbol must appear before the NOT '!' symbol. Mixing normal and OR
       variables is pointless; the OR variables will be ignored.

       ,(item1[\nitem2[\nitem3..]]) -- returns a comma-separated list. See
       ccoommmmaa__lliisstt(()).

        -- returns the evaluated value (see eevvaall__ddeesscc__vvaarr(()))

       Definition at line 2109 of file simul_efun.c.

       References comma_list(), desc_vars, eval_cond_exp(), eval_desc_var(),
       and split_exp().

       Referenced by eval_cond_exp(), msg(), msg_bare(), msg_object(),
       process_codes(), and process_grammar().

   iinntt ffiillee__eexxiissttss ((ssttrriinngg ppaatthh))
       RReettuurrnnss::
           True if the file given by 'path' exists. This function will return
           false if _p_a_t_h represents a directory.

       PPaarraammeetteerrss::

       _p_a_t_h   The name of the file whose existence you wish to check.

       Definition at line 1894 of file simul_efun.c.

       References legal_filename().

   ssttrriinngg ffiillee__nnaammee ((oobbjjeecctt oobb))
       Deprecated function detector :-).

       Definition at line 482 of file simul_efun.c.

       References debug().

   iinntt ffiillee__ttiimmee ((ssttrriinngg ppaatthh))
       Gets the modification time for a file. If the file does not exist, -1
       is returned. The time is given as an integer -- use ctime() or ssttiimmee(())
       on the integer to make it human readable.

       PPaarraammeetteerrss::

       _p_a_t_h   The full path of the file.

       Definition at line 282 of file simul_efun.c.

   nnoommaasskk vvaarraarrggss oobbjjeecctt ffiinndd__lliivviinngg ((ssttrriinngg nnaammee,, oobbjjeecctt eennvv))
       Finds a living object whose living name is _n_a_m_e. If passed only one
       parameter, it will first search environment(this_player()) for a living
       matching 'name', and if no such living is found, it will select one of
       the living objects in the world with that name, and return a pointer to
       it, or 0 if there is no such living anywhere. If passed two parameters,
       it will choose one of the living objects inside of _e_n_v named _n_a_m_e, and
       return a pointer to it. Again, it returns 0 on failure.

       See also sseett__lliivviinngg__nnaammee(()). Note that living searches done in the local
       room need only match the iidd(()) function, but global searches must match
       the living name exactly.

       Definition at line 221 of file simul_efun.c.

       References is_living(), and name_living_m.

   vvaarraarrggss ssttrriinngg ffiinndd__ppaatthh ((ssttrriinngg mmaapp,, iinntt ssttaarrttxx,, iinntt ssttaarrttyy,, iinntt ggooaallxx,,
       iinntt ggooaallyy,, mmaappppiinngg ccoossttss,, iinntt mmaapp__wwiiddtthh))
       Returns the shortest path from point (startx,starty) to point
       (goalx,goaly) in wswwnwwwsse form. The A* algorithm is used with
       Manhattan distance used as a minimum cost heuristic. This code is
       fairly efficient.

       PPaarraammeetteerrss::

       _m_a_p    The map, as a \n delimited string. The map will be processed
              into lines, and each line will be made the same width by adding
              \27 (escape) characters onto the end of each line -- it would
              therefore be ideal if you did not use escapes as a walkable
              character. Note that the format is a little different if you
              specify _m_a_p___w_i_d_t_h -- it will then assume that the map is an
              even, square grid.

       _s_t_a_r_t_x The x coordinate at which you begin searching.

       _s_t_a_r_t_y The y coordinate at which you begin searching.

       _g_o_a_l_x  The x coordinate you wish to reach

       _g_o_a_l_y  The y coordinate you wish to reach

       _c_o_s_t_s  A mapping of character to cost. Characters not appearing in the
              mapping are presumed solid.

       _m_a_p___w_i_d_t_h
              (Optional) The width of the grid given in _m_a_p. If not given,
              then a \n delimited map is assumed. If the grid isn't a perfect
              rectangle, the short line at the end is thrown away.Allaryin
              wishes it to be abundantly clear that he had nothing to do with
              this code, and wants you to blame me (Acius) instead.

       Definition at line 2418 of file simul_efun.c.

   oobbjjeecctt ffiinndd__ppllaayyeerr ((ssttrriinngg nnaammee))
       Finds the player whose qquueerryy__nnaammee(()) function returns _n_a_m_e. If no such
       player can be found, returns 0. The player need not be present.

       Definition at line 145 of file simul_efun.c.

   vvaarraarrggss oobbjjeecctt ffiinndd__rroooomm ((ssttrriinngg aaddddrr,, oobbjjeecctt ssttaarrttppooiinntt))
       Returns an object pointer for the room/object referenced by addr. The
       room references are in a semicolon separated format, such as
       ;reality;westcontinent;castle;room92;sword. This also recognizes the
       keywords 'world' and 'env', and can handle relative references when
       _s_t_a_r_t_p_o_i_n_t is specified.

       PPaarraammeetteerrss::

       _a_d_d_r   The semicolon delimited list for the object you are referencing.

       _s_t_a_r_t_p_o_i_n_t
              (Optional) An object pointer from which to start relative
              references. For players, the startpoint is themself. For rooms,
              the startpoint is the room itself.

       Definition at line 2274 of file simul_efun.c.

       References present().

   vvaarraarrggss ssttrriinngg ggeett__llooccaattiioonn ((oobbjjeecctt wwhhoommee,, oobbjjeecctt ffrroommmmee))
       RReettuurrnnss::
           the location of an object in the world as a semicolon delimited
           object reference. find_room(get_location(obj)) returns obj. If the
           _f_r_o_m_m_e parameter is given, the reference will be relative to
           fromme.

       PPaarraammeetteerrss::

       _w_h_o_m_e  The object whose location you wish to find.

       _f_r_o_m_m_e (OObbjjeecctt) The object to start looking from; if it isn't
              specified, the world is used.

       Definition at line 319 of file simul_efun.c.

   vvooiidd iinnsseerrtt__lliivviinngg ((ssttrriinngg nnaammee,, oobbjjeecctt oobb))
       Adds a living object to the mapping of living objects. Similar to
       set_living_name, except that you may specify which object is to be
       added as the second parameter.

       PPaarraammeetteerrss::

       _n_a_m_e   The name of the living object.

       _o_b     A pointer to the living object whose name is being added.

       Definition at line 168 of file simul_efun.c.

       References is_clone(), living_name_m, and name_living_m.

       Referenced by set_living_name().

   ssttrriinngg iinntt__ttoo__ttiimmee ((iinntt xx))
       Converts an integer number of seconds to a string giving the length of
       the time period in days, hours, minutes and seconds.

       Definition at line 511 of file simul_efun.c.

   ssttrriinngg iinnvveennttoorryy__ssttrriinngg ((oobbjjeecctt ** oobblliisstt))
       Returns a prettified string giving the array of objects passed in as a
       comma seperated list. This checks for both recognition (using name
       instead of distant) and duplicates (three wolves instead of a wolf, a
       wolf, and a wolf).

       Definition at line 1658 of file simul_efun.c.

       References comma_list().

   iinntt iiss__cclloonnee ((mmiixxeedd oobb))
       RReettuurrnnss::
           True if ob is an object pointer and a clone. This is done by
           checking the file name for a #.

       PPaarraammeetteerrss::

       _o_b     The object.

       Definition at line 439 of file simul_efun.c.

       Referenced by insert_living().

   iinntt iiss__lliivviinngg ((oobbjjeecctt oobb))
       RReettuurrnnss::
           True if _o_b is a living object.

       Definition at line 157 of file simul_efun.c.

       Referenced by find_living().

   iinntt lleeggaall__ffiilleennaammee ((ssttrriinngg ffnnaammee))
       Returns true if _f_n_a_m_e is a legal filename. This does not imply that the
       file exists, only that the filename being requested is syntactically
       legal. Not all possible UNIX-legal filenames will be considered legal
       by this function, but every filename considered legal by this function
       is legal in UNIX as well. Note that '..' is not allowed -- You may wish
       to call /obj/player->make_path_absolute() first if you want to support
       relative paths like that.

       Definition at line 1841 of file simul_efun.c.

       Referenced by file_exists(), query_read_access(), and
       query_write_access().

   oobbjjeecctt** lliimmiitt__bbuullkk ((oobbjjeecctt ** oobblliisstt,, iinntt bbuullkk))
       See lliimmiitt__wweeiigghhtt(()). Does the same thing for bulk.

       Definition at line 2636 of file simul_efun.c.

   oobbjjeecctt** lliimmiitt__wweeiigghhtt ((oobbjjeecctt ** oobblliisstt,, iinntt wweeiigghhtt))
       RReettuurrnnss::
           If the total weight of all the objects in _o_b_l_i_s_t is less than
           weight, it will return a copy of _o_b_l_i_s_t. Otherwise, it will return
           as many of the objects as will fit within the weight limit given.
           If no objects fit, an empty array is returned (Not a perfect 0:1
           knapsack solution, btw, just a useful approximation). Note that it
           will also attempt to split quantity objects.

       Definition at line 2601 of file simul_efun.c.

   vvooiidd lloogg__ffiillee ((ssttrriinngg ffiillee,, ssttrriinngg ssttrr))
       Adds a string onto the end of a log file. The logs are kept in LOG_DIR,
       defined in const.h. This function does not allow you to pass in an
       absolute path (although subpaths off the log directory, like
       sys/syslog, would be allowed).

       PPaarraammeetteerrss::

       _f_i_l_e   The file you wish to add a log entry to.

       _s_t_r    The string to be added to the log file.

       Definition at line 296 of file simul_efun.c.

       References stime().

   vvaarraarrggss vvooiidd mmssgg ((ssttrriinngg wwoorrddss,, iinntt iinnddeenntt))
       The msg class of functions are used as a replacement where possible of
       write and tell_object. This function sends the string in 'words' to
       this_player() (typically the player who is currently performing an
       action). A \n is automatically added on the end, and prompt handling is
       done according to set_message_mode() in player. If you don't want the
       prompt handling and the automatic \n, use mmssgg__bbaarree(()).

       PPaarraammeetteerrss::

       _w_o_r_d_s  A string containing the message you wish to display.

       _i_n_d_e_n_t (optional) the number of spaces for a hanging indent. All lines
              are indented after the first one (if you wish to indent the
              first line, add some spaces of your own! See ttaabb(())).

       Definition at line 975 of file simul_efun.c.

       References break_string(), eval_exp(), process_ansi(),
       process_grammar(), and wrap_width.

   vvaarraarrggss vvooiidd mmssgg__aallll ((ssttrriinngg wwoorrddss,, iinntt iinnddeenntt))
       Sends a message to ALL players using msg_object.

       PPaarraammeetteerrss::

       _w_o_r_d_s  A string containing the message you wish to display.

       _i_n_d_e_n_t (optional) the number of spaces for a hanging indent. All lines
              are indented after the first one (if you wish to indent the
              first line, add some spaces of your own! See ttaabb(()))

       Definition at line 1040 of file simul_efun.c.

       References msg_object().

   vvaarraarrggss vvooiidd mmssgg__bbaarree ((ssttrriinngg wwoorrddss))
       Writes a message to this_player(). No \n is added to the end, and
       prompt handling is ignored. All of the usual processing is still
       performed, however. If you don't want processing, use write().

       PPaarraammeetteerrss::

       _w_o_r_d_s  A string containing the message you wish to display.

       Definition at line 1007 of file simul_efun.c.

       References eval_exp(), process_ansi(), and process_grammar().

   vvaarraarrggss vvooiidd mmssgg__oobbjjeecctt ((oobbjjeecctt oobb,, ssttrriinngg wwoorrddss,, iinntt iinnddeenntt))
       Writes a message to ob. Automatically adds a \n and does message
       handling according to set_message_mode() in player. If you don't want
       message handling or process_string(), use tell_object().

       PPaarraammeetteerrss::

       _o_b     An object pointer -- the person who is to receive this message.

       _w_o_r_d_s  A string containing the message you wish to display.

       _i_n_d_e_n_t (optional) the number of spaces for a hanging indent. All lines
              are indented after the first one (if you wish to indent the
              first line, add some spaces of your own! See ttaabb(()))

       Definition at line 1024 of file simul_efun.c.

       References break_string(), eval_exp(), process_ansi(),
       process_grammar(), and wrap_width.

       Referenced by debug(), msg_all(), and msg_room().

   vvaarraarrggss vvooiidd mmssgg__rroooomm ((oobbjjeecctt oobb,, ssttrriinngg wwoorrddss,, iinntt iinnddeenntt))
       Sends a message to all objects inside of ob using msg_object. This is
       mainly appropriate for broadcasting into a room from elsewhere. Actions
       performed by living objects within the room are usually best done using
       msg_local in the performer.

       PPaarraammeetteerrss::

       _o_b     The room in which to broadcast the message.

       _w_o_r_d_s  A string containing the message you wish to display.

       _i_n_d_e_n_t (optional) the number of spaces for a hanging indent. All lines
              are indented after the first one (if you wish to indent the
              first line, add some spaces of your own! See ttaabb(()))

       Definition at line 1059 of file simul_efun.c.

       References msg_object(), and set_listener().

   ssttrriinngg ppaadd ((ssttrriinngg ssttrr,, iinntt ccoouunntt,, iinntt jjuusstt))
       Pads or truncates a string to be exactly _c_o_u_n_t characters long. Your
       string should not contain tilde or ANSI codes, or you will have strange
       side effects.

       PPaarraammeetteerrss::

       _s_t_r    The string to pad.

       _c_o_u_n_t  The desired length of the string. Note that this function has
              problems if the number of spaces to add is greater than 512 (if
              you need more than this, modify the simul_efun ccrreeaattee(())).

       _j_u_s_t   Justification for the string. If _j_u_s_t == JUST_LEFT, then padding
              will be added to the right of the string, if just == JUST_RIGHT
              then padding is added on the left (right justify), and if just
              == JUST_CENTER the string will be centered. The constants for
              justification are in const.h

       NNoottee::
           The latest sprintf functions are more powerful than this function
           is by a long shot; if you want real string processing power, go
           look it up; this one is simpler to use, however.

       RReettuurrnnss::
           The padded string.

       Definition at line 1107 of file simul_efun.c.

       References space_pad.

   vvaarraarrggss oobbjjeecctt pprreesseenntt ((mmiixxeedd ssttrr,, oobbjjeecctt eennvv))
       A replacement for the pprreesseenntt(()) efun. The primary difference is that
       this one respects the returning of an object from iidd(()) as a method of
       redirection.

       Definition at line 2357 of file simul_efun.c.

       Referenced by all_present(), and find_room().

   vvaarraarrggss ssttrriinngg pprroocceessss__aannssii ((ssttrriinngg ffmmtt,, oobbjjeecctt ddeesstt))
       process_ansi is used locally by all msg class functions. It is used to
       process ANSI codes *only*. This function should only be called ONCE per
       string, otherwise escaped tildes (the ~TILD code) will be treated as
       normal tildes, which will give wrong results occasionally.

       PPaarraammeetteerrss::

       _f_m_t    The string (with ~ codes in it)

       _d_e_s_t   (Optional) The person who will actually receive this string. If
              necessary, this may be someone other than the listener (see
              set_listener). This is not really significant grammatically, it
              is mainly used to decide whether to use ANSI colors or not.

       NNoottee::
           This function should be called before break_string, otherwise the
           linewrapping will have errors.

       Definition at line 878 of file simul_efun.c.

       References ansitab, and noansitab.

       Referenced by msg(), msg_bare(), msg_object(), and process_codes().

   vvaarraarrggss ssttrriinngg pprroocceessss__ccooddeess ((ssttrriinngg wwoorrddss))
       Processes expressions, ANSI codes, and grammar in _w_o_r_d_s, and returns
       the processed result. Do this, then linewrap, and you get the same
       result as one of the mmssgg(()) functions.

       Definition at line 997 of file simul_efun.c.

       References eval_exp(), process_ansi(), and process_grammar().

   vvaarraarrggss ssttrriinngg pprroocceessss__ggrraammmmaarr ((ssttrriinngg ffmmtt,, oobbjjeecctt ddeesstt))
       process_grammar is used locally by all msg class functions. It scans a
       string and converts formatted text (all ~xxxx material) into the
       correct format (i.e. ~name is this player's name). You should usually
       call sseett__aaccttoorr(()), sseett__ttaarrggeett(()), and sseett__lliisstteenneerr(()) before you call this
       function -- these set up the messaging environment for handling
       grammar. If the messager you're processing doesn't need grammar, you
       don't have a problem.

       See verb.c for how to use verb conjugations.

       PPaarraammeetteerrss::

       _f_m_t    The string (with ~ codes in it)

       _d_e_s_t   (Optional) The person who will actually receive this string. If
              necessary, this may be someone other than the listener (see
              set_listener). This is not really significant grammatically, it
              is mainly used to decide whether to use ANSI colors or not.

       NNoottee::
           This function should be called before break_string, otherwise the
           linewrapping will have errors.

       Definition at line 648 of file simul_efun.c.

       References _actor, _direction, _listener, _target, and eval_exp().

       Referenced by msg(), msg_bare(), msg_object(), and process_codes().

   oobbjjeecctt qquueerryy__aaccttoorr (())
       RReettuurrnnss::
           The value most recently passed to sseett__aaccttoorr(()).

       Definition at line 580 of file simul_efun.c.

       References _actor.

   ssttrriinngg qquueerryy__aaddvveerrbb (())
       RReettuurrnnss::
           The currently set adverb.

       Definition at line 611 of file simul_efun.c.

   ssttrriinngg qquueerryy__ddiirreeccttiioonn (())
       RReettuurrnnss::
           The most recently set direction from sseett__ddiirreeccttiioonn(()).

       Definition at line 596 of file simul_efun.c.

       References _direction.

   mmiixxeedd qquueerryy__gglloobbaall__ddeesscc__vvaarr ((ssttrriinngg vvaarr))
       A debugging function.

       Definition at line 1968 of file simul_efun.c.

       References desc_vars.

   oobbjjeecctt qquueerryy__mmeesssseennggeerr (())
       Returns the last object to execute a write or msg function.

       Definition at line 951 of file simul_efun.c.

       References _messenger.

   vvaarraarrggss iinntt qquueerryy__rreeaadd__aacccceessss ((ssttrriinngg ffiillee,, oobbjjeecctt wwhhoossee))
       Queries whether an object has access to read a file/directory. Returns
       true if access is allowed. See also query_write_access. Does not check
       for file existence.

       PPaarraammeetteerrss::

       _f_i_l_e   Full path to the file/directory to read.

       _w_h_o_s_e  Which object will perform the read. this_object() if not
              specified.

       Definition at line 1913 of file simul_efun.c.

       References legal_filename().

   oobbjjeecctt qquueerryy__ttaarrggeett (())
       RReettuurrnnss::
           The value most recently passed to sseett__ttaarrggeett(()).

       Definition at line 574 of file simul_efun.c.

       References _target.

   iinntt qquueerryy__ttoo__iinntt__ffaaiill (())
       Returns true if the previous call to to_int failed.

       Definition at line 1780 of file simul_efun.c.

       References int_fail_flag.

   vvaarraarrggss iinntt qquueerryy__wwrriittee__aacccceessss ((ssttrriinngg ffiillee,, oobbjjeecctt wwhhoossee))
       Queries whether an object has write access to a file/directory. Returns
       true if access would be allowed. If you do not have access, then
       attempting access generates an error. This allows you to check for the
       error conditions before they happen. If the file/directory does not
       exist, returns true if you would be allowed to create it.

       PPaarraammeetteerrss::

       _f_i_l_e   Full path to the file/directory you want to write.

       _w_h_o_s_e  Which object will be writing to the file. If not specified,
              this_object() is assumed.

       Definition at line 1929 of file simul_efun.c.

       References legal_filename().

   iinntt sseenndd__iimm ((ssttrriinngg nnaammee,, ssttrriinngg mmeessssaaggee))
       A simple function to send an instant message to a wizard. An instant
       message will reach the wizard either immediately (if they are logged
       on) or as soon as they log on again. The message is sent from
       this_player().

       PPaarraammeetteerrss::

       _n_a_m_e   The name of the recipient. If they are not online, it will be
              sent to the mailbox of the same name.

       RReettuurrnnss::
           True on success. Currently always returns true, as the instant
           messenger functions have no fail conditions.

       Definition at line 2144 of file simul_efun.c.

   vvooiidd sseett__aaccttoorr ((oobbjjeecctt oobb))
       Sets the actor which the ~name escape codes refer to.

       PPaarraammeetteerrss::

       _o_b     An object pointer for the actor; usually this_player(). This is
              not the name.

       Definition at line 568 of file simul_efun.c.

       References _actor.

   vvooiidd sseett__aaddvveerrbb ((ssttrriinngg xx))
       Allows you to set the current adverb. If players give an adverb before
       their verbs, this will be called; you can use qquueerryy__aaddvveerrbb(()) to fetch
       it.

       Definition at line 606 of file simul_efun.c.

   vvooiidd sseett__ddiirreeccttiioonn ((ssttrriinngg ssttrr))
       Pass in any string. The ~dirc code will be replaced by the string which
       you pass in in subsequent calls to msg functions or process_string.
       This is typically used for directions, i.e. Bob leaves ~dirc -> Bob
       leaves north.

       Definition at line 591 of file simul_efun.c.

       References _direction.

   vvooiidd sseett__gglloobbaall__ddeesscc__vvaarr ((ssttrriinngg vvaarr,, mmiixxeedd vvaall))
       Allows you to set a description variable. By convention, description
       variables are all UPPER CASE, but this is not enforced. See
       eevvaall__ddeesscc__vvaarr(()) for possible things you can set them to. You may delete
       variables from the desc_vars mapping by setting them to 0.

       PPaarraammeetteerrss::

       _v_a_r    The name of the description variable

       _v_a_l    The value for the description variable -- int, string, array, or
              closure.

       Definition at line 1960 of file simul_efun.c.

       References desc_vars.

   vvooiidd sseett__iinntteerrffaaccee__ccaattcchh ((iinntt eennaabbllee))
       Designates a function to handle text received by this_player() while
       the current interface is active. This does not effect text printed by
       the interface object itself. Be warned, this is a little difficult to
       do well. See TTeexxttddrraaww for useful functions for handling catch
       terminals, and FFuulllleeddiitt for an example.

       Definition at line 1751 of file simul_efun.c.

   vvooiidd sseett__lliisstteenneerr ((oobbjjeecctt wwhhoo))
       The listener is a variable you should set whenever using formatted
       strings. The listener tells who is 'listening' to this text, so that
       the verb conjugation and name/pronoun codes can be interpreted
       correctly. Send in an *object pointer* for whoever is listening.

       Definition at line 623 of file simul_efun.c.

       References _listener.

       Referenced by msg_room().

   pprrootteecctteedd vvooiidd sseett__lliivviinngg__nnaammee ((ssttrriinngg nnaammee))
       Call this function from your living objects in their initialization
       code to add them to the searchable database of living objects.

       PPaarraammeetteerrss::

       _n_a_m_e   The name by which the object should be referenced

       Definition at line 203 of file simul_efun.c.

       References insert_living().

   vvooiidd sseett__ttaarrggeett ((oobbjjeecctt oobb))
       Sets the target which the ~targ escape codes refer to.

       PPaarraammeetteerrss::

       _o_b     An object pointer for the target (not the name).

       Definition at line 561 of file simul_efun.c.

       References _target.

   vvaarraarrggss vvooiidd sshhiifftt__iinntteerrffaaccee ((ssttrriinngg nnaammee,, ssttrriinngg pprroommpptt))
       Shifts this_player()'s interface to an alternative handler. This is
       used to transfer control from one interface to another. It is the same
       as ddrroopp__iinntteerrffaaccee(()) followed by an aadddd__iinntteerrffaaccee(()), except that the
       prompts will be handled correctly (if you do a drop followed
       immediately by an add, you get strange prompt spam).

       Definition at line 1721 of file simul_efun.c.

   vvaarraarrggss oobbjjeecctt ssiinnggllee__pprreesseenntt ((ssttrriinngg ssttrr,, oobbjjeecctt eennvv,, oobbjjeecctt **
       eexxcclluuddee__oobbjjeeccttss))
       Allows you to get a *single* object, but with all the parsing that
       all_present allows. In essence, it uses all_present, then gives back
       the first thing.

       The _e_n_v parameter is required, and specifies which object should be
       searched.

       Definition at line 2382 of file simul_efun.c.

       References all_present().

   pprrootteecctteedd ssttrriinngg** sspplliitt__eexxpp ((ssttrriinngg eexxpp))
       Used by eevvaall__eexxpp(()) and others to find matching parentheses -- a simple
       sscanf is insufficient, since it doesn't handle nesting properly.

       Definition at line 2006 of file simul_efun.c.

       Referenced by eval_exp().

   ssttrriinngg ssttiimmee ((iinntt ttiimmee))
       Generates timestamps of the form: dd.mm.yy hh:mm

       Definition at line 493 of file simul_efun.c.

       References _months.

       Referenced by log_file().

   vvooiidd ssttrriinngg__eeddiitt ((ssttrriinngg ffuunncc,, ssttrriinngg ddaattaa))
       This function uses this_player()'s editor (a clone of the object given
       as a filename in the editor environment variable) to edit the string
       passed in as data (editors should handle being passed a 0 for data, in
       which case they should start with a blank string). As soon as the
       editor has finished editing the string in question, it will be passed
       back as a parameter to _f_u_n_c in the calling object.

       PPaarraammeetteerrss::

       _f_u_n_c   The function in your object that will be called when editing is
              finished.

       _d_a_t_a   The initial value for the variable being edited.

       TTooddoo::
            Not implemented yet.

       Definition at line 1948 of file simul_efun.c.

   ssttrriinngg ttaabb ((ssttrriinngg ttaabbssttrr,, iinntt ccoouunntt))
       RReettuurrnnss::
           _t_a_b_s_t_r, concatenated with itself _c_o_u_n_t times. For example, if you
           need a string of 80 spaces, call tab( ' ', 80 );

       Definition at line 1081 of file simul_efun.c.

   vvaarraarrggss vvooiidd tteellll__rroooomm ((oobbjjeecctt oobb,, ssttrriinngg ssttrr))
       An implementation of tteellll__rroooomm(()) (which is not an efun)

       Definition at line 937 of file simul_efun.c.

   iinntt ttoo__iinntt ((mmiixxeedd nnuumm))
       Converts an integer or a string to an integer.

       RReettuurrnnss::
           The integer extracted from 'num.'

       NNoottee::
           This function does return 0 on failure, but if you pass it '0' then
           it will return 0 even if it is a success. The only way to be sure
           is to call the qquueerryy__ttoo__iinntt__ffaaiill(()) function, which will return 1 if
           the previous call to to_int failed.

       Definition at line 1791 of file simul_efun.c.

       References int_fail_flag.

   iinntt vvaalliidd__mmaanniippuullaattee ((oobbjjeecctt aaccttoorr,, oobbjjeecctt eennvv))
       Determines whether there is a living object blocking _a_c_t_o_r from
       manipulating _e_n_v. For example, this will return true for a player who
       wants to get an apple from a box, but false for a player who wants to
       get an apple from someone else's inventory. It will also return false
       for an object in another room, or inside a closed container
       (query_closed() returns true).

       Definition at line 1877 of file simul_efun.c.

   ssttrriinngg vveerrssiioonn (())
       Returns the current version of the MUDlib driver.

       Definition at line 335 of file simul_efun.c.

MMEEMMBBEERR DDAATTAA DDOOCCUUMMEENNTTAATTIIOONN
   oobbjjeecctt __aaccttoorr
       Used by sseett__aaccttoorr(())

       Definition at line 556 of file simul_efun.c.

       Referenced by process_grammar(), query_actor(), and set_actor().

   ssttrriinngg __ddiirreeccttiioonn
       Used by sseett__ddiirreeccttiioonn(())

       Definition at line 585 of file simul_efun.c.

       Referenced by process_grammar(), query_direction(), and
       set_direction().

   oobbjjeecctt __lliisstteenneerr
       Used by sseett__lliisstteenneerr(())

       Definition at line 616 of file simul_efun.c.

       Referenced by process_grammar(), and set_listener().

   oobbjjeecctt __mmeesssseennggeerr
       Used by qquueerryy__mmeesssseennggeerr(())

       Definition at line 933 of file simul_efun.c.

       Referenced by query_messenger().

   mmaappppiinngg __mmoonntthhss
       Used by ssttiimmee(()) to convert month names to numbers

       Definition at line 488 of file simul_efun.c.

       Referenced by stime().

   oobbjjeecctt __ttaarrggeett
       Used by sseett__ttaarrggeett(())

       Definition at line 554 of file simul_efun.c.

       Referenced by process_grammar(), query_target(), and set_target().

   mmaappppiinngg aannssiittaabb
       A list of the most common ANSI codes used.

       Definition at line 69 of file simul_efun.c.

       Referenced by create(), and process_ansi().

   mmaappppiinngg ddeesscc__vvaarrss
       Holds description variables (for conditional descriptions).

       Definition at line 56 of file simul_efun.c.

       Referenced by create(), eval_cond_exp(), eval_desc_var(), eval_exp(),
       query_global_desc_var(), and set_global_desc_var().

   ssttrriinngg EESSCCAAPPEE
       Initialized to contain the escape character.

       Definition at line 53 of file simul_efun.c.

       Referenced by break_string(), and create().

   nnoossaavvee pprriivvaattee iinntt iinntt__ffaaiill__ffllaagg
       Used by qquueerryy__ttoo__iinntt__ffaaiill(())

       Definition at line 1777 of file simul_efun.c.

       Referenced by query_to_int_fail(), and to_int().

   mmaappppiinngg lliivviinngg__nnaammee__mm == (([[]]))
       A mapping keyed by object pointer to find living objects' names.

       Definition at line 50 of file simul_efun.c.

       Referenced by create(), and insert_living().

   mmaappppiinngg nnaammee__lliivviinngg__mm == (([[]]))
       A mapping keyed by name to find living objects.

       Definition at line 48 of file simul_efun.c.

       Referenced by all_living(), all_living_names(), create(),
       find_living(), and insert_living().

   mmaappppiinngg nnooaannssiittaabb
       A list of the most common ANSI codes used.

       Definition at line 69 of file simul_efun.c.

       Referenced by create(), and process_ansi().

   mmaappppiinngg pprroonnoouunnss
       A list of valid pronouns for objects: him, her, it, them.

       Definition at line 65 of file simul_efun.c.

       Referenced by all_present(), and create().

   ssttrriinngg ssppaaccee__ppaadd
       A long string of spaces, usable by ppaadd(()).

       Definition at line 72 of file simul_efun.c.

       Referenced by create(), and pad().

   ssttrriinngg vvaalliidd__cchhaarrss
       A 256-character-long string that is used as a table for getting rid of
       control characters from strings in cclleeaannuupp__ssttrriinngg(())

       Definition at line 61 of file simul_efun.c.

       Referenced by cleanup_string(), and create().

   iinntt wwrraapp__wwiiddtthh
       Internally used to give the screen width to wrap for.

       Definition at line 948 of file simul_efun.c.

       Referenced by msg(), and msg_object().


AAUUTTHHOORR
       Generated automatically by Doxygen for Walraven from the source code.



Walraven                          8 Jan 2004                     Simul_efun(3)
