/*************************************************************************** * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, * * Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. * * * * Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael * * Chastain, Michael Quan, and Mitchell Tse. * * * * In order to use any part of this Merc Diku Mud, you must comply with * * both the original Diku license in 'license.doc' as well the Merc * * license in 'license.txt'. In particular, you may not remove either of * * these copyright notices. * * * * Much time and thought has gone into this software and you are * * benefitting. We hope that you share your changes too. What goes * * around, comes around. * ***************************************************************************/ /*************************************************************************** * ROM 2.4 is copyright 1993-1998 Russ Taylor * * ROM has been brought to you by the ROM consortium * * Russ Taylor (rtaylor@hypercube.org) * * Gabrielle Taylor (gtaylor@hypercube.org) * * Brian Moore (zump@rom.org) * * By using this code, you have agreed to follow the terms of the * * ROM license, in the file Rom24/doc/rom.license * ***************************************************************************/ #if defined(macintosh) #include <types.h> #else #include <sys/types.h> #include <sys/time.h> #endif #include <stdio.h> #include <string.h> #include <stdlib.h> #include <ctype.h> #include <time.h> #include "include.h" CMD_DATA * cmd_first; CMD_DATA * cmd_last; #define CMDEDIT( fun ) bool fun (CHAR_DATA *ch, char *argument ) #define LOG_NORMAL 0 #define LOG_ALWAYS 1 #define LOG_NEVER 2 extern const struct size_type cat_table[]; extern const struct size_type log_table[]; char *dofuname args ((CMD_DATA *cmd ) ); CMD_DATA *new_cmd args( (void) ); void free_cmd args( (CMD_DATA *cmd) ); DO_FUN *dofun_lookup args( (const char *name) ); struct cmdfun_type { char *name; DO_FUN *do_fun; }; extern const struct cmdfun_type cmdfun_table[]; void save_cmd_table() { FILE *fp; CMD_DATA *cmd; if( file_exists("../data/command/command.dat" ) && ( fp = file_open("../data/command/command.dat","w+") ) != NULL ) { for(cmd = cmd_first; cmd ; cmd = cmd->next ) { fprintf(fp, "Name %s~\n", cmd->name ); fprintf(fp, "Dofun %s~\n", dofuname(cmd) ); fprintf(fp, "Position %d\n", cmd->position ); fprintf(fp, "Level %d\n", cmd->level ); fprintf(fp, "Log %d\n",cmd->log ); fprintf(fp, "Show %d\n", cmd->show ); fprintf(fp, "Cat %d\n", cmd->cat ); fprintf(fp, "Disabled %d\n\r", cmd->disabled ? TRUE : FALSE); fprintf(fp, "End\n\n"); } } fprintf(fp, "$\n"); file_close(fp); } void load_cmd_list() { FILE *fp; CMD_DATA *cmd; const char *word; if(file_exists("../data/command/command.dat") ) fp = file_open("../data/command/command.dat", "r" ); else { logf2("You got no commands now! Your screwed! Blame Davion!\n\r"); return; } for( ;; ) { word = feof (fp) ? "End" : fread_word (fp); if(word[0] == '$' ) return; switch (UPPER(word[0] )) { case 'C': if(!str_cmp(word, "Cat" ) ) cmd->cat = fread_number(fp); break; case 'D': if(!str_cmp(word, "Dofun" ) ) { cmd->do_fun = dofun_lookup(fread_string(fp) ); break; } if(!str_cmp(word, "Disabled" ) ) { cmd->disabled = fread_number(fp); break; } break; case 'E': if(!str_cmp(word, "End" ) ) break; break; case 'L': if(!str_cmp(word, "Level" ) ) { cmd->level = fread_number(fp); break; } if(!str_cmp(word, "Log" ) ) { cmd->log = fread_number(fp); break; } break; case 'N': if(!str_cmp(word, "Name" ) ) { cmd = new_cmd(); cmd->name = fread_string(fp); break; } break; case 'P': if(!str_cmp(word, "Position" ) ) { cmd->position = fread_number(fp); break; } break; case 'S': if(!str_cmp(word, "Show" ) ) { cmd->show = fread_number(fp); break; } break; }//End of switch }//End of for file_close(fp); } char *dofuname (CMD_DATA *cmd) { int i; for( i = 0; cmdfun_table[i].name != NULL ; i ++ ) { if(cmd->do_fun == cmdfun_table[i].do_fun) return cmdfun_table[i].name; } logf2("BUG: %s has no do function", cmd->name ); return "do_null"; } DO_FUN *dofun_lookup(const char *name) { int i; for (i = 0;cmdfun_table[i].name != NULL ; i ++) { if(!str_cmp(name, cmdfun_table[i].name ) ) return cmdfun_table[i].do_fun; } return NULL; } CMD_DATA *cmd_lookup(const char *name ) { CMD_DATA *cmd; for( cmd = cmd_first ; cmd ; cmd = cmd->next ) { if(!str_cmp(name, cmd->name ) ) return cmd; } return NULL; } CMD_DATA *cmd_free; CMD_DATA *new_cmd(void) { static CMD_DATA cmd_zero; CMD_DATA *cmd; if (cmd_free == NULL) cmd = (CMD_DATA *)alloc_perm(sizeof(*cmd)); else { cmd = cmd_free; cmd_free = cmd_free->next; } *cmd = cmd_zero; if(!cmd_first ) cmd_first = cmd; if(cmd_last) { cmd_last->next = cmd; cmd->prev = cmd_last; } cmd_last = cmd; free_string(cmd->name); cmd->name = str_dup("NewCommand"); cmd->do_fun = cmdfun_table[1].do_fun; cmd->level = 0; cmd->position = 0; cmd->show = 1; cmd->log = LOG_NORMAL; VALIDATE(cmd); return cmd; } void free_cmd(CMD_DATA *cmd) { if (!IS_VALID(cmd)) return; INVALIDATE(cmd); cmd->next = cmd_free; cmd->prev = cmd_free; cmd_free = cmd; } CMDEDIT(cmdedit_show ) { CMD_DATA *cmd; EDIT_COMMAND(ch, cmd ); printf_to_char(ch, "{DCommand name{r: {W%s{x\n\r", cmd->name ); send_to_char("{D======================================{x\n\r",ch); printf_to_char(ch, "{DCommand Catagory{r: {W%s{x\n\r", cat_table[cmd->cat].name ); printf_to_char(ch, "{DCommand Do_function{r: {W%s{x\n\r", dofuname(cmd) ); printf_to_char(ch, "{DCommand Level{r: {W%d{x\n\r", cmd->level ); printf_to_char(ch, "{DCommand Position{r: {W%s{x\n\r", position_table[cmd->position].name ); printf_to_char(ch, "{DCommand Show{r: {W%s{x\n\r", cmd->show == TRUE ? "Yes" : "No" ); printf_to_char(ch, "{DCommand Log{r: {W%s{x\n\r", log_table[cmd->log].name ); return FALSE; } CMDEDIT( cmdedit_name ) { CMD_DATA *cmd; EDIT_COMMAND(ch, cmd ); if(argument[0] == '\0') { send_to_char("Syntax: name <name>\n\r",ch); return FALSE; } if( cmd_lookup(argument ) != NULL ) { send_to_char("There is already a command by that name.\n\r",ch); return FALSE; } free_string(cmd->name ); cmd->name = str_dup(argument ); return TRUE; } int cat_lookup (const char *name ) { int i; for( i = 0 ; cat_table[i].name != NULL ; i++ ) { if(!str_cmp(cat_table[i].name, name ) ) return i; } return -1; } CMDEDIT( cmdedit_catagory ) { CMD_DATA *cmd; int cat; EDIT_COMMAND(ch, cmd ); if(argument[0] == '\0' ) { send_to_char("Syntax: catagory <catagory>\n\r",ch); return FALSE; } if( ( cat = cat_lookup (argument ) ) == -1 ) { send_to_char("That is not a valid catagory. Valid catagory's are:\n\r",ch); for(cat = 0; cat_table[cat].name != NULL ; cat++ ) printf_to_char(ch, "%s ", cat_table[cat].name); return FALSE; } printf_to_char(ch, "%s is now placed in the %s catagory.\n\r",cmd->name, cat_table[cat].name ); cmd->cat = cat; return TRUE; } CMDEDIT( cmdedit_dofun ) { CMD_DATA *cmd; DO_FUN *dofun; EDIT_COMMAND(ch, cmd); if(argument[0] == '\0' ) { send_to_char("Syntax: dofun <dofun>\n\r",ch); return FALSE; } if( ( dofun = dofun_lookup(argument ) ) == NULL ) { send_to_char("No such do_function. Did you add it to the dofun_table?\n\r",ch); return FALSE; } cmd->do_fun = dofun; send_to_char("Do function set.\n\r",ch); return TRUE; } CMDEDIT (cmdedit_level ) { CMD_DATA *cmd; int level; char arg[MSL]; EDIT_COMMAND(ch, cmd); argument = one_argument(argument,arg); if(arg[0] == '\0' ) { send_to_char("Syntax level <#level>\n\r",ch); return FALSE; } if(!is_number(arg) ) { send_to_char("It must be a number.\n\r",ch); return FALSE; } level = atoi(arg); if(level > MAX_LEVEL || level < 0 ) { send_to_char("It must be less than 159, and greater than 0.\n\r",ch); return FALSE; } send_to_char("Level set.\n\r",ch); cmd->level = level; return TRUE; } CMDEDIT( cmdedit_position ) { CMD_DATA *cmd; int pos; EDIT_COMMAND (ch, cmd ); if(argument[0] == '\0' ) { send_to_char("Syntax: position <position>\n\r",ch); return FALSE; } if( ( pos = position_lookup(argument ) ) == -1 ) { send_to_char("What type of position is that?\n\r", ch ); return FALSE; } send_to_char("Position set.\n\r",ch); cmd->position = pos; return TRUE; } CMDEDIT( cmdedit_showcmd ) { CMD_DATA *cmd; EDIT_COMMAND(ch, cmd); if(argument[0] == '\0' ) { send_to_char("Syntax: cmdshow <true/false>\n\r",ch); return TRUE; } if(!str_cmp(argument, "true" ) ) { send_to_char("This command will now show.\n\r",ch); cmd->show = TRUE; return TRUE; } if(!str_cmp(argument, "false" ) ) { send_to_char("This command will no longer be shown.\n\r",ch); cmd->show = FALSE; return TRUE; } send_to_char("Either 'true' or 'false'.\n\r",ch); return FALSE; } CMDEDIT( cmdedit_log) { CMD_DATA *cmd; EDIT_COMMAND(ch, cmd); if(argument[0] == '\0' ) { send_to_char("Syntax: log <never|always|normal>\n\r",ch); return FALSE; } if(!str_cmp(argument, "never" ) ) { send_to_char("Logging set to never.\n\r",ch); cmd->log = LOG_NEVER; return TRUE; } if(!str_cmp(argument, "always" ) ) { send_to_char("Logging set to always.\n\r",ch); cmd->log = LOG_ALWAYS; return TRUE; } if(!str_cmp(argument, "normal" ) ) { send_to_char("Logging set to normal.\n\r",ch); cmd->log = LOG_NORMAL; return TRUE; } send_to_char("Either never, normal, or always.\n\r",ch); return FALSE; } CMDEDIT( cmdedit_new ) { CMD_DATA *cmd; if(argument[0] == '\0' ) { send_to_char("Syntax: new <New Name>\n\r",ch); return FALSE; } if( cmd_lookup(argument ) != NULL ) { send_to_char("That command already exists.\n\r",ch); return FALSE; } cmd = new_cmd(); free_string(cmd->name ); cmd->name = str_dup(argument); ch->desc->pEdit = (void *) cmd; send_to_char("Command created.\n\r",ch); return TRUE; } CMDEDIT( cmdedit_move ) { CMD_DATA *cmd, *mCmd, *tCmd, *nCmd, *pCmd; char arg1[MSL], arg2[MSL], arg3[MSL]; EDIT_COMMAND(ch, cmd); argument = one_argument(argument, arg1); argument = one_argument(argument, arg2); argument = one_argument(argument, arg3); if(arg1[0] == '\0' || arg2[0] == '\0' || arg3[0] == '\0' ) { send_to_char("Syntax: move <command> <befor|after> <to-command>\n\r",ch); return FALSE; } if( ( tCmd = cmd_lookup(arg3 ) ) == NULL ) { send_to_char("To command, not existing.\n\r",ch ); return FALSE; } if( ( mCmd = cmd_lookup(arg1 ) ) == NULL ) { send_to_char("Which command would you like to move?\n\r",ch); return FALSE; } if( tCmd == mCmd ) { send_to_char("You can't do that!\n\r",ch); return FALSE; } if(!str_cmp(arg2, "befor" ) ) { pCmd = mCmd->prev; nCmd = mCmd->next; mCmd->next = NULL; mCmd->prev = NULL; if(cmd_last == mCmd ) cmd_last = pCmd; else nCmd->prev = pCmd; if(cmd_first == mCmd ) cmd_first = nCmd; pCmd->next = nCmd; if(cmd_first == tCmd ) { cmd_first = mCmd; mCmd->next = tCmd; tCmd->prev = mCmd; printf_to_char(ch, "%s moved befor %s.\n\r", mCmd->name, tCmd->name ); return TRUE; } pCmd = tCmd->prev; printf_to_char(ch, "%s moved befor %s.\n\r", mCmd->name, tCmd->name ); tCmd->prev = mCmd; pCmd->next = mCmd; mCmd->prev = pCmd; mCmd->next = tCmd; return TRUE; } if(!str_cmp(arg2, "after" ) ) { pCmd = mCmd->prev; nCmd = mCmd->next; mCmd->next = NULL; mCmd->prev = NULL; if(cmd_last == mCmd ) cmd_last = pCmd; else nCmd->prev = pCmd; if(cmd_first == mCmd ) cmd_first = nCmd; else pCmd->next = nCmd; if(cmd_last == tCmd ) { cmd_last = mCmd; mCmd->prev = tCmd; tCmd->next = mCmd; printf_to_char(ch, "%s moved after %s.\n\r", mCmd->name, tCmd->name ); return TRUE; } nCmd = tCmd->next; printf_to_char(ch, "%s moved after %s.\n\r", mCmd->name, tCmd->name ); nCmd->prev = mCmd; tCmd->next = mCmd; mCmd->next = nCmd; mCmd->prev = tCmd; return TRUE; } send_to_char("It must be 'befor' or 'after' the command.\n\r",ch); return FALSE; } CMDEDIT( cmdedit_delete ) { CMD_DATA *pCmd, *temp, *prev; if(argument[0] == '\0' ) { send_to_char("Syntax delete <cmdname>\n\r",ch); return FALSE; } if( ( pCmd = cmd_lookup(argument) ) == NULL ) { send_to_char("That isn't a valid command.\n\r",ch ); return FALSE; } if( !is_admin(ch) ) { send_to_char("Only Admins can delete command.\n\r",ch); return FALSE; } for(temp = cmd_first ; temp ; temp = temp->next ) { if(temp->next == pCmd ) { prev = pCmd->next; prev->prev = temp; temp->next = prev; free_cmd(pCmd); send_to_char("Commmand Delete.\n\r",ch); return TRUE; } } cmdedit_delete(ch, NULL ); return FALSE; } void do_cmdlist(CHAR_DATA *ch, char *argument ) { int col = 0; CMD_DATA *cmd; for(cmd = cmd_first; cmd ; cmd = cmd->next ) { printf_to_char( ch, " [{c%-11s{x]", cmd->name ); if ( ++col % 5 == 0 ) send_to_char("\n\r",ch); } return; } const struct cmdfun_type cmdfun_table [] = { { "north", do_north }, { "east", do_east }, { "south", do_south }, { "west", do_west }, { "up", do_up }, { "down", do_down }, { "at", do_at }, { "cast", do_cast }, { "buy", do_buy }, { "channels", do_channels }, { "exits", do_exits }, { "get", do_get }, { "goto", do_goto }, { "group", do_group }, { "guild", do_guild }, { "do_kill", do_kill }, { "purchase", do_purchase }, { "inventory", do_inventory }, { "insert", do_insert }, { "kill", do_kill }, { "look", do_look }, { "clantalk", do_clantalk }, { "music", do_music }, { "order", do_order }, { "practice", do_practice }, { "rest", do_rest }, { "sit", do_sit }, { "sockets", do_sockets }, { "stand", do_stand }, { "tell", do_tell }, { "unlock", do_unlock }, { "unlink", do_unlink }, { "wear", do_wear }, { "wizhelp", do_wizhelp }, { "push", do_push }, { "drag", do_drag }, { "donate", do_donate }, { "auction", do_auction }, { "bid", do_bid }, { "email", do_email }, { "affects", do_affects }, { "affects2", do_affects2 }, { "areas", do_areas }, { "bug", do_bug }, { "board", do_board }, { "commands", do_commands }, { "compare", do_compare }, { "consider", do_consider }, { "count", do_count }, { "credits", do_credits }, { "equipment", do_equipment }, { "examine", do_examine }, { "help", do_help }, { "groups", do_groups }, { "motd", do_motd }, { "read", do_read }, { "report", do_report }, { "rules", do_rules }, { "score", do_score }, { "skills", do_skills }, { "socials", do_socials }, { "show", do_show }, { "spells", do_spells }, { "story", do_story }, { "time", do_time }, { "typo", do_typo }, { "unread", do_unread }, { "version", do_version }, { "weather", do_weather }, { "who", do_who }, { "whois", do_whois }, { "wizlist", do_wizlist }, { "scan", do_scan }, { "istat", do_istat }, { "slist", do_slist }, { "lore", do_lore }, { "finger", do_finger }, { "peek", do_peek }, { "note", do_note }, { "mobdeaths", do_mobdeaths }, { "mobkills", do_mobkills }, { "reveal", do_reveal }, { "cwho", do_cwho }, { "roster", do_roster }, { "alia", do_alia }, { "alias", do_alias }, { "autolist", do_autolist }, { "autoassist", do_autoassist }, { "autodamage", do_autodamage }, { "autoexit", do_autoexit }, { "autogold", do_autogold }, { "autoloot", do_autoloot }, { "autosac", do_autosac }, { "autosplit", do_autosplit }, { "brief", do_brief }, { "colour", do_colour }, { "combine", do_combine }, { "compact", do_compact }, { "description",do_description }, { "delet", do_delet }, { "delete", do_delete }, { "nofollow", do_nofollow }, { "noloot", do_noloot }, { "nosummon", do_nosummon }, { "password", do_password }, { "prompt", do_prompt }, { "scroll", do_scroll }, { "title", do_title }, { "unalias", do_unalias }, { "wimpy", do_wimpy }, { "stance", do_stance }, { "nickname", do_nickname }, { "afk", do_afk }, { "answer", do_answer }, { "deaf", do_deaf }, { "emote", do_emote }, { "pmote", do_pmote }, { "gossip", do_gossip, }, { "grats", do_grats }, { "gtell", do_gtell }, { "pose", do_pose }, { "quote", do_quote }, { "quiet", do_quiet }, { "reply", do_reply }, { "replay", do_replay }, { "say", do_say }, { "shout", do_shout }, { "yell", do_yell }, { "pray", do_pray }, { "beep", do_beep }, { "racetalk", do_racetalk }, { "whisper", do_whisper }, { "hero", do_hero }, { "hint", do_hint }, { "penter", do_penter }, { "ooc", do_ooc }, { "shortdescr", do_shortdescr }, { "newbie", do_newbie }, { "introduce", do_introduce }, { "announce", do_announce }, { "strap", do_strap }, { "unsheath", do_unsheath }, { "sheath", do_sheath }, { "belt", do_belt }, { "cloak", do_cloak }, { "hood", do_hood }, { "brandish", do_brandish }, { "close", do_close }, { "drink", do_drink }, { "drop", do_drop }, { "eat", do_eat }, { "envenom", do_envenom }, { "fill", do_fill }, { "give", do_give }, { "heal", do_heal }, { "list", do_list }, { "lock", do_lock }, { "open", do_open }, { "pick", do_pick }, { "pour", do_pour }, { "put", do_put }, { "quaff", do_quaff }, { "recite", do_recite }, { "remove", do_remove }, { "sell", do_sell }, { "sacrifice", do_sacrifice }, { "value", do_value }, { "wear", do_wear }, { "zap", do_zap }, { "forge", do_forge }, { "brew", do_brew }, { "resize", do_resize }, { "search", do_search }, { "ohide", do_ohide }, { "newforge", do_newforge }, { "demand", do_demand }, { "exchange", do_exchange }, { "boxrent", do_boxrent }, { "store", do_store }, { "retrieve", do_retrieve }, { "smithing", do_smithing }, { "repair", do_repair }, { "tally", do_tally }, { "sharpen", do_sharpen }, { "butcher", do_butcher }, { "qsmith", do_qsmith }, { "purify", do_purify }, { "throatchop", do_throatchop }, { "backstab", do_backstab }, { "bash", do_bash }, { "berserk", do_berserk }, { "dirt", do_dirt }, { "disarm", do_disarm }, { "flee", do_flee }, { "kick", do_kick }, { "murde", do_murde }, { "murder", do_murder }, { "rescue", do_rescue }, { "trip", do_trip }, { "engage", do_engage }, { "whirlwind", do_whirlwind }, { "circle", do_circle }, { "surrender", do_surrender }, { "war", do_war }, { "warcry", do_warcry }, { "assassinate",do_assassinate }, { "bloodlust", do_bloodlust }, { "nature", do_nature }, { "knee", do_knee }, { "srush", do_srush }, { "spin", do_spin }, { "rage", do_rage }, { "draw", do_draw }, { "fire", do_fire }, { "dislodge", do_dislodge }, { "gouge", do_gouge, }, { "cleave", do_cleave }, { "blackjack", do_blackjack }, { "stake", do_stake }, { "tail", do_tail }, { "doorbash", do_doorbash }, { "feed", do_feed }, { "rub", do_rub }, { "mob", do_mob }, { "enter", do_enter }, { "follow", do_follow }, { "gain", do_gain }, { "enter", do_enter }, { "groups", do_groups }, { "hide", do_hide }, { "play", do_play }, { "qui", do_qui }, { "quit", do_quit }, { "recall", do_recall }, { "wpoint", do_wpoint }, { "rent", do_rent }, { "save", do_save }, { "sleep", do_sleep }, { "sneak", do_sneak }, { "split", do_split }, { "steal", do_steal }, { "train", do_train }, { "visible", do_visible }, { "wake", do_wake }, { "where", do_where }, { "throw", do_throw }, { "second", do_second }, { "become", do_become }, { "hometown", do_hometown }, { "autoall", do_autoall }, { "study", do_study }, { "travel", do_travel }, { "withdraw", do_withdraw }, { "change", do_change }, { "deposit", do_deposit }, { "account", do_account }, { "share", do_share }, { "btransfer", do_btransfer }, { "gquest", do_gquest }, { "qpgive", do_qpgive }, { "quest", do_quest }, { "tpgive", do_tpgive }, { "tpspend", do_tpspend }, { "restring", do_restring }, { "token", do_token }, { "question", do_question }, { "use", do_use }, { "petlevel", do_petlevel }, { "petname", do_petname }, { "rental", do_rental }, { "track", do_track }, { "channel", do_channel }, { "clear", do_clear }, { "splay", do_splay }, { "songs", do_songs }, { "bounty", do_bounty }, { "recl", do_recl }, { "reclass", do_reclass }, { "arshow", do_arshow }, { "petcall", do_petcall }, { "mount", do_mount }, { "dismount", do_dismount }, { "beseech", do_beseech }, { "tithe", do_tithe }, { "autolevel", do_autolevel }, { "level", do_level }, { "bite", do_bite }, { "turn", do_turn }, { "familiar", do_familiar }, { "mtsteal", do_mtsteal }, { "petshow", do_petshow }, { "info", do_info }, { "revert", do_revert }, { "convert", do_convert }, { "map", do_map }, { "seize", do_seize }, { "helptally", do_helptally }, { "updatechar", do_updatechar }, { "advance", do_advance }, { "copyover", do_copyover }, { "dump", do_dump }, { "trust", do_trust }, { "violate", do_violate }, { "allow", do_allow }, { "ban", do_ban }, { "deny", do_deny }, { "disconnect", do_disconnect }, { "flag", do_flag }, { "freeze", do_freeze }, { "permban", do_permban }, { "protect", do_protect }, { "reboo", do_reboo }, { "reboot", do_reboot }, { "set", do_set }, { "shutdow", do_shutdow }, { "shutdown", do_shutdown }, { "wizlock", do_wizlock }, { "force", do_force }, { "load", do_load }, { "newlock", do_newlock }, { "nochannels", do_nochannels }, { "noemote", do_noemote }, { "noshout", do_noshout }, { "notell", do_notell }, { "silence", do_silence }, { "pecho", do_pecho }, { "pardon", do_pardon }, { "purge", do_purge }, { "restore", do_restore }, { "sla", do_sla }, { "slay", do_slay }, { "teleport", do_transfer }, { "poofin", do_bamfin }, { "poofout", do_bamfout }, { "echo", do_echo }, { "holylight", do_holylight }, { "incognito", do_incognito }, { "invis", do_invis }, { "log", do_log }, { "memory", do_memory }, { "mwhere", do_mwhere }, { "owhere", do_owhere }, { "peace", do_peace }, { "recho", do_recho }, { "return", do_return }, { "snoop", do_snoop }, { "stat", do_stat }, { "statlist", do_statlist }, { "string", do_string }, { "switch", do_switch }, { "invis", do_invis }, { "vnum", do_vnum }, { "zecho", do_zecho }, { "clone", do_clone }, { "wiznet", do_wiznet }, { "immtalk", do_immtalk }, { "imotd", do_imotd }, { "smote", do_smote }, { "prefi", do_prefi }, { "prefix", do_prefix }, { "disable", do_disable }, { "avatar", do_avatar }, { "fvlist", do_fvlist }, { "sedit", do_sedit }, { "ifollow", do_ifollow }, { "rename", do_rename }, { "pwipe", do_pwipe }, { "omni", do_omni }, { "imp", do_imp }, { "implag", do_implag }, { "unrestore", do_unrestore }, { "scatter", do_scatter }, { "pload", do_pload }, { "punload", do_punload }, { "wpeace", do_wpeace }, { "skillstat", do_skillstat }, { "spellstat", do_spellstat }, { "olevel", do_olevel }, { "mlevel", do_mlevel }, { "double", do_double }, { "divine", do_divine }, { "astrip", do_astrip }, { "arealinks", do_arealinks }, { "fremove", do_fremove }, { "security", do_security }, { "repeat", do_repeat }, { "repop", do_repop }, { "reward", do_reward }, { "check", do_check }, { "ftick", do_ftick }, { "openvlist", do_openvlist }, { "olist", do_olist }, { "rlist", do_rlist }, { "mlist", do_mlist }, { "immtitle", do_immtitle }, { "otype", do_otype }, { "grantbp", do_grantbp }, { "xpreset", do_xpreset }, { "munique", do_munique }, { "prand", do_prand }, { "gpoint", do_gpoint }, { "timeout", do_timeout }, { "mobslay", do_mobslay }, { "wiznetall", do_wiznetall }, { "admin", do_admin }, { "ibeep", do_ibeep }, { "olc", do_olc }, { "aedit", do_aedit }, { "redit", do_redit }, { "medit", do_medit }, { "oedit", do_oedit }, { "asave", do_asave }, { "alist", do_alist }, { "resets", do_resets }, { "mpdump", do_mpdump }, { "mpstat", do_mpstat }, { "mpedit", do_mpedit }, { "hedit", do_hedit }, { "opedit", do_opedit }, { "rpedit", do_rpedit }, { "opdump", do_opdump }, { "opstat", do_opstat }, { "rpdump", do_rpdump }, { "rpstat", do_rpstat }, { "promote", do_promote }, { "save_guilds",do_save_guilds }, { "gedit", do_gedit }, { "instaroom", do_instaroom }, { "skedit", do_skedit }, { "cmdedit", do_cmdedit }, { "cmdlist", do_cmdlist }, { "mine", do_mine }, { "godchat", do_godchat }, { "autoweather", do_autoweather }, { "wset", do_wset }, { "build", do_build }, { "isignal", do_isignal }, { "fquit", do_fquit }, { "saveconst", do_saveconst }, { "constval", do_constval }, { "checkvnum", do_checkvnum }, { "levelflux", do_levelflux }, { "petlist", do_petlist }, { "rally", do_rally }, { "punch", do_punch }, { "rlgedit", do_rlgedit }, { "rescind", do_rescind }, { "exalt", do_exalt }, { "initiate", do_initiate }, { "denounce", do_denounce }, { "trivia", do_trivia }, { "suppress", do_suppress }, { "homeb", do_homeb }, { "objbuy", do_objbuy }, { "mobbuy", do_mobbuy }, { "invite", do_invite }, { "home", do_home }, { "hname", do_hname }, { "hdesc", do_hdesc }, { "join", do_join }, { "boot", do_boot }, { "mrelic", do_mrelic }, { "pack", do_pack }, { "sstep", do_sstep }, { "frecall", do_frecall }, { "away", do_away }, { "tfunc", do_testfunc }, { "pcforge", do_pcforge }, { "pshow", do_pshow }, { "post", do_post }, { "chmail", do_chmail }, { "plist", do_plist }, { "pinfo", do_pinfo }, { "timer", do_timer }, { "sound", do_sound }, { "stop", do_stop }, { "testsound", do_testsound }, { "click", do_click }, { "compress", do_compress }, { "showcompress", do_showcompress }, { "mudinfo", do_mudinfo }, { "image", do_image }, { "clist", do_clist }, { "inlay", do_inlay }, { "marry", do_marry }, { "divorce", do_divorce }, { "spousetalk", do_spousetalk }, { "spgate", do_spgate }, { "trade", do_trade }, { "mxp", do_mxp }, { NULL, NULL }, }; const struct size_type cat_table[] = { { "None" }, { "Config" }, { "Common" }, { "Communication" }, { "Info" }, { "Object Manipulation" }, { "Movement" }, { "Combat" }, { NULL } }; const struct size_type log_table[] = { { "Normal" }, { "Always" }, { "Never" }, { NULL } };