This file was written for release 1.2 of DGD.

DGD is a rewrite from scratch of the LPMud server.  It runs on Windows, MacOS,
BeOS and many versions of Unix.  Binaries and source for the latest stable
release of DGD can be found at:

    ftp://ftp.imaginary.com/pub/LPC/servers/DGD/

DGD's home page is at:

    http://www.dworkin.nl/dgd/

Please report bugs to <felix@dworkin.nl>.


This distribution is organized as follows:

bin		Installation binaries will be created here (Unix & BeOS).
doc		Documentation, currently still very incomplete.
mud		A minimal mudlib called the kernel library, which is
		distributed together with, but not part of DGD.  The kernel
		library is in the public domain.
src		Where the source of DGD resides, and where you issue your
		`make' command on Unix or BeOS.
src/host/*	Subdirectories for various platform-dependent files.  For
		historical reasons, files for Windows are in src/host/pc.
tmp		The place where temporary files, such as the swap file, are
		created by DGD.

See the file doc/Platforms for help on compiling DGD on various platforms.
Also consult the src/host/*/README file for your platform, if there is one.


The following significant changes have been made since version 1.1 (for
a full list, consult the file src/Changelog):

 - A generic string parser has been added, which parses strings using a
   context-free grammar and regular expressions; see the file doc/parser.
 - Functions can now be `atomic'.  An error that occurs while executing an
   atomic function will roll back all changes made by that function,
   including calls to other functions.  Calls to atomic functions can be
   safely nested.  There is one limitation: file writing operations are not
   possible from atomically executed code.
 - A new typechecking mode has been added, selected by setting the config
   variable `typechecking' to 2.  This introduces the constant `nil' as
   a value distinct of integer 0.  String, object, array and mapping values
   will be initialized as nil.  The kfuns allocate(), allocate_int() and
   allocate_float() allocate an array of nil values, integer 0 values, and
   floating point 0.0 values, respectively.
 - `varargs' can now be used in the argument list of a function, to specify
   that only the following arguments are optional, rather than all of them.
   In typechecking mode 2, this is the only allowed use of varargs.
 - Callouts can now have millisecond delays, using a float delay argument.
   A callout with a delay of 0 will be executed immediately after termination
   of the current thread.
 - A new kfun millitime() was added.
 - Blocking of user input is now possible with the new block_input() kfun.
 - New kfuns query_ip_name() and send_datagram() were added.
 - ANSI C equivalent math functions have been implemented as kfuns.
 - New kfuns hash_crc16() and hash_md5() were added.
 - DGD has been made restartable without quitting on Windows, Mac and BeOS.


DGD 1.2 has changed behaviour in one significant way: the semantics of
send_message() have changed, and the function message_done() is now
called in the user object whenever the output buffer has drained --
not just after a message couldn't be sent completely right away.  One
effect of this is that the kernel library that came with DGD 1.1 may
not work with later versions.  This is because the standard user object
in the old version of the kernel library does not have a message_done()
function.  To get it to work, add the following function to
/kernel/lib/user.c:

    int message_done()
    {
	return MODE_NOCHANGE;
    }


*WARNING*

It is possible to use statedumps created by DGD 1.1 with 1.2.  However, you
must first make sure that there are no partially upgraded objects in the
statedump that DGD 1.1 (or any version prior to 1.1.97) created.

A partially upgraded object is a clone whose master object has been
recompiled, but which itself hasn't been upgraded yet.  DGD 1.2 handles
these objects differently, and attempting to use it on a statedump with
old-style partially upgraded objects will result in crashes and trashed
statedumps.

Getting rid of partially upgraded objects is very simple: when restoring
state from a statedump file, DGD automatically upgrades any left-over
partially upgraded objects.  So, if you have a statedump file that might
contain a partially upgraded object, restart your old DGD with it, and
then let it create a new statedump immediately, or at least without
recompiling any objects in the meantime.  The resulting statedump file
will be guaranteed free of partially upgraded objects, and can safely be
used by DGD 1.2.

It is <not> possible to restore a statedump created by DGD 1.2 with any
earlier version.