void programming_the_mud(void *anything,...)
{
   /* Programming Diku can be very easy for conventional effects, but */
   /* it gets progressively difficult as the complexity increases.    */
   /* This section is meant to cover the simpler end of this spectrum */
   /* most notably the concept of the spec_proc, and perhaps ease     */
   /* the process of creating "special" things.                       */
   
   /* A few notes about how Diku works:
   
         Diku basically uses a system of default actions to perform
         when commands are entered. These routines are called if no
         other routine decides to claim the command (and there's no
         other problem, like being asleep when trying to leave the
         room). Special procedures attached to rooms, items, and
         mobs all intercept such actions before they reach the
         command interpreter. If any of these procedures chooses to
         process the command itself, it does so and returns TRUE,
         thus halting the processing of the command.
         
         These special procedures are also called at a regular rate
         without being connected to commands. This allows for behavior
         that's unconnected to what anybody else does (such as a
         Janitor picking up trash).
         

         The interface for Copper's spec_procs has been changed from
         standard Diku to let the proc know exactly which mud object
         it is associated with. Obj and room procs have also been
         changed to be called on "ticks" like mob procs are, so that
         they are able to do things which are not in response to
         player actions.
         
*/

#begin PUBLIC_PROCEDURES

   /*** Feel free to call these from within your spec_procs ***/
   
   act(<format string>,<vis flag>,<char>,<obj>,<other>,<to_who>)
   /* This is the recommended way to send information to the players  */
   /* Complete docs can be found in the standard Diku distribution.   */
   /* We recommend using $n, $o, $p, etc. instead of hard coding any  */
   /* names into the string. This lends to reusability of the code,   */
   /* and will handle situations such as invisibility and darkness.   */
   
   log(<string>)
   /* Use this to output extremely bad situations to the log file     */
   /* Unless you do something extravagant, you likely won't use this  */
   
   number(<low>,<high>)
   dice(<number>,<size>)
   /* To get random numbers in a range, or to simulate dice rolls     */
   
   teleport_to(<char>,<real-room number>)
   /* Pretty self-explanatory...to get the real room number for a     */
   /* known virtual number, use real_room(<room v-num>)               */
   
   transact(<from>,<merchandise>,<to>,<value>)
   /* This function can be used for those instances when using the    */
   /* standard shopkeeper() function wouldn't work (where exchanges   */
   /* of money or goods isn't restricted to a particular toom) or     */
   /* the complexity of shopkeeper() is not needed. This function     */
   /* will properly handle situations where there the receiver does   */
   /* not have enough money, or when an item isn't necessarily given  */
   /* (Winky). The routine returns true if the exchange is completed. */
   
   /**                                                               **/
   
   /** The rest of the public routines are called with the same      **/
   /** format as the mob spec_proc itself, and are usable directly   **/
   /** as mob spec_procs without any intervening calling code. Be    **/
   /** sure to respect their return values - if they return TRUE,    **/
   /** then don't do anything more in your proc, and return TRUE as  **/
   /** well - this will prevent strange things from happening.       **/
   
   devour(...)       /* Eat corpses/food like a fido */
   janitor(...)      /* Pick up "trash" */
   poison(...)       /* Bite people */
   shopkeeper(...)   /* When there's an entry in .shp for a shopkeeper*/
                     /* Tell us when you use this in your code, since */
                     /* shopkeepers are usually automatically assigned*/    
   receptionist(...) /* Let someone rent */
   
   /* The following are public routines which relate to the upcoming  */
   /* jailing system. Use only for mobs to be found exclusivly within */
   /* the hometowns (or have a good reason for them to be elsewhere)  */
   
   arrester(...)
   jailkeeper(...)
   judge(...)       /* This proc is not yet written */
   witness(...)     /* The most likely one you'll need to use */

#end PUBLIC_PROCEDURES

}