Some terms on mud programming

LPC - The language the mud is programmed in, a language like C.

Object Oriented Programming - A programming style in which all elements are
   treated as objects. Objects consist of variables and functions through
   which to manipulate those variables. Functions can be called by other
   functions or by the game driver. Objects can use each other's functions
   by means of inheritance or cloning.

Game driver - This is the program that actually runs the mud on the
   machine. It keeps track of which objects to create, keep around or
   get rid of, it handles efuns and maintains player connections.

Mudlib - (mud library) This is the code that defines the objects of this
   particular mud. This is the parts wizards can add their areas to.

Objects - For the mud, just about everything is an object. A sword, a beer,
   the room you're in, you, and even things that you don't see in the
   player world, like the guild master and other coordinating objects.

Variables - These are the units that store the data an object needs,
   like a room's description or a monster's level. There are six types:
      status - this can only contain the values 0 or 1
      int - (integer) can contain any whole number
      string - can contain text, which must be enclosed between 
      object - well, what else, it points to an object
      mapping - in mappings you can store pairs of variables the first
         variable must be of type string, the second may be any type.
         mappings are inclosed by ( ).
      mixed -  use this type if the variable NEEDS to be able to store
         more than one type of data.
      array - an array is not a variable type as such: you always have
         an array OF another type of variable. an array is no more than
         a collection of variables, enclosed by ({ }).

Functions - Functions are pieces of code that manipulate data. Functions
   have types, just like variables, depending on the kind of data they
   return. Functions that don't return data are of type void. Functions
   are written as: type function_name( argument list ) { code block }
   where the argument lists consists of variables that may be passed to
   this function from the function that called it. There are three
   categories of functions:
      efuns - (external functions) which are defined by the driver. You
         can't see their code block.
      lfuns - (local functions) are reserved functions coded in objects
         in the mudlib, often because they may be called by the driver.
      other functions you code - technically they are the same as lfuns,
         except for the fact that they don't have reserved names.

