World(3)                                                              World(3)



NNAAMMEE
       World -

SSYYNNOOPPSSIISS
       Inherits AArreeaa.


   PPuubblliicc MMeetthhooddss
       void wwoorrlldd__ttiimmeedd__ssaavvee ()
       void ssaavvee__sseellff ()
       int qquueerryy__wwoorrlldd__ttiimmeedd__ssaavvee ()
       void llooaadd__sseellff (int x)
       int qquueerryy__llooaadd__iinn__pprrooggrreessss ()
       void ccrreeaattee ()
       string ddeessttrruuccttoorr (object ob)
       string qquueerryy__nnaammee ()

   PPuubblliicc AAttttrriibbuutteess
       nosave int llooaadd__iinn__pprrooggrreessss

DDEETTAAIILLEEDD DDEESSCCRRIIPPTTIIOONN
       This is the world object. All of the world is, eventually, somewhere
       inside of it. The reason that we use a world object is to make the
       saveload system a bit easier. The saveload (more specifically, the
       'inven' component) saves its own state, then sends a signal to each of
       the objects in its inventory, causing them to save their states. This
       cascades down until the whole world state is saved.

       There are other possible ways of handling this, but this one works
       pretty well, so we're keeping it :).

       Note that the world may not be cloned; the master copy of the world
       object is the one used.

       Definition at line 23 of file world.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vooiidd ccrreeaattee (())
       The constructor. This sets up the default state for the world object
       and then has it load itself from disk by calling llooaadd__sseellff(()).

       Reimplemented from AArreeaa.

       Definition at line 72 of file world.c.

       References load_in_progress, Inven::load_object(), load_self(), and
       Desc::name.

   ssttrriinngg ddeessttrruuccttoorr ((oobbjjeecctt oobb))
       Causes an error (cannot destruct) unless the MUD is busy shutting down.

       Reimplemented from OObbjjeecctt.

       Definition at line 93 of file world.c.

   vvooiidd llooaadd__sseellff ((iinntt xx))
       This overrides IInnvveenn::::llooaadd__sseellff, because unlike every other object, the
       world is loaded *before* its unique_id is known. It thus has a constant
       unique_id of 1. Since load_self requires a unique_id to be passed in,
       this function takes a parameter, but it is ignored; the unique_id of
       the world is always assumed to be 1.

       Reimplemented from IInnvveenn.

       Definition at line 59 of file world.c.

       Referenced by create().

   iinntt qquueerryy__llooaadd__iinn__pprrooggrreessss (())
       RReettuurrnnss::
           True, if the world is busy loading.

       Definition at line 65 of file world.c.

       References load_in_progress.

   ssttrriinngg qquueerryy__nnaammee (())
       RReettuurrnnss::
           The string 'world'. Even if you try to set the name to something
           else, this will force it back to being 'world', as this is
           considered a sort of reserved word.

       Reimplemented from DDeesscc.

       Definition at line 103 of file world.c.

       References Desc::name.

   iinntt qquueerryy__wwoorrlldd__ttiimmeedd__ssaavvee (())
       Allows you to check how long it will be until the world next saves
       itself.

       Definition at line 49 of file world.c.

   vvooiidd ssaavvee__sseellff (())
       Save the world!

       Reimplemented from IInnvveenn.

       Definition at line 43 of file world.c.

   vvooiidd wwoorrlldd__ttiimmeedd__ssaavvee (())
       Called from the constructor. A task that causes the world to save
       itself every few hours (depending on the value of WORLD_SAVE_TIME in
       const.h).

       Definition at line 35 of file world.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
   nnoossaavvee iinntt llooaadd__iinn__pprrooggrreessss
       Tracks whether the world is in the middle of loading. Some objects
       might have problems if they try to do something while the world is
       loading, so this can be useful.

       Definition at line 30 of file world.c.

       Referenced by create(), and query_load_in_progress().


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



Walraven                          8 Jan 2004                          World(3)
