  Compat vs. Native Mode -- by Mateese
-------------------------------------------------------------------------------
Please refer to /doc/concepts/native for the original documentation.
Please refer to article 'changes' for the changes in the mudlib.

The current gamedriver offers two modes of running, native and compatibility,
each with different features. The compat mode was implemented since there 
hasn't been a true native mudlib at the time the driver was improved.

The main differences are:

 - In native mode, the reset method changes as follows.
   When an object gets created/cloned, it's local fun 'create()' will
    be called by the gamedriver. In compat mode, the driver would
    instead call the local fun 'reset()' with a zero argument.
   Then, as long as the object exists and is used, the local fun
    'reset()' will be called in compat mode with a non-zero argument.
   Therefore, your compat code of:

     reset(flag) {
       if (flag) {
         <warm reset code>
       } else {
         <creational code>
       }
     }

   becomes native like:

     create() {
       <creational code>
     }

     reset(){
       <warm reset code>
     }

 - Most values are stored now as 'Properties'. The advantage of properties
   is that a property might be defined and used independent of an
   objects source. See /doc/concepts/properties.

 - To achieve a more powerful security system, native mode introduces
    userids (uids) for each object. See /doc/concepts/uids and the
    separate article in this lib for a more elaborate discussion.
   In short, two types of uids are distinguished: 
     uid:  The userid of that object(player) which created the source of
           object in question.
     euid: (effective uid) the uid of that object which is responsible
           for the actions of the object in question.

 - Objects can't no longer move other objects with the efun 'move_object()',
    just themselves. Also the efun 'transfer()' is no longer defined.
   Instead, to move an object, it's lfun 'move()' must be called with
    the desired destination and the move-method as arguments.
   At the moment, /std/thing/moving->move() moves the object and
   then returns 1.

 - Objects should only be destructed by themselves. To achieve this,
    the object's lfun 'remove()' must be called.
   The efun 'destruct()' remains, but it's use on other objects should
    be limited to debug or emergency situations.
   At the moment, /std/thing/moving->remove() destructs the object and
   returns 1.

 - In native mode, it is only possible to command() this_object(),
   i.e. 'command("smile", find_player("jrwiz"))' is no longer
   possible. Instead the lfun 'command_me' needs to be called, 
   i.e. 'find_player("jrwiz")->command_me("smile") .

 - A smallie: file_name(object) now returns a string starting with '/'.

 - Besides swapping out the program code of unused objects, there is a
    new way of conserving memory, involving a local fun 'clean_up()' in
    each object. See /doc/concepts/memory' for further details.

 - Filenames may be shortened using the special characters ~ and + .
   Assume the active euid being <euid>:
     ~/<path>       is equal to /players/<euid>/<path>
     ~<user>/<path> is equal to /players/<name>/<path>
     +/<path>       is equal to /d/<euid>/<path>
     +<name>/<path> is equal to /players/<name>/<path>
   
 - The wizard commands 'update' and 'destruct' try to be smart, and
   just call the lfun remove() in the victim object. This of course
   may refuse to destruct the victim.
   There are two new commands, 'Update' and 'Destruct', which are just
   destruct-under-all-circumstances-'update'/'destruct's.

 - The wizard command 'ls' is now performed by the efun get_dir_ext().
   This means that each entry in the dir listing is marked with '/' if
   it's an directory, or an '*' if it's an loaded object file.

 - Long and short descriptions of objects are queried with calls
   to  varargs string QueryLong(string arg)  and  string QueryShort(). 
   Both return a (long/short) description string.

