/
Sapphire/bin/
Sapphire/db/
Sapphire/db/OLC_rooms/
Sapphire/db/abi/
Sapphire/db/em_src/
Sapphire/db/helps/
Sapphire/db/helps/emman/ifunc/
Sapphire/db/npcs/Tatt/
Sapphire/db/objects/Tatt/
Sapphire/db/q_data/
Sapphire/db/rooms/Tatt/
Sapphire/doc/
Sapphire/doc/em/
Sapphire/etc/
Sapphire/src/abic/
Sapphire/src/areacon/
Sapphire/src/client/
Sapphire/src/embc/
Sapphire/src/emi/
Sapphire/src/emi/test/
Sapphire/src/include/
Sapphire/src/sapphire/em/
Sapphire/src/tcon/
/*
 * Copyright (C) 1995-1997 Christopher D. Granz
 *
 * This header may not be removed.
 *
 * Refer to the file "License" included in this package for further
 * information and before using any of the following.
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <setjmp.h>

#include "sapphire.h"


/*
 * Globals
 */
char *                                                     pProgramName;
jmp_buf                                                        jbReboot;

int                                                         iTelnetPort;
int                                                         iBinaryPort;
int                                                        iMUDCommPort;
sapsocket                                                sTelnetControl;
sapsocket                                                sBinaryControl;
sapsocket                                               sMUDCommControl;

int                                                         iMaxPlayers;
int                                                      iNumberPlayers;

char *                                             pLoginScreenFilename;
time_t                                                     tCurrentTime;

char                                                          cNullChar;
char *                                                         pStrings;
char *                                                      pStringsEnd;
char *                                                      pStringsPos;
long                                                       lStringSpace;

CHILDP_DATA *                                                 pChildren;

char *                                                      pCOFilename;
long                                                       lCurrentLine;

bool                                                       bErrorsFound;
bool                                                     bWarningsFound;

FILE *                                                         pLogFile;

char *                                                    pBootFilename;
char *                                                 pMUDCommFilename;
char *                                                         pTempDir;
char *                                                pShellProgramName;
char *                                                          pLogDir;
char *                                                       pPlayerDir;
char *                                                        pShellDir;
char *                                                   pXWordFilename;
char *                                                pGreetingFilename;
char *                                                 pGoodbyeFilename;
char *                                                    pMOTDFilename;
char *                                                           pEmDir;
char *                                                        pImageDir;
char *                                                         pHelpDir;
char *                                                          pNPCDir;
char *                                                       pObjectDir;
char *                                                         pRoomDir;
char *                                                         pZoneDir;
char *                                                    pQuestDataDir;
char *                                                 pEmUsageFilename;
char *                                                        pGreeting;
char *                                                         pGoodbye;
char *                                                            pMOTD;
char *                                                         pMUDName;

bool                                                       bEmFuncUsage;

long                                                     lLoopStallTime;
long                                                         lEmMaxTime;
int                                                       iHashListSize;

char                                                  cCreationCode[32];
int                                                  iCreationCodeTimer;

bool                                                           bRunning;
int                                                               iMode;
int                                                         iMemoryMode;

TERM_DATA *                                                   pTermFree;
CHAR_DATA *                                                   pCharFree;
OBJ_DATA *                                                     pObjFree;

XWORD_DATA *                                                 pXWordList;
MUD_COMM_DATA *                                            pMUDCommList;
TERM_DATA *                                                   pTermList;
HELP_DATA *                                                   pHelpList;
NPC_INDEX_DATA **                                        ppNPCIndexList;
OBJ_INDEX_DATA **                                        ppObjIndexList;
ROOM_INDEX_DATA **                                      ppRoomIndexList;
ZONE_DATA *                                                   pZoneList;
QUEST_DATA *                                             pQuestDataList;
CHAR_DATA **                                                 ppCharList;
OBJ_DATA **                                                   ppObjList;

RUNNING_SCRIPT_DATA *                                pRunningScriptList;

int                                                       iMaxShowCount;


/*
 * Tables
 */
const char                                              cLetterTable[] =
{
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
    '\0'
};

const char *                                        pWordNumberTable[] =
{
    "zero",         "one",          "two",           "three",
    "four",         "five",         "six",           "seven",
    "eight",        "nine",         "ten",           "eleven",
    "twelve",       "thirteen",     "fourteen",      "fifthteen",
    "sixteen",      "seventeen",    "eighteen",      "nineteen",
    "twenty",       "twenty-one",   "twenty-two",    "twenty-three",
    "twenty-four",  "twenty-five",  "twenty-six",    "twenty-seven",
    "twenty-eight", "twenty-nine",  "thirty",        "thirty-one",
    "thirty-two",   "thirty-three", "thirty-four",   "thirty-five",
    "thirty-six",   "thirty-seven", "thirty-eight",  "thirty-nine",
    "fourty",       "fourty-one",   "fourty-two",    "fourty-three",
    "fourty-four",  "fourty-five",  "fourty-six",    "fourty-seven",
    "fourty-eight", "fourty-nine",  "fifty-one",     "fifty-two",
    "fifty-three",  "fifty-four",   "fifty-five",    "fifty-six",
    "fifty-seven",  "fifty-eight",  "fifty-nine",    "sixty",
    "sixty-one",    "sixty-two",    "sixty-three",   "sixty-four",
    "sixty-seven",  "sixty-eight",  "sixty-nine",    "seventy",
    "seventy-one",  "seventy-two",  "seventy-three", "seventy-four",
    "seventy-five", "seventy-six",  "seventy-eight", "seventy-nine",
    "eighty",       "eighty-one",   "eighty-two",    "eighty-three",
    "eighty-four",  "eighty-five",  "eighty-six",    "eighty-seven",
    "eighty-eight", "eighty-nine",  "ninety",        "ninety-one",
    "ninety-two",   "ninety-three", "ninety-four",   "ninety-five",
    "ninety-six",   "ninety-seven", "ninety-eight",  "ninety-nine",
    "one-hundred"
};

/*
 * Used to generate random creation codes.
 */
const char *                                      pCreationCodeTable[] =
{
    "1",  "2",  "3",  "4",  "5",  "6",  "7",  "8",  "9",
    "ba", "du", "am", "gh", "yt", "kr", "eq", "ws", "oi",
    "lf", "cv", "xn", "za", "jt", "pw", "et", "uo", "0"
};

const struct str_number_type                         snFileTypeTable[] =
{
    { ".txt",              FILE_TYPE_TEXT                 },
    { ".text",             FILE_TYPE_TEXT                 },
    { ".gif",              FILE_TYPE_GIF                  },
    { ".jpeg",             FILE_TYPE_JPEG                 },
    { ".jpg",              FILE_TYPE_JPEG                 },
    { ".au",               FILE_TYPE_AUDIO                },
    { "",                  0                              }
}; 

const struct str_number_type                              snDirTable[] =
{
    { "North",     0 },
    { "South",     1 },
    { "East",      2 },
    { "West",      3 },
    { "Up",        4 },
    { "Down",      5 },
    { "NorthEast", 6 },
    { "SouthWest", 7 },
    { "NorthWest", 8 },
    { "SouthEast", 9 },
    { "NE",        6 },
    { "SW",        7 },
    { "NW",        8 },
    { "SE",        9 },
    { "",          0 }
};

struct cmd_type                                            cCmdTable[] =
{
    { "North",      cmd_north,      0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "South",      cmd_south,      0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "East",       cmd_east,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "West",       cmd_west,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Up",         cmd_up,         0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Down",       cmd_down,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "NorthEast",  cmd_northeast,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "SouthWest",  cmd_southwest,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "NorthWest",  cmd_northwest,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "SouthEast",  cmd_southeast,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "NE",         cmd_northeast,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "SW",         cmd_southwest,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "NW",         cmd_northwest,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "SE",         cmd_southeast,  0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Look",       cmd_look,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Read",       cmd_read,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Write",      cmd_write,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Search",     cmd_search,     0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Exits",      cmd_exits,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Emote",      cmd_emote,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "*",          cmd_emote,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Say",        cmd_say,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "'",          cmd_say,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Tell",       cmd_tell,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { ";",          cmd_tell,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Yell",       cmd_yell,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Get",        cmd_get,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Take",       cmd_get,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Put",        cmd_put,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Drop",       cmd_drop,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Give",       cmd_give,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Equip",      cmd_equip,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Use",        cmd_use,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Lock",       cmd_lock,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Unlock",     cmd_unlock,     0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Light",      cmd_light,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Kill",       cmd_kill,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Flee",       cmd_flee,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Run",        cmd_flee,       0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Stand",      cmd_stand,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Sit",        cmd_sit,        0,
      NUMBER_POSITION_STANDING,     MODE_ALL,     FALSE   },

    { "Rest",       cmd_rest,       0,
      NUMBER_POSITION_SITTING,      MODE_ALL,     FALSE   },

    { "Sleep",      cmd_sleep,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Wake",       cmd_wake,       0,
      NUMBER_POSITION_SLEEPING,     MODE_ALL,     FALSE   },

    { "Practice",   cmd_practice,   0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Follow",     cmd_follow,     0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Add",        cmd_add,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Remove",     cmd_remove,     0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Inventory",  cmd_inventory,  0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Equipment",  cmd_equipment,  0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Introduce",  cmd_introduce,  0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Condition",  cmd_condition,  0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Compare",    cmd_compare,    0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Consider",   cmd_consider,   0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Open",       cmd_open,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Close",      cmd_close,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Eat",        cmd_eat,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Drink",      cmd_drink,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Fill",       cmd_fill,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Empty",      cmd_empty,      0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "List",       cmd_list,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Buy",        cmd_buy,        0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { "Sell",       cmd_sell,       0,
      NUMBER_POSITION_RESTING,      MODE_ALL,     FALSE   },

    { ".",          cmd_chat,       2,
      NUMBER_POSITION_DYING,        MODE_GENERIC, FALSE   },

    { ".",          cmd_chat,       BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_RPG,     FALSE   },

    { ":",          cmd_lwizcomm,   BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "/",          cmd_wizcomm,    BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "",           NULL,           0,
      0,                            0,            FALSE   }
};


struct cmd_type                                         cSysCmdTable[] =
{
    { "Credits",    cmd_credits,    0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Help",       cmd_help,       0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Quit",       cmd_quit,       0,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Who",        cmd_who,        0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "RWho",       cmd_rwho,       0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "MUDs",       cmd_muds,       0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "LTell",      cmd_ltell,      2,
      NUMBER_POSITION_DYING,        MODE_GENERIC, FALSE   },

    { "RTell",      cmd_rtell,      2,
      NUMBER_POSITION_DYING,        MODE_GENERIC, FALSE   },

    { "Chat",       cmd_chat,       2,
      NUMBER_POSITION_DYING,        MODE_GENERIC, FALSE   },

    { "Save",       cmd_save,       0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Commands",   cmd_commands,   0,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Prompt",     cmd_prompt,     0,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    /*
     * Builder commands.
     */
    { "Control",    cmd_control,    BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Return",     cmd_return,     BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Users",      cmd_users,      BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Servers",    cmd_servers,    BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Disconnect", cmd_disconnect, BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "CCode",      cmd_ccode,      BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Create",     cmd_create,     BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Destroy",    cmd_destroy,    BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Lookup",     cmd_lookup,     BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Stat",       cmd_stat,       BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Set",        cmd_set,        BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Edit",       cmd_edit,       BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Goto",       cmd_goto,       BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Transfer",   cmd_transfer,   BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "LTell",      cmd_ltell,      BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_RPG,     FALSE   },

    { "RTell",      cmd_rtell,      BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_RPG,     FALSE   },

    { "Chat",       cmd_chat,       BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_RPG,     FALSE   },

    { "LWizComm",   cmd_lwizcomm,   BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "WizComm",    cmd_wizcomm,    BUILDER_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    /*
     * Implementor commands.
     */
    { "Delete",     cmd_delete,     IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },
#ifdef DEBUG
    { "CoreDump",   cmd_coredump,   IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },
#endif
    { "Reboot",     cmd_reboot,     IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "Memory",     cmd_memory,     IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "Shell",      cmd_shell,      IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     FALSE   },

    { "FWrite",     cmd_fwrite,     IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "LSet",       cmd_lset,       IMP_LEVEL,
      NUMBER_POSITION_DYING,        MODE_ALL,     TRUE    },

    { "",           NULL,           0,
      0,                            0,            FALSE   }
};


struct olc_cmd_type                                     olccNPCTable[] =
{
    { "Who",         olc_cmd_who              },
    { "RWho",        olc_cmd_rwho             },
    { "LTell",       olc_cmd_ltell            },
    { "RTell",       olc_cmd_rtell            },
    { "Chat",        olc_cmd_chat             },
    { ".",           olc_cmd_chat             },
    { "LWizComm",    olc_cmd_lwizcomm         },
    { ":",           olc_cmd_lwizcomm         },
    { "WizComm",     olc_cmd_wizcomm          },
    { "/",           olc_cmd_wizcomm          },
    { "Done",        olc_cmd_done             },
    { "",            NULL                     }
};

struct olc_cmd_type                                  olccObjectTable[] =
{
    { "Who",         olc_cmd_who              },
    { "RWho",        olc_cmd_rwho             },
    { "LTell",       olc_cmd_ltell            },
    { "RTell",       olc_cmd_rtell            },
    { "Chat",        olc_cmd_chat             },
    { ".",           olc_cmd_chat             },
    { "LWizComm",    olc_cmd_lwizcomm         },
    { ":",           olc_cmd_lwizcomm         },
    { "WizComm",     olc_cmd_wizcomm          },
    { "/",           olc_cmd_wizcomm          },
    { "Done",        olc_cmd_done             },
    { "",            NULL                     }
};

struct olc_cmd_type                                    olccRoomTable[] =
{
    { "Who",         olc_cmd_who              },
    { "RWho",        olc_cmd_rwho             },
    { "LTell",       olc_cmd_ltell            },
    { "RTell",       olc_cmd_rtell            },
    { "Chat",        olc_cmd_chat             },
    { ".",           olc_cmd_chat             },
    { "LWizComm",    olc_cmd_lwizcomm         },
    { ":",           olc_cmd_lwizcomm         },
    { "WizComm",     olc_cmd_wizcomm          },
    { "/",           olc_cmd_wizcomm          },
    { "Done",        olc_cmd_done             },
    { "New",         olc_cmd_room_new         },
    { "Save",        olc_cmd_room_save        },
    { "List",        olc_cmd_room_list        },
    { "Title",       olc_cmd_room_title       },
    { "Description", olc_cmd_room_description },
    { "Sector",      olc_cmd_room_sector      },
    { "Flag",        olc_cmd_room_flag        },
    { "",            NULL                     }
};

struct shell_cmd_type                                scShellCmdTable[] =
{
    { "exit",        shell_cmd_exit           },
    { "cd",          shell_cmd_cd             },
    { "rm",          shell_cmd_rm             },
    { "mkdir",       shell_cmd_mkdir          },
    { "rmdir",       shell_cmd_rmdir          },
    { "ls",          shell_cmd_ls             },
    { "cat",         shell_cmd_cat            },
    { "users",       shell_cmd_users          },
    { "who",         shell_cmd_who            },
    { "tell",        shell_cmd_tell           },
    { "",            NULL                     }
};

const struct str_number_type                         snPositionTable[] =
{
    { "Dying",             NUMBER_POSITION_DYING          },
    { "Sleeping",          NUMBER_POSITION_SLEEPING       },
    { "Resting",           NUMBER_POSITION_RESTING        },
    { "Sitting",           NUMBER_POSITION_SITTING        },
    { "Standing",          NUMBER_POSITION_STANDING       },
    { "",                  0                              }
};

const struct str_number_type                           snSectorTable[] =
{
    { "Undefined",         NUMBER_SECTOR_UNDEFINED        },
    { "Void",              NUMBER_SECTOR_VOID             },
    { "Air",               NUMBER_SECTOR_AIR              },
    { "Water",             NUMBER_SECTOR_WATER            },
    { "WaterNoSwimming",   NUMBER_SECTOR_WATER_NO_SWIM    },
    { "Underground",       NUMBER_SECTOR_UNDERGROUND      },
    { "Inside",            NUMBER_SECTOR_INSIDE           },
    { "City",              NUMBER_SECTOR_CITY             },
    { "",                  0                              }
};

const struct str_number_type                              snSexTable[] =
{
    { "Male",              NUMBER_SEX_MALE                },
    { "Female",            NUMBER_SEX_FEMALE              },
    { "Random",            NUMBER_SEX_RANDOM   /* NPCs */ },
    { "",                  0                              }
};

const struct str_number_type                        snHairColorTable[] =
{
    { "Black",             NUMBER_HAIR_COLOR_BLACK        },
    { "Brown",             NUMBER_HAIR_COLOR_BROWN        },
    { "Blonde",            NUMBER_HAIR_COLOR_BLONDE       },
    { "Red",               NUMBER_HAIR_COLOR_RED          },
    { "Green",             NUMBER_HAIR_COLOR_GREEN        },
    { "Blue",              NUMBER_HAIR_COLOR_BLUE         },
    { "",                  0                              }
};

const struct str_number_type                         snEyeColorTable[] =
{
    { "Brown",             NUMBER_EYE_COLOR_BROWN         },
    { "Green",             NUMBER_EYE_COLOR_GREEN         },
    { "Blue",              NUMBER_EYE_COLOR_BLUE          },
    { "Red",               NUMBER_EYE_COLOR_RED           },
    { "",                  0                              }
};

const struct race_type                                    rRaceTable[] =
{
    { "An", "Undefined", NUMBER_RACE_UNDEFINED, FALSE, 0,
      0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN,
      NUMBER_HAIR_COLOR_BLONDE, NUMBER_HAIR_COLOR_RED,
      NUMBER_HAIR_COLOR_GREEN,  NUMBER_HAIR_COLOR_BLUE },
    { NUMBER_EYE_COLOR_BROWN,   NUMBER_EYE_COLOR_GREEN,
      NUMBER_EYE_COLOR_BLUE,    NUMBER_EYE_COLOR_RED },
                                { 210, 10 }, { 3000, 10 },
                                { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Human", NUMBER_RACE_HUMAN, TRUE, 0, 0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN,
      NUMBER_HAIR_COLOR_BLONDE, NUMBER_HAIR_COLOR_RED },
    { NUMBER_EYE_COLOR_BROWN,   NUMBER_EYE_COLOR_GREEN,
      NUMBER_EYE_COLOR_BLUE },  { 90, 36 }, { 400, 60 },
                                { 0, 0, 0, 0, 0, 0, 0 }   },

    { "An", "Elf", NUMBER_RACE_ELF, TRUE,
    ( FLAG_ACT_DETECT_MAGIC | FLAG_ACT_NIGHTVISION ), 0,
    { NUMBER_HAIR_COLOR_BLONDE, NUMBER_HAIR_COLOR_GREEN,
      NUMBER_HAIR_COLOR_BLUE },
    { NUMBER_EYE_COLOR_GREEN,   NUMBER_EYE_COLOR_BLUE },
    { 90, 40 }, { 200, 70 },    { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Half-Elf", NUMBER_RACE_HALF_ELF, TRUE,
      FLAG_ACT_DETECT_MAGIC, 0,
    { NUMBER_HAIR_COLOR_BROWN,  NUMBER_HAIR_COLOR_BLONDE,
      NUMBER_HAIR_COLOR_RED,    NUMBER_HAIR_COLOR_GREEN },
    { NUMBER_EYE_COLOR_GREEN,   NUMBER_EYE_COLOR_BLUE },
    { 80, 35 }, { 230, 65 },    { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Dwarf",    NUMBER_RACE_DWARF, TRUE,
      FLAG_ACT_NIGHTVISION, 0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN },
    { NUMBER_EYE_COLOR_BROWN,   NUMBER_EYE_COLOR_GREEN },
    { 48, 24 }, { 200, 80 },    { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Half-Orc", NUMBER_RACE_HALF_ORC, TRUE,
      FLAG_ACT_NIGHTVISION, 0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN   },
    { NUMBER_EYE_COLOR_BROWN }, { 74, 35 }, { 210, 100 },
                                { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Gnome",    NUMBER_RACE_GNOME, TRUE,
      FLAG_ACT_NIGHTVISION, 0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN,
      NUMBER_HAIR_COLOR_RED },
    { NUMBER_EYE_COLOR_GREEN,   NUMBER_EYE_COLOR_BLUE,
      NUMBER_EYE_COLOR_RED },   { 36, 14 }, { 90, 30 },
                                { 0, 0, 0, 0, 0, 0, 0 }   },

    { "A", "Horse",    NUMBER_RACE_HORSE, FALSE, 0, 0,
    { NUMBER_HAIR_COLOR_BLACK,  NUMBER_HAIR_COLOR_BROWN },
    { NUMBER_EYE_COLOR_BROWN,   NUMBER_EYE_COLOR_BLUE },
                                { 105, 80 }, { 2000, 600 },
                                { 0, 0, 0, 0, 0, 0, 0 }   },

    { "", "",   0, FALSE, 0, 0, { 0, 0 },
    { 0 }, { 0 }, { 0 },        { 0, 0, 0, 0, 0, 0, 0 }   }
};

const struct str_number_type                 snNPCScriptTriggerTable[] =
{
    { "Created",           NUMBER_NPC_TRIGGER_CREATED     },
    { "Random",            NUMBER_NPC_TRIGGER_RANDOM      },
    { "Message",           NUMBER_NPC_TRIGGER_MESSAGE     },
    { "Emote",             NUMBER_NPC_TRIGGER_EMOTE       },
    { "Say",               NUMBER_NPC_TRIGGER_SAY         },
    { "Tell",              NUMBER_NPC_TRIGGER_TELL        },
    { "Yell",              NUMBER_NPC_TRIGGER_YELL        },
    { "",                  0                              }
};

const struct str_number_type                 snObjScriptTriggerTable[] =
{
    { "Random",            NUMBER_OBJ_TRIGGER_RANDOM      },
    { "Get",               NUMBER_OBJ_TRIGGER_RANDOM      },
    { "",                  0                              }
};

const struct str_number_type                snRoomScriptTriggerTable[] =
{
    { "Random",            NUMBER_ROOM_TRIGGER_RANDOM     },
    { "Message",           NUMBER_ROOM_TRIGGER_MESSAGE    },
    { "Emote",             NUMBER_ROOM_TRIGGER_EMOTE      },
    { "Say",               NUMBER_ROOM_TRIGGER_SAY        },
    { "Yell",              NUMBER_ROOM_TRIGGER_YELL       },
    { "",                  0                              }
};

const struct str_number_type                 snNPCScriptCommandTable[] =
{
    { "End",               NUMBER_NPC_COMMAND_END         },
    { "Enable",            NUMBER_NPC_COMMAND_ENABLE      },
    { "Disable",           NUMBER_NPC_COMMAND_DISABLE     },
    { "Wait",              NUMBER_NPC_COMMAND_WAIT        },
    { "Set",               NUMBER_NPC_COMMAND_SET         },
    { "Game_cmd",          NUMBER_NPC_COMMAND_GAME_CMD    },
    { "",                  0                              }
};

const struct str_number_type                 snObjScriptCommandTable[] =
{
    { "End",               NUMBER_OBJ_COMMAND_END         },
    { "Enable",            NUMBER_OBJ_COMMAND_ENABLE      },
    { "Disable",           NUMBER_OBJ_COMMAND_DISABLE     },
    { "Wait",              NUMBER_OBJ_COMMAND_WAIT        },
    { "Set",               NUMBER_OBJ_COMMAND_SET         },
    { "",                  0                              }
};

const struct str_number_type                snRoomScriptCommandTable[] =
{
    { "End",               NUMBER_ROOM_COMMAND_END        },
    { "Enable",            NUMBER_ROOM_COMMAND_ENABLE     },
    { "Disable",           NUMBER_ROOM_COMMAND_DISABLE    },
    { "Wait",              NUMBER_ROOM_COMMAND_WAIT       },
    { "Set",               NUMBER_ROOM_COMMAND_SET        },
    { "Create_NPC",        NUMBER_ROOM_COMMAND_CREATE_NPC },
    { "Create_Object",     NUMBER_ROOM_COMMAND_CREATE_OBJ },
    { "",                  0                              }
};

const struct script_func_type                  sfScriptFunctionTable[] =
{
    { "capitialize",       script_func_capitialize        },
    { "uncapitialize",     script_func_uncapitialize      },
    { "capitialize_first", script_func_capitialize_first  },
    { "is_npc",            script_func_is_npc             },
    { "is_guest",          script_func_is_guest           },
    { "get_char",          script_func_get_char           },
    { "get_pc",            script_func_get_pc             },
    { "get_npc",           script_func_get_npc            },
    { "get_char_in_room",  script_func_get_char_in_room   },
    { "get_pc_in_room",    script_func_get_pc_in_room     },
    { "get_npc_in_room",   script_func_get_npc_in_room    },
    { "get_room",          script_func_get_room           },
    { "",                  NULL                           }
};

const struct str_number_type                         snItemTypeTable[] =
{
    { "Undefined",         NUMBER_ITEM_UNDEFINED          },
    { "Container",         NUMBER_ITEM_CONTAINER          },
    { "DrinkContainer",    NUMBER_ITEM_DRINK_CONTAINER    },
    { "Paper",             NUMBER_ITEM_PAPER              },
    { "Pencil",            NUMBER_ITEM_PENCIL             },
    { "Communicator",      NUMBER_ITEM_COMMUNICATOR       },
    { "Light",             NUMBER_ITEM_LIGHT              },
    { "Lighter",           NUMBER_ITEM_LIGHTER            },
    { "Key",               NUMBER_ITEM_KEY                },
    { "Stone",             NUMBER_ITEM_STONE              },
    { "Chair",             NUMBER_ITEM_CHAIR              },
    { "Bed",               NUMBER_ITEM_BED                },
    { "Dagger",            NUMBER_ITEM_DAGGER             },
    { "Sword",             NUMBER_ITEM_SWORD              },
    { "Mace",              NUMBER_ITEM_MACE               },
    { "Axe",               NUMBER_ITEM_AXE                },
    { "Spear",             NUMBER_ITEM_SPEAR              },
    { "Flail",             NUMBER_ITEM_FLAIL              },
    { "Bow",               NUMBER_ITEM_BOW                },
    { "Armor",             NUMBER_ITEM_ARMOR              },
    { "ArmGuards",         NUMBER_ITEM_ARM_GUARDS         },
    { "Boots",             NUMBER_ITEM_BOOTS              },
    { "Leggings",          NUMBER_ITEM_LEGGINGS           },
    { "Helmet",            NUMBER_ITEM_HELMET             },
    { "Cloak",             NUMBER_ITEM_CLOAK              },
    { "Shield",            NUMBER_ITEM_SHIELD             },
    { "Ring",              NUMBER_ITEM_RING               },
    { "",                  0                              }
}; 

const struct number_number_type                     nnItemEquipTable[] =
{
    { NUMBER_ITEM_UNDEFINED,       NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_UNDEFINED,       NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_CONTAINER,       NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_CONTAINER,       NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_DRINK_CONTAINER, NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_DRINK_CONTAINER, NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_COMMUNICATOR,    NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_COMMUNICATOR,    NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_LIGHT,           NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_LIGHT,           NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_STONE,           NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_STONE,           NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_KEY,             NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_KEY,             NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_DAGGER,          NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_DAGGER,          NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_SWORD,           NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_SWORD,           NUMBER_WEAR_RHAND      },
    { NUMBER_ITEM_MACE,            NUMBER_WEAR_LHAND      },
    { NUMBER_ITEM_MACE,            NUMBER_WEAR_RHAND      },
    { 0,                           0                      }
};

const struct str_number_type                             snSizeTable[] =
{
    { "Tiny",              NUMBER_SIZE_TINY               },
    { "Small",             NUMBER_SIZE_SMALL              },
    { "Medium",            NUMBER_SIZE_MEDIUM             },
    { "Large",             NUMBER_SIZE_LARGE              },
    { "Huge",              NUMBER_SIZE_HUGE               },
    { "",                  0                              }
}; 

const struct str_number_type                         snMaterialTable[] =
{
    { "Undefined",         NUMBER_MATERIAL_UNDEFINED      },
    { "Ice",               NUMBER_MATERIAL_ICE            },
    { "Fire",              NUMBER_MATERIAL_FIRE           },
    { "Cloth",             NUMBER_MATERIAL_CLOTH          },
    { "Leather",           NUMBER_MATERIAL_LEATHER        },
    { "Bronze",            NUMBER_MATERIAL_BRONZE         },
    { "Iron",              NUMBER_MATERIAL_IRON           },
    { "Steel",             NUMBER_MATERIAL_STEEL          },
    { "Glass",             NUMBER_MATERIAL_GLASS          },
    { "Silver",            NUMBER_MATERIAL_SILVER         },
    { "Gold",              NUMBER_MATERIAL_GOLD           },
    { "Diamond",           NUMBER_MATERIAL_DIAMOND        },
    { "Emerald",           NUMBER_MATERIAL_EMERALD        },
    { "",                  0                              }
};

const struct str_number_type                         snNPCFlagsTable[] =
{
    { "SPECIAL",           FLAG_NPC_SPECIAL               },
    { "MOUNTABLE",         FLAG_NPC_MOUNTABLE             },
    { "STAYINSIDE",        FLAG_NPC_STAY_INSIDE           },
    { "STAYOUTSIDE",       FLAG_NPC_STAY_OUTSIDE          },
    { "NOKILL",            FLAG_NPC_NO_KILL               },
    { "AGGRESSIVE",        FLAG_NPC_AGGRESSIVE            },
    { "CRAZED",            FLAG_NPC_CRAZED                },
    { "TEACHER",           FLAG_NPC_TEACHER               },
    { "",                  0                              }
};

const struct str_number_type                        snPartFlagsTable[] =
{
    { "",                  0                              }
};

const struct str_number_type                         snActFlagsTable[] =
{
    { "INVIS",             FLAG_ACT_INVIS                 },
    { "SEEINVIS",          FLAG_ACT_SEE_INVIS             },
    { "DETECTHIDDEN",      FLAG_ACT_DETECT_HIDDEN         },
    { "DETECTMAGIC",       FLAG_ACT_DETECT_MAGIC          },
    { "NIGHTVISION",       FLAG_ACT_NIGHTVISION           },
    { "",                  0                              }
};

const struct str_number_type                      snObjectFlagsTable[] =
{
    { "SPECIAL",           FLAG_OBJECT_SPECIAL            },
    { "UNTAKEABLE",        FLAG_OBJECT_UNTAKEABLE         },
    { "CLOSABLE",          FLAG_OBJECT_CLOSABLE           },
    { "CLOSED",            FLAG_OBJECT_CLOSED             },
    { "LOCKED",            FLAG_OBJECT_LOCKED             },
    { "LIT",               FLAG_OBJECT_LIT                },
    { "MAGIC",             FLAG_OBJECT_MAGIC              },
    { "INVIS",             FLAG_OBJECT_INVIS              },
    { "",                  0                              }
};

const struct str_number_type                        snRoomFlagsTable[] =
{
    { "DARK",              FLAG_ROOM_DARK                 },
    { "INVIS",             FLAG_ROOM_INVIS                },
    { "NONPCS",            FLAG_ROOM_NO_NPCS              },
    { "PRIVATE",           FLAG_ROOM_PRIVATE              },
    { "IMMORTAL",          FLAG_ROOM_IMMORTAL             },
    { "UNSAFE",            FLAG_ROOM_UNSAFE               },
    { "NOWEATHER",         FLAG_ROOM_NO_WEATHER           },
    { "",                  0                              }
};

struct npc_load_type                                   npclLoadTable[] =
{
    { "INHERIT",           npc_load_inherit               },
    { "I",                 npc_load_inherit               },
    { "IMAGEFILENAME",     npc_load_imagefilename         },
    { "IMAGE_FILENAME",    npc_load_imagefilename         },
    { "IMAGE",             npc_load_imagefilename         },
    { "IF",                npc_load_imagefilename         },
    { "NAMES",             npc_load_names                 },
    { "N",                 npc_load_names                 },
    { "SHORTDESC",         npc_load_shortdesc             },
    { "SHORT_DESC",        npc_load_shortdesc             },
    { "SD",                npc_load_shortdesc             },
    { "DESC",              npc_load_desc                  },
    { "D",                 npc_load_desc                  },
    { "DESC1",             npc_load_desc1                 },
    { "D1",                npc_load_desc1                 },
    { "DESC2",             npc_load_desc2                 },
    { "D2",                npc_load_desc2                 },
    { "DESC3",             npc_load_desc3                 },
    { "D3",                npc_load_desc3                 },
    { "DESC4",             npc_load_desc4                 },
    { "D4",                npc_load_desc4                 },
    { "DESC5",             npc_load_desc5                 },
    { "D5",                npc_load_desc5                 },
    { "LONGDESC",          npc_load_longdesc              },
    { "LONG_DESC",         npc_load_longdesc              },
    { "LD",                npc_load_longdesc              },
    { "NPCFLAGS",          npc_load_npcflags              },
    { "NPC_FLAGS",         npc_load_npcflags              },
    { "NPCF",              npc_load_npcflags              },
    { "PARTFLAGS",         npc_load_partflags             },
    { "PART_FLAGS",        npc_load_partflags             },
    { "PF",                npc_load_partflags             },
    { "ACTFLAGS",          npc_load_actflags              },
    { "ACT_FLAGS",         npc_load_actflags              },
    { "AF",                npc_load_actflags              },
    { "RACE",              npc_load_race                  },
    { "R",                 npc_load_race                  },
    { "SEX",               npc_load_sex                   },
    { "S",                 npc_load_sex                   },
    { "HAIRCOLOR",         npc_load_haircolor             },
    { "HAIR_COLOR",        npc_load_haircolor             },
    { "HC",                npc_load_haircolor             },
    { "EYECOLOR",          npc_load_eyecolor              },
    { "EYE_COLOR",         npc_load_eyecolor              },
    { "EC",                npc_load_eyecolor              },
    { "HEIGHT",            npc_load_height                },
    { "H",                 npc_load_height                },
    { "WEIGHT",            npc_load_weight                },
    { "W",                 npc_load_weight                },
    { "MAXCARRY",          npc_load_maxcarry              },
    { "MAX_CARRY",         npc_load_maxcarry              },
    { "MC",                npc_load_maxcarry              },
    { "LEVEL",             npc_load_level                 },
    { "L",                 npc_load_level                 },
    { "EXPERIENCE",        npc_load_experience            },
    { "E",                 npc_load_experience            },
    { "ALIGNMENT",         npc_load_alignment             },
    { "A",                 npc_load_alignment             },
    { "POSITION",          npc_load_position              },
    { "P",                 npc_load_position              },
    { "GOLD",              npc_load_gold                  },
    { "G",                 npc_load_gold                  },
    { "WANDER",            npc_load_wander                },
    { "WA",                npc_load_wander                },
    { "STATS",             npc_load_stats                 },
    { "ST",                npc_load_stats                 },
    { "PROGRAM",           npc_load_program               },
    { "PR",                npc_load_program               },
    { "SCRIPT",            npc_load_program               },
    { "SC",                npc_load_program               },
    { "",                  NULL                           }
};

struct obj_load_type                                     olLoadTable[] =
{
    { "INHERIT",           obj_load_inherit               },
    { "I",                 obj_load_inherit               },
    { "IMAGEFILENAME",     obj_load_imagefilename         },
    { "IMAGE_FILENAME",    obj_load_imagefilename         },
    { "IMAGE",             obj_load_imagefilename         },
    { "IF",                obj_load_imagefilename         },
    { "NAMES",             obj_load_names                 },
    { "N",                 obj_load_names                 },
    { "SHORTDESC",         obj_load_shortdesc             },
    { "SHORT_DESC",        obj_load_shortdesc             },
    { "SD",                obj_load_shortdesc             },
    { "DESC",              obj_load_desc                  },
    { "D",                 obj_load_desc                  },
    { "LONGDESC",          obj_load_longdesc              },
    { "LONG_DESC",         obj_load_longdesc              },
    { "LD",                obj_load_longdesc              },
    { "ITEMTYPE",          obj_load_itemtype              },
    { "ITEM_TYPE",         obj_load_itemtype              },
    { "IT",                obj_load_itemtype              },
    { "OBJECTFLAGS",       obj_load_objectflags           },
    { "OBJECT_FLAGS",      obj_load_objectflags           },
    { "OF",                obj_load_objectflags           },
    { "LEVEL",             obj_load_level                 },
    { "L",                 obj_load_level                 },
    { "WEIGHT",            obj_load_weight                },
    { "W",                 obj_load_weight                },
    { "SIZE",              obj_load_size                  },
    { "S",                 obj_load_size                  },
    { "COST",              obj_load_cost                  },
    { "C",                 obj_load_cost                  },
    { "CONDITION",         obj_load_condition             },
    { "CO",                obj_load_condition             },
    { "MATERIAL",          obj_load_material              },
    { "M",                 obj_load_material              },
    { "VALUES",            obj_load_values                },
    { "V",                 obj_load_values                },
    { "STRINGVALUE",       obj_load_stringvalue           },
    { "STRING_VALUE",      obj_load_stringvalue           },
    { "SV",                obj_load_stringvalue           },
    { "PROGRAM",           obj_load_program               },
    { "P",                 obj_load_program               },
    { "SCRIPT",            obj_load_program               },
    { "SC",                obj_load_program               },
    { "",                  NULL                           }
};

struct room_load_type                                    rlLoadTable[] =
{
    { "IMAGEFILENAME",     room_load_imagefilename        },
    { "IMAGE_FILENAME",    room_load_imagefilename        },
    { "IMAGE",             room_load_imagefilename        },
    { "IF",                room_load_imagefilename        },
    { "TITLE",             room_load_title                },
    { "T",                 room_load_title                },
    { "DESC",              room_load_desc                 },
    { "D",                 room_load_desc                 },
    { "ROOMFLAGS",         room_load_roomflags            },
    { "ROOM_FLAGS",        room_load_roomflags            },
    { "RF",                room_load_roomflags            },
    { "SECTOR",            room_load_sector               },
    { "S",                 room_load_sector               },
    { "TEMPERATURE",       room_load_temperature          },
    { "TE",                room_load_temperature          },
    { "NORTHDESC",         room_load_northdesc            },
    { "NORTH_DESC",        room_load_northdesc            },
    { "ND",                room_load_northdesc            },
    { "SOUTHDESC",         room_load_southdesc            },
    { "SOUTH_DESC",        room_load_southdesc            },
    { "SD",                room_load_southdesc            },
    { "EASTDESC",          room_load_eastdesc             },
    { "EAST_DESC",         room_load_eastdesc             },
    { "ED",                room_load_eastdesc             },
    { "WESTDESC",          room_load_westdesc             },
    { "WEST_DESC",         room_load_westdesc             },
    { "WD",                room_load_westdesc             },
    { "UPDESC",            room_load_updesc               },
    { "UP_DESC",           room_load_updesc               },
    { "UD",                room_load_updesc               },
    { "DOWNDESC",          room_load_downdesc             },
    { "DOWN_DESC",         room_load_downdesc             },
    { "DD",                room_load_downdesc             },
    { "NORTHEASTDESC",     room_load_northeastdesc        },
    { "NORTHEAST_DESC",    room_load_northeastdesc        },
    { "NED",               room_load_northeastdesc        },
    { "SOUTHWESTDESC",     room_load_southwestdesc        },
    { "SOUTHWEST_DESC",    room_load_southwestdesc        },
    { "SWD",               room_load_southwestdesc        },
    { "NORTHWESTDESC",     room_load_northwestdesc        },
    { "NORTHWEST_DESC",    room_load_northwestdesc        },
    { "NWD",               room_load_northwestdesc        },
    { "SOUTHEASTDESC",     room_load_southeastdesc        },
    { "SOUTHEAST_DESC",    room_load_southeastdesc        },
    { "SED",               room_load_southeastdesc        },
    { "NORTH",             room_load_exitnorth            },
    { "N",                 room_load_exitnorth            },
    { "SOUTH",             room_load_exitsouth            },
    { "SO",                room_load_exitsouth            },
    { "EAST",              room_load_exiteast             },
    { "E",                 room_load_exiteast             },
    { "WEST",              room_load_exitwest             },
    { "W",                 room_load_exitwest             },
    { "UP",                room_load_exitup               },
    { "U",                 room_load_exitup               },
    { "DOWN",              room_load_exitdown             },
    { "DO",                room_load_exitdown             },
    { "NORTHEAST",         room_load_exitnortheast        },
    { "NE",                room_load_exitnortheast        },
    { "SOUTHWEST",         room_load_exitsouthwest        },
    { "SW",                room_load_exitsouthwest        },
    { "NORTHWEST",         room_load_exitnorthwest        },
    { "NW",                room_load_exitnorthwest        },
    { "SOUTHEAST",         room_load_exitsoutheast        },
    { "SE",                room_load_exitsoutheast        },
    { "NPCS",              room_load_npcs                 },
    { "OBJECTS",           room_load_objects              },
    { "O",                 room_load_objects              },
    { "PROGRAM",           room_load_program              },
    { "P",                 room_load_program              },
    { "SCRIPT",            room_load_program              },
    { "SC",                room_load_program              },
    { "",                  NULL                           }
};

struct zone_load_type                                    zlLoadTable[] =
{
    { "",                  NULL                           }
};


/*
 * End of globals.c
 */