Exit_info(3)                                                      Exit_info(3)



NNAAMMEE
       Exit_info -

SSYYNNOOPPSSIISS
   PPuubblliicc MMeetthhooddss
       mapping qquueerryy__eexxiitt (mixed exit)
       mixed qquueerryy__eexxiitt__hhaannddllee (string room, string link)
       mixed qquueerryy__eexxiitt__vvaarr (mixed exit, string var)
       int sseett__eexxiitt__vvaarr (mixed exit, string var, mixed val)
       int rreemmoovvee__eexxiitt__vvaarr (mixed exit, string var)
       mixed aadddd__eexxiitt (string room1_name, string room2_name)
       mixed rreemmoovvee__eexxiitt (mixed exit)
       void uuppddaattee__rroooomm__eexxiittss ()
       mixed ggeett__eexxiitt__iinnddeexx (object ob)
       int * qquueerryy__rroooomm__iinnddiicceess (string name)
       mapping * qquueerryy__eexxiittss ()
       varargs mixed qquueerryy__rroooomm__eexxiittss (string name)
       void sseett__eexxiittss (mapping *m)
       void sseett__rroooomm__eexxiittss (mapping m)

   PPuubblliicc AAttttrriibbuutteess
       mapping * eexxiittss = ({ })
       mapping rroooomm__eexxiittss = ([ ])

DDEETTAAIILLEEDD DDEESSCCRRIIPPTTIIOONN
       The information, generally stored in the area object, which holds exit
       information. Stores all the exit connecting objects within this area.

       Definition at line 7 of file exit_info.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
   mmiixxeedd aadddd__eexxiitt ((ssttrriinngg rroooomm11__nnaammee,, ssttrriinngg rroooomm22__nnaammee))
       Adds an exit connecting room1 to room2. The exit's 'handle' is
       returned. Note that the exit handle may be either an integer or a
       string, so be flexible. Note that either one of the rooms may be a
       fully qualified room reference; this function figures out correct
       referencing on its own. If either one of the exits is not in this area,
       then an inter-area exit is created, and the returned handle will be a
       string. If the rooms are both within this area, then the returned
       handle will be an integer.

       Note that find_room() must return objects for both rooms, or this
       function will fail.

       RReettuurrnnss::
           An exit handle on success, -1 on failure (0 is a valid exit
           handle).

       Definition at line 152 of file exit_info.c.

       References get_exit_index(), and set_exit_var().

   mmiixxeedd ggeett__eexxiitt__iinnddeexx ((oobbjjeecctt oobb))
       A low level function for constructing exit indices. It is recursive.
       You should call aadddd__eexxiitt(()) to create new exits.

       Definition at line 267 of file exit_info.c.

       References exits.

       Referenced by add_exit().

   mmaappppiinngg qquueerryy__eexxiitt ((mmiixxeedd eexxiitt))
       RReettuurrnnss::
           The mapping for a single exit. It will return 0 if the exit does
           not exist.

       NNoottee::
           If the _e_x_i_t parameter is an integer, it is the index of the exit.
           Bounds checking is done. If it is a string, then it is assumed to
           be a recursive exit reference. If the reference is valid, the exit
           is returned, otherwise 0 is.

       Definition at line 35 of file exit_info.c.

       References exits.

       Referenced by query_exit_handle(), query_exit_var(), and
       query_room_exits().

   mmiixxeedd qquueerryy__eexxiitt__hhaannddllee ((ssttrriinngg rroooomm,, ssttrriinngg lliinnkk))
       \retun The handle for the exit in _r_o_o_m whose link is given by _l_i_n_k. I
       have to use link, since not all exits necessarily have associated
       directions.

       Definition at line 71 of file exit_info.c.

       References query_exit(), and room_exits.

   mmiixxeedd qquueerryy__eexxiitt__vvaarr ((mmiixxeedd eexxiitt,, ssttrriinngg vvaarr))
       RReettuurrnnss::
           the value of the variable _v_a_r in the exit given by the handle _e_x_i_t.

       Definition at line 83 of file exit_info.c.

       References query_exit().

   mmaappppiinngg** qquueerryy__eexxiittss (())
       RReettuurrnnss::
           The array of *all* the exits in this area. This can be very big, so
           handle with care.

       Definition at line 293 of file exit_info.c.

       References exits.

   vvaarraarrggss mmiixxeedd qquueerryy__rroooomm__eexxiittss ((ssttrriinngg nnaammee))
       RReettuurrnnss::
           If you pass in no parameters, this will return the mapping of rooms
           with their corresponding indices. If you pass in a _n_a_m_e, then it
           will return an array of the exit mappings for that room (not the
           indices). If you want the indices for a room, use
           qquueerryy__rroooomm__iinnddiicceess(()) (but be warned, indices may contain references
           to outer rooms). Note that these two return types are different!
           You get back a mapping if you pass in a 0, but an array if you pass
           in a name. Note that when passing in a name, you'll get an empty
           array even if the room doesn't exist.

       Definition at line 307 of file exit_info.c.

       References query_exit(), and room_exits.

   iinntt** qquueerryy__rroooomm__iinnddiicceess ((ssttrriinngg nnaammee))
       RReettuurrnnss::
           An array of all the exit indices associated with a room. Note that
           some of them may be strings. This will always return an array.

       Definition at line 283 of file exit_info.c.

       References room_exits.

   mmiixxeedd rreemmoovvee__eexxiitt ((mmiixxeedd eexxiitt))
       Deletes an exit and all associated information. The exit given by the
       handle _e_x_i_t is deleted; this handle may be a recursive one, and should
       still work fine.

       RReettuurrnnss::
           The handle of the removed exit on success, -1 on failure.

       Definition at line 189 of file exit_info.c.

       References exits, and update_room_exits().

   iinntt rreemmoovvee__eexxiitt__vvaarr ((mmiixxeedd eexxiitt,, ssttrriinngg vvaarr))
       Delete an exit variable; used to invert the set_exit_var call.

       Definition at line 124 of file exit_info.c.

       References exits.

   iinntt sseett__eexxiitt__vvaarr ((mmiixxeedd eexxiitt,, ssttrriinngg vvaarr,, mmiixxeedd vvaall))
       Sets one of the variables associated with an exit. The only variable
       that is guaranteed useful for all types of exits is 'handler' -- this
       is the object in /world/exits that is used for managing exit behavior.
       The handle can be an integer or a string (use the returned value when
       you created the exit).

       RReettuurrnnss::
           True on success, false on failure.

       Definition at line 97 of file exit_info.c.

       References exits.

       Referenced by add_exit().

   vvooiidd sseett__eexxiittss ((mmaappppiinngg ** mm))
       Sets the exits mapping directly. _m must be an array, or this call will
       be quietly ignored. Be very careful not to corrupt exit data; for
       efficiency, the exit routines will usually assume that data is
       correctly formatted!

       Definition at line 322 of file exit_info.c.

       References exits.

   vvooiidd sseett__rroooomm__eexxiittss ((mmaappppiinngg mm))
       Sets the mapping of room exits directly. It is required that this be a
       mapping -- any other datatype is quietly ignored.

       Definition at line 329 of file exit_info.c.

       References room_exits.

   vvooiidd uuppddaattee__rroooomm__eexxiittss (())
       Rebuilds the room_exits mapping. There are two reasons to do this: It
       is an easy way to fix things if you break them accidentally (which is
       easy enough, if you don't know what you're doing), and it might
       actually get used by some highly obscure, complex exit modification
       scheme. Your pick.

       Definition at line 219 of file exit_info.c.

       References room_exits.

       Referenced by remove_exit().

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
   mmaappppiinngg** eexxiittss == (({{ }}))
       An array of this form: ({ ([ ... ]), ([ ... ]), ... }) Basically, each
       mapping in the array represents an exit. Exits are then referenced by
       number. room knows which exits belong to it because they are given in
       room_exits.

       Definition at line 15 of file exit_info.c.

       Referenced by get_exit_index(), query_exit(), query_exits(),
       remove_exit(), remove_exit_var(), set_exit_var(), and set_exits().

   mmaappppiinngg rroooomm__eexxiittss == (([[ ]]))
       A mapping of arrays of ints: ([ 'room1': ({ 7, 12, ... }), 'room2': ({
       3, 6, ... }), ... ]) Each room has an associated array of ints. They
       are indices into the exits mapping.

       Definition at line 20 of file exit_info.c.

       Referenced by query_exit_handle(), query_room_exits(),
       query_room_indices(), set_room_exits(), and update_room_exits().


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



Walraven                          8 Jan 2004                      Exit_info(3)
