/*************************************************************************** * 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. * * * * Envy Diku Mud improvements copyright (C) 1994 by Michael Quan, David * * Love, Guilherme 'Willie' Arnold, and Mitchell Tse. * * * * In order to use any part of this Envy Diku Mud, you must comply with * * the original Diku license in 'license.doc', the Merc license in * * 'license.txt', as well as the Envy license in 'license.nvy'. * * 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. * ***************************************************************************/ /*$Id: interp.c,v 1.51 2005/04/10 16:29:00 tyrion Exp $*/ #if defined( macintosh ) #include <types.h> #else #include <sys/types.h> #endif #include <ctype.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #ifndef RUN_AS_WIN32SERVICE #include <unistd.h> #endif #include "merc.h" bool check_social args( ( CHAR_DATA *ch, char *command, char *argument ) ); bool check_alias args( ( CHAR_DATA *ch, char *command, char *argument ) ); void add_alias args( ( CHAR_DATA *ch, ALIAS_DATA *pAl, char *old, char *_new ) ); bool check_disabled args( ( CHAR_DATA *ch, const struct cmd_type *command ) ); bool can_mob_use( CHAR_DATA *ch, char *argument); DISABLED_DATA *disabled_first; #define END_MARKER "END" /* for load_disabled && save_disabled */ /* * Command logging types. */ #define LOG_NORMAL 0 #define LOG_ALWAYS 1 #define LOG_NEVER 2 /* * Altrag was here. */ #define LOG_BUILD 3 /* * God Levels - Check them out in merc.h */ #define L_HER LEVEL_HERO /* * Log-all switch. */ bool fLogAll = FALSE; /* * Command table. */ struct cmd_type cmd_table [ ] = { /* * Common movement commands. */ { "north", do_north, POS_GHOST, 0, LOG_NORMAL }, { "east", do_east, POS_GHOST, 0, LOG_NORMAL }, { "south", do_south, POS_GHOST, 0, LOG_NORMAL }, { "west", do_west, POS_GHOST, 0, LOG_NORMAL }, { "up", do_up, POS_GHOST, 0, LOG_NORMAL }, { "down", do_down, POS_GHOST, 0, LOG_NORMAL }, /* XOR */ { "push", do_push, POS_STANDING, 0, LOG_NORMAL }, { "drag", do_drag, POS_STANDING, 0, LOG_NORMAL }, /* * Common other commands. * Placed here so one and two letter abbreviations work. */ { "buy", do_buy, POS_STANDING, 0, LOG_NORMAL }, { "cast", do_cast, POS_FIGHTING, 0, LOG_NORMAL }, { "qb", do_quickburst, POS_FIGHTING, 0, LOG_NORMAL }, { "quickburst", do_quickburst, POS_FIGHTING, 0, LOG_NORMAL }, { "use", do_use, POS_FIGHTING, 0, LOG_NORMAL }, { "dual", do_dual, POS_FIGHTING, 0, LOG_NORMAL }, { "exits", do_exits, POS_RESTING, 0, LOG_NORMAL }, { "get", do_get, POS_STANDING, 0, LOG_NORMAL }, { "inventory", do_inventory, POS_DEAD, 0, LOG_NORMAL }, { "invoke", do_invoke, POS_FIGHTING, 0, LOG_NORMAL }, { "kill", do_kill, POS_FIGHTING, 0, LOG_NORMAL }, { "look", do_look, POS_RESTING, 0, LOG_NORMAL }, { "order", do_order, POS_RESTING, 0, LOG_ALWAYS }, { "rest", do_rest, POS_SLEEPING, 0, LOG_NORMAL }, { "repair", do_repair, POS_STANDING, 0, LOG_NORMAL }, { "sleep", do_sleep, POS_SLEEPING, 0, LOG_NORMAL }, { "stand", do_stand, POS_SLEEPING, 0, LOG_NORMAL }, { "tell", do_tell, POS_RESTING, 0, LOG_NORMAL }, { "wield", do_wear, POS_FIGHTING, 0, LOG_NORMAL }, { "wizhelp", do_wizhelp, POS_DEAD, 0, LOG_NORMAL }, { "multiburst", do_multiburst, POS_FIGHTING, 0, LOG_NORMAL }, { "mb", do_multiburst, POS_FIGHTING, 0, LOG_NORMAL }, { "mpstat", do_mpstat, POS_DEAD, L_APP, LOG_NORMAL }, { "mpcommands", do_mpcommands, POS_DEAD, L_APP, LOG_NORMAL }, { "mpasound", do_mpasound, POS_DEAD, 0, LOG_NORMAL }, { "mpjunk", do_mpjunk, POS_DEAD, 0, LOG_NORMAL }, { "mpastatus", do_mpastatus, POS_DEAD, 0, LOG_NORMAL }, { "mpdisable", do_mpdisable, POS_DEAD, 0, LOG_NORMAL }, { "mpenable", do_mpenable, POS_DEAD, 0, LOG_NORMAL }, { "mpecho", do_mpecho, POS_DEAD, 0, LOG_NORMAL }, { "mpechoat", do_mpechoat, POS_DEAD, 0, LOG_NORMAL }, { "mpechoaround", do_mpechoaround,POS_DEAD, 0, LOG_NORMAL }, { "mpkill", do_mpkill ,POS_DEAD, 0, LOG_NORMAL }, { "mpmload", do_mpmload ,POS_DEAD, 0, LOG_NORMAL }, { "mpoload", do_mpoload ,POS_DEAD, 0, LOG_NORMAL }, { "mppurge", do_mppurge ,POS_DEAD, 0, LOG_NORMAL }, { "mpgoto", do_mpgoto ,POS_DEAD, 0, LOG_NORMAL }, { "mpat", do_mpat ,POS_DEAD, 0, LOG_NORMAL }, { "mptransfer", do_mptransfer ,POS_DEAD, 0, LOG_NORMAL }, { "mpforce", do_mpforce ,POS_DEAD, 0, LOG_NORMAL }, { "mpteleport", do_mpteleport, POS_DEAD, 0, LOG_NORMAL }, { "mpgainxp", do_mpgainxp, POS_DEAD, 0, LOG_NORMAL }, { "mpgainqp", do_mpgainqp, POS_DEAD, 0, LOG_NORMAL }, /* * Informational commands. */ { "affected", do_affectedby, POS_RESTING, 0, LOG_NORMAL }, { "areas", do_areas, POS_DEAD, 0, LOG_NORMAL }, { "bug", do_bug, POS_DEAD, 0, LOG_NORMAL }, { "commands", do_commands, POS_DEAD, 0, LOG_NORMAL }, { "compare", do_compare, POS_STANDING, 0, LOG_NORMAL }, { "consider", do_consider, POS_STANDING, 0, LOG_NORMAL }, { "credits", do_credits, POS_DEAD, 0, LOG_NORMAL }, { "enter", do_enter, POS_GHOST, 0, LOG_NORMAL }, { "equipment", do_equipment, POS_DEAD, 0, LOG_NORMAL }, { "examine", do_examine, POS_RESTING, 0, LOG_NORMAL }, { "finger", do_finger, POS_DEAD, L_DIR, LOG_ALWAYS }, { "hlist", do_hlist, POS_DEAD, L_APP, LOG_NORMAL }, { "help", do_help, POS_DEAD, 0, LOG_NORMAL }, { "idea", do_idea, POS_DEAD, 0, LOG_NORMAL }, { "report", do_report, POS_DEAD, 0, LOG_NORMAL }, { "pagelength", do_pagelen, POS_DEAD, 0, LOG_NORMAL }, { "read", do_look, POS_RESTING, 0, LOG_NORMAL }, { "score", do_score, POS_DEAD, 0, LOG_NORMAL }, { "slist", do_slist, POS_DEAD, 0, LOG_NORMAL }, { "socials", do_socials, POS_DEAD, 0, LOG_NORMAL }, { "time", do_time, POS_DEAD, 0, LOG_NORMAL }, { "typo", do_typo, POS_DEAD, 0, LOG_NORMAL }, { "weather", do_weather, POS_RESTING, 0, LOG_NORMAL }, { "worth", do_worth, POS_DEAD, 0, LOG_NORMAL }, { "who", do_who, POS_DEAD, 0, LOG_NORMAL }, { "wizlist", do_wizlist, POS_DEAD, 0, LOG_NORMAL }, /* * Clan commands. */ { "smash", do_smash, POS_STANDING, 30, LOG_NORMAL }, { "induct", do_induct, POS_STANDING, 0, LOG_ALWAYS }, { "outcast", do_outcast, POS_STANDING, 0, LOG_ALWAYS }, { "setlev", do_setlev, POS_STANDING, 0, LOG_ALWAYS }, { "cinfo", do_cinfo, POS_DEAD, 0, LOG_NORMAL }, { "clanview", do_clanview, POS_SLEEPING, 30, LOG_NORMAL }, { "clanheal", do_clan_heal, POS_STANDING, 30, LOG_NORMAL }, { "utopian healing",do_utopian_healing,POS_STANDING, 30, LOG_NORMAL }, /* * Guild commands */ { "guild", do_guild, POS_DEAD, 0, LOG_ALWAYS }, { "unguild", do_unguild, POS_DEAD, 0, LOG_ALWAYS }, { "setrank", do_setrank, POS_DEAD, 0, LOG_ALWAYS }, { "gdt", do_gdt, POS_SLEEPING, 0, LOG_NORMAL }, { "guildtalk", do_gdt, POS_SLEEPING, 0, LOG_NORMAL }, /* * Configuration commands. */ { "alias", do_alias, POS_DEAD, 0, LOG_NORMAL }, { "auto", do_auto, POS_DEAD, 0, LOG_NORMAL }, { "autoexit", do_autoexit, POS_DEAD, 0, LOG_NORMAL }, { "autoloot", do_autoloot, POS_DEAD, 0, LOG_NORMAL }, { "autogold", do_autogold, POS_DEAD, 0, LOG_NORMAL }, { "autosac", do_autosac, POS_DEAD, 0, LOG_NORMAL }, { "blank", do_blank, POS_DEAD, 0, LOG_NORMAL }, { "brief", do_brief, POS_DEAD, 0, LOG_NORMAL }, { "channels", do_channels, POS_DEAD, 0, LOG_NORMAL }, { "combine", do_combine, POS_DEAD, 0, LOG_NORMAL }, { "config", do_config, POS_DEAD, 0, LOG_NORMAL }, { "description", do_description, POS_DEAD, 0, LOG_NORMAL }, { "password", do_password, POS_DEAD, 0, LOG_NEVER }, { "speak", do_speak, POS_RESTING, 0, LOG_NORMAL }, { "learn", do_learn, POS_STANDING, 0, LOG_NORMAL }, { "sedit", do_sedit, POS_DEAD, L_IMM, LOG_ALWAYS }, { "prompt", do_prompt, POS_DEAD, 0, LOG_NORMAL }, { "title", do_title, POS_DEAD, 0, LOG_NORMAL }, { "wimpy", do_wimpy, POS_STANDING, 0, LOG_NORMAL }, { "countcommands", do_countcommands,POS_DEAD, L_CON, LOG_NORMAL }, { "timequake", do_timequake, POS_DEAD, L_OVD, LOG_ALWAYS }, { "recall", do_noob_recall, POS_GHOST, 0, LOG_NORMAL }, /* * Communication commands. */ { "answer", do_answer, POS_SLEEPING, 0, LOG_NORMAL }, { "auction", do_auction, POS_STANDING, 0, LOG_NORMAL }, { "bid", do_bid, POS_STANDING, 0, LOG_ALWAYS }, { "chat", do_chat, POS_SLEEPING, 0, LOG_NORMAL }, { "mutter", do_mutter, POS_SLEEPING, 0, LOG_NORMAL }, { "<", do_mutter, POS_SLEEPING, 0, LOG_NORMAL }, { ".", do_chat, POS_SLEEPING, 0, LOG_NORMAL }, { "emote", do_emote, POS_RESTING, 0, LOG_NORMAL }, { ",", do_emote, POS_RESTING, 0, LOG_NORMAL }, { "gtell", do_gtell, POS_DEAD, 0, LOG_NORMAL }, { ";", do_gtell, POS_DEAD, 0, LOG_NORMAL }, { "music", do_music, POS_SLEEPING, 0, LOG_NORMAL }, { "note", do_note, POS_SLEEPING, 0, LOG_NORMAL }, { "pose", do_pose, POS_RESTING, 0, LOG_NORMAL }, { "quest", do_quest, POS_STANDING, 0, LOG_NORMAL }, { "question", do_question, POS_SLEEPING, 0, LOG_NORMAL }, { "reply", do_reply, POS_SLEEPING, 0, LOG_NORMAL }, { "say", do_say, POS_RESTING, 0, LOG_NORMAL }, { "'", do_say, POS_RESTING, 0, LOG_NORMAL }, { "shout", do_shout, POS_RESTING, 3, LOG_NORMAL }, { "yell", do_yell, POS_RESTING, 0, LOG_NORMAL }, { "clantalk", do_clan, POS_DEAD, 0, LOG_NORMAL }, { "class", do_class, POS_DEAD, 0, LOG_NORMAL }, { ">", do_class, POS_DEAD, 0, LOG_NORMAL }, { "guard", do_guard, POS_DEAD, L_DIR, LOG_NORMAL }, { "[", do_guard, POS_DEAD, L_DIR, LOG_NORMAL }, { "timelord", do_timelord, POS_DEAD, L_CON, LOG_NORMAL }, { "stormlord", do_timelord, POS_DEAD, L_CON, LOG_NORMAL }, { "=", do_timelord, POS_DEAD, L_CON, LOG_NORMAL }, { "tl", do_timelord, POS_DEAD, L_CON, LOG_NORMAL }, { "ooc", do_ooc, POS_DEAD, 0, LOG_NORMAL }, { "info", do_info, POS_DEAD, 0, LOG_ALWAYS }, /* * Object manipulation commands. */ { "brandish", do_brandish, POS_FIGHTING, 0, LOG_NORMAL }, { "close", do_close, POS_FIGHTING, 0, LOG_NORMAL }, { "drink", do_drink, POS_FIGHTING, 0, LOG_NORMAL }, { "drop", do_drop, POS_FIGHTING, 0, LOG_NORMAL }, { "eat", do_eat, POS_FIGHTING, 0, LOG_NORMAL }, { "fill", do_fill, POS_STANDING, 0, LOG_NORMAL }, { "forge", do_forge, POS_STANDING, 30, LOG_ALWAYS }, { "give", do_give, POS_FIGHTING, 0, LOG_NORMAL }, { "hold", do_wear, POS_FIGHTING, 0, LOG_NORMAL }, { "join", do_join, POS_FIGHTING, 0, LOG_NORMAL }, { "list", do_list, POS_STANDING, 0, LOG_NORMAL }, { "lock", do_lock, POS_FIGHTING, 0, LOG_NORMAL }, { "open", do_open, POS_FIGHTING, 0, LOG_NORMAL }, { "patch", do_patch, POS_STANDING, 0, LOG_NORMAL }, { "put", do_put, POS_FIGHTING, 0, LOG_NORMAL }, { "quaff", do_quaff, POS_FIGHTING, 0, LOG_NORMAL }, { "recite", do_recite, POS_FIGHTING, 0, LOG_NORMAL }, { "remove", do_remove, POS_FIGHTING, 0, LOG_NORMAL }, { "search", do_search, POS_STANDING, 0, LOG_NORMAL }, { "sell", do_sell, POS_STANDING, 0, LOG_NORMAL }, { "take", do_get, POS_STANDING, 0, LOG_NORMAL }, { "sacrifice", do_sacrifice, POS_GHOST, 0, LOG_NORMAL }, { "separate", do_separate, POS_FIGHTING, 0, LOG_NORMAL }, { "unlock", do_unlock, POS_FIGHTING, 0, LOG_NORMAL }, { "value", do_value, POS_STANDING, 0, LOG_NORMAL }, { "wear", do_wear, POS_FIGHTING, 0, LOG_NORMAL }, { "zap", do_zap, POS_FIGHTING, 0, LOG_NORMAL }, { "fire", do_fire, POS_FIGHTING, 0, LOG_NORMAL }, { "stare", do_stare, POS_STANDING, 0, LOG_NORMAL }, /* * Combat commands. */ { "flee", do_flee, POS_FIGHTING, 0, LOG_NORMAL }, { "murde", do_murde, POS_FIGHTING, 5, LOG_NORMAL }, { "murder", do_murder, POS_FIGHTING, 5, LOG_NORMAL }, { "throw", do_throw, POS_STANDING, 0, LOG_NORMAL }, /* * Race Commands * */ { "breathe", do_breathe_fire, POS_STANDING, 0, LOG_NORMAL }, { "fly", do_race_fly, POS_STANDING, 0, LOG_NORMAL }, /* * Miscellaneous commands. */ { "afk", do_afk, POS_SLEEPING, 0, LOG_NORMAL }, { "bet", do_bet, POS_STANDING, 0, LOG_NORMAL }, { "delet", do_delet, POS_DEAD, 0, LOG_ALWAYS }, { "delete", do_delete, POS_DEAD, 0, LOG_NORMAL }, { "account", do_account, POS_RESTING, 0, LOG_NORMAL }, { "bodybag", do_bodybag, POS_DEAD, L_DEI, LOG_ALWAYS }, { "follow", do_follow, POS_RESTING, 0, LOG_NORMAL }, { "lose", do_lose, POS_RESTING, 0, LOG_NORMAL }, { "group", do_group, POS_SLEEPING, 0, LOG_NORMAL }, { "heal", do_heal, POS_RESTING, 0, LOG_NORMAL }, { "palm", do_palm, POS_STANDING, 0, LOG_NORMAL }, { "ban", do_ban, POS_DEAD, L_DIR, LOG_ALWAYS }, { "bank", do_bank, POS_STANDING, 0, LOG_NORMAL }, { "practice", do_practice, POS_STANDING, 0, LOG_NORMAL}, { "qui", do_qui, POS_DEAD, 0, LOG_NORMAL }, { "quit", do_quit, POS_DEAD, 0, LOG_NORMAL }, { "rent", do_rent, POS_DEAD, 0, LOG_NORMAL }, { "save", do_save, POS_DEAD, 2, LOG_NORMAL }, { "sleep", do_sleep, POS_SLEEPING, 0, LOG_NORMAL }, { "spells", do_spells2, POS_SLEEPING, 0, LOG_NORMAL }, { "skills", do_skills, POS_SLEEPING, 0, LOG_NORMAL }, { "split", do_split, POS_STANDING, 0, LOG_NORMAL }, { "steal", do_steal, POS_STANDING, 0, LOG_NORMAL }, { "study", do_study, POS_STANDING, 0, LOG_NORMAL }, { "train", do_train, POS_STANDING, 0, LOG_NORMAL }, { "visible", do_visible, POS_SLEEPING, 0, LOG_NORMAL }, { "reality", do_reality, POS_SLEEPING, 0, LOG_NORMAL }, { "wake", do_wake, POS_SLEEPING, 0, LOG_NORMAL }, { "where", do_where, POS_RESTING, 0, LOG_NORMAL }, { "pray", do_pray, POS_STANDING, 0, LOG_NORMAL }, { "mount", do_mount, POS_STANDING, 0, LOG_NORMAL }, { "dismount", do_dismount, POS_STANDING, 0, LOG_NORMAL }, /* { "challenge", do_challenge, POS_STANDING, 0, LOG_NORMAL }, { "accept", do_accept, POS_STANDING, 0, LOG_NORMAL }, { "decline", do_decline, POS_STANDING, 0, LOG_NORMAL },*/ { "remortalize", do_remortalize, POS_STANDING, 0, LOG_ALWAYS }, { "devote", do_devote, POS_STANDING, 0, LOG_ALWAYS }, /* * Immortal commands. */ { "vused", do_vused, POS_DEAD, L_DEI, LOG_NORMAL }, { "vnum", do_vnum, POS_DEAD, L_DEI, LOG_NORMAL }, { "load", do_load, POS_DEAD, L_IMP, LOG_NORMAL }, { "restrict", do_restrict, POS_DEAD, L_SEN, LOG_NORMAL }, { "astatus", change_area_status, POS_DEAD, L_CON, LOG_ALWAYS }, { "authorize", do_authorize, POS_DEAD, L_APP, LOG_ALWAYS }, { "advance", do_advance, POS_DEAD, L_CON, LOG_ALWAYS }, { "imtlset", do_imtlset, POS_DEAD, L_SEN, LOG_ALWAYS }, { "sstime", do_sstime, POS_DEAD, L_IMP, LOG_ALWAYS }, { "trust", do_trust, POS_DEAD, L_CON, LOG_ALWAYS }, { "dostat", do_dostat, POS_DEAD, L_CON, LOG_ALWAYS }, { "allow", do_allow, POS_DEAD, L_SEN, LOG_ALWAYS }, { "deny", do_deny, POS_DEAD, L_DIR, LOG_ALWAYS }, { "disconnect", do_disconnect, POS_DEAD, L_APP, LOG_ALWAYS }, { "force", do_force, POS_DEAD, L_DEI, LOG_ALWAYS }, { "freeze", do_freeze, POS_DEAD, L_DEI, LOG_ALWAYS }, { "fset", do_fset, POS_DEAD, L_OVD, LOG_ALWAYS }, { "at", do_at, POS_DEAD, L_APP, LOG_NORMAL }, { "atall", do_for, POS_DEAD, L_OVD, LOG_ALWAYS }, { "log", do_log, POS_DEAD, L_DIR, LOG_ALWAYS }, { "mset", do_mset, POS_DEAD, L_DEI, LOG_BUILD }, { "newcorpse", do_newcorpse, POS_DEAD, L_IMM, LOG_ALWAYS }, { "lset", do_lset, POS_DEAD, L_DEI, LOG_BUILD }, { "noemote", do_noemote, POS_DEAD, L_DEI, LOG_NORMAL }, { "notell", do_notell, POS_DEAD, L_DEI, LOG_NORMAL }, { "notestat", do_notestat, POS_DEAD, L_DEI, LOG_NORMAL }, { "numlock", do_numlock, POS_DEAD, L_CON, LOG_ALWAYS }, { "oload", do_oload, POS_DEAD, L_APP, LOG_BUILD }, { "oset", do_oset, POS_DEAD, L_IMM, LOG_BUILD }, { "pardon", do_pardon, POS_DEAD, L_IMP, LOG_ALWAYS }, { "purge", do_purge, POS_DEAD, L_APP, LOG_NORMAL }, { "reboo", do_reboo, POS_DEAD, L_ARC, LOG_NORMAL }, { "reboot", do_reboot, POS_DEAD, L_ARC, LOG_ALWAYS }, { "restore", do_restore, POS_DEAD, L_DEI, LOG_ALWAYS }, { "shutdow", do_shutdow, POS_DEAD, L_KPR, LOG_NORMAL }, { "shutdown", do_shutdown, POS_DEAD, L_KPR, LOG_ALWAYS }, { "silence", do_silence, POS_DEAD, L_DEI, LOG_ALWAYS }, { "set", do_set, POS_DEAD, L_IMP, LOG_ALWAYS }, { "sla", do_sla, POS_DEAD, L_DEI, LOG_NORMAL }, { "slay", do_slay, POS_DEAD, L_DEI, LOG_ALWAYS }, { "sset", do_sset, POS_DEAD, L_OVD, LOG_ALWAYS }, { "sstat", do_sstat, POS_DEAD, L_APP, LOG_NORMAL }, { "stat", do_stat, POS_DEAD, L_IMP, LOG_ALWAYS }, { "string", do_string, POS_DEAD, L_APP, LOG_ALWAYS }, { "transfer", do_transfer, POS_DEAD, L_APP, LOG_ALWAYS }, { "users", do_users, POS_DEAD, L_IMM, LOG_NORMAL }, { "wizify", do_wizify, POS_DEAD, L_CON, LOG_ALWAYS }, { "wizlock", do_wizlock, POS_DEAD, L_CON, LOG_ALWAYS }, { "disable", do_disable, POS_DEAD, L_CON, LOG_ALWAYS }, { "iscore", do_iscore, POS_DEAD, L_APP, LOG_ALWAYS }, { "echo", do_echo, POS_DEAD, L_ARC, LOG_ALWAYS }, { "memory", do_memory, POS_DEAD, L_APP, LOG_NORMAL }, { "mload", do_mload, POS_DEAD, L_DEI, LOG_BUILD }, { "mfind", do_mfind, POS_DEAD, L_DEI, LOG_NORMAL }, { "mstat", do_mstat, POS_DEAD, L_DEI, LOG_NORMAL }, { "lstat", do_lstat, POS_DEAD, L_APP, LOG_NORMAL }, { "mwhere", do_mwhere, POS_DEAD, L_DEI, LOG_NORMAL }, { "newlock", do_newlock, POS_DEAD, L_CON, LOG_ALWAYS }, { "ofind", do_ofind, POS_DEAD, L_APP, LOG_NORMAL }, { "ostat", do_ostat, POS_DEAD, L_DEI, LOG_NORMAL }, { "owhere", do_owhere, POS_DEAD, L_DEI, LOG_NORMAL }, { "pecho", do_pecho, POS_DEAD, L_DEI, LOG_ALWAYS }, { "rename", do_rename, POS_DEAD, L_OVD, LOG_ALWAYS }, { "wizpwd", do_wizpwd, POS_DEAD, L_CON, LOG_ALWAYS }, { "smite", do_smite, POS_DEAD, L_DEI, LOG_ALWAYS }, { "dog", do_dog, POS_DEAD, L_OVD, LOG_ALWAYS }, { "seize", do_seize, POS_DEAD, L_DIR, LOG_ALWAYS }, { "update", do_update, POS_DEAD, L_CON, LOG_ALWAYS }, { "peace", do_peace, POS_DEAD, L_APP, LOG_NORMAL }, { "pload", do_pload, POS_DEAD, L_DIR, LOG_ALWAYS }, { "top", do_top, POS_DEAD, L_KPR, LOG_NORMAL }, { "pwhere", do_pwhere, POS_DEAD, L_APP, LOG_NORMAL }, { "recho", do_recho, POS_DEAD, L_DEI, LOG_ALWAYS }, { "realmemory", do_realmemory, POS_DEAD, L_OVD, LOG_BUILD }, { "return", do_return, POS_DEAD, L_APP, LOG_NORMAL }, { "rset", do_rset, POS_DEAD, L_IMM, LOG_BUILD }, { "rstat", do_rstat, POS_DEAD, L_DEI, LOG_NORMAL }, { "showcorrupt", do_showcorrupt, POS_DEAD, L_OVD, LOG_NORMAL }, { "slookup", do_slookup, POS_DEAD, 0, LOG_NORMAL}, { "snoop", do_snoop, POS_DEAD, L_SEN, LOG_ALWAYS }, { "switch", do_switch, POS_DEAD, L_CON, LOG_ALWAYS }, { "wizinvis", do_invis, POS_DEAD, L_APP, LOG_NORMAL }, { "wrlist", do_wrlist, POS_DEAD, L_DEI, LOG_NORMAL }, { "marry", do_marry, POS_DEAD, L_SEN, LOG_ALWAYS }, { "divorce", do_divorce, POS_DEAD, L_SEN, LOG_ALWAYS }, { "rings", do_rings, POS_DEAD, L_IMP, LOG_ALWAYS }, { "makelegend", do_makelegend, POS_DEAD, L_OVD, LOG_ALWAYS }, { "astrip", do_astrip, POS_DEAD, L_DEI, LOG_NORMAL }, { "bamfin", do_bamfin, POS_DEAD, L_APP, LOG_NORMAL }, { "bamfout", do_bamfout, POS_DEAD, L_APP, LOG_NORMAL }, { "bamfsin", do_bamfsin, POS_DEAD, L_APP, LOG_NORMAL }, { "bamfsout", do_bamfsout, POS_DEAD, L_APP, LOG_NORMAL }, { "goto", do_goto, POS_DEAD, L_APP, LOG_NORMAL }, { "holylight", do_holylight, POS_DEAD, L_APP, LOG_NORMAL }, { "immtalk", do_immtalk, POS_DEAD, L_APP, LOG_NORMAL }, { ":", do_immtalk, POS_DEAD, L_APP, LOG_NORMAL }, { "champion", do_hero, POS_DEAD, LEVEL_HERO, LOG_NORMAL }, { "-", do_hero, POS_DEAD, LEVEL_HERO, LOG_NORMAL }, { "demigod", do_demigod, POS_DEAD, LEVEL_DEMIGOD, LOG_NORMAL }, { "]", do_demigod, POS_DEAD, LEVEL_DEMIGOD, LOG_NORMAL }, { "gratz", do_gratz, POS_DEAD, 1, LOG_NORMAL }, /* * Clan commands -- Altrag */ { "clans", do_clans, POS_DEAD, 0, LOG_NORMAL }, { "transmute", do_transmute, POS_RESTING, 30, LOG_NORMAL }, { "bestow", do_bestow, POS_DEAD, L_DEI, LOG_NORMAL }, { "image", do_image, POS_STANDING, 30, LOG_NORMAL }, { "cleanstat", do_cleanstat, POS_DEAD, 0, LOG_ALWAYS }, { "religions", do_religions, POS_DEAD, 0, LOG_NORMAL }, { "religioninfo", do_religioninfo,POS_DEAD, 0, LOG_NORMAL }, { "relinfo", do_religioninfo,POS_DEAD, 0, LOG_NORMAL }, { "relquest", do_relquest, POS_DEAD, 0, LOG_NORMAL }, { "crusade", do_crusade, POS_DEAD, 0, LOG_NORMAL }, { "map", do_map, POS_DEAD, 0, LOG_NORMAL }, /* * OLC 1.1b */ { "aedit", do_aedit, POS_DEAD, L_CON, LOG_BUILD }, { "cedit", do_cedit, POS_DEAD, L_CON, LOG_BUILD }, { "hedit", do_hedit, POS_DEAD, L_IMP, LOG_BUILD }, { "redit", do_redit, POS_DEAD, L_DEI, LOG_BUILD }, { "oedit", do_oedit, POS_DEAD, L_DEI, LOG_BUILD }, { "medit", do_medit, POS_DEAD, L_DEI, LOG_BUILD }, { "asave", do_asave, POS_DEAD, L_DEI, LOG_NORMAL }, { "alist", do_alist, POS_DEAD, L_DEI, LOG_NORMAL }, { "resets", do_resets, POS_DEAD, L_DEI, LOG_NORMAL }, { "reledit", do_reledit, POS_DEAD, L_CON, LOG_BUILD }, { "resetxp", do_resetxp, POS_DEAD, L_OVD, LOG_ALWAYS }, /* Moved for OLC conflicts */ /* * End of list. */ { "", 0, POS_DEAD, 0, LOG_NORMAL } }; /* * The main entry point for executing commands. * Can be recursively called from 'at', 'order', 'force'. */ void interpret( CHAR_DATA *ch, char *argument ) { char command [ MAX_INPUT_LENGTH ]; char logline [ MAX_INPUT_LENGTH ]; int cmd; int trust; bool found; if ( ch->wait > 0 ) return; if (!IS_NPC(ch) && ch->pcdata->craft_timer > 0) destroy_craft( ch, FALSE ); /* * Strip leading spaces. */ while ( isspace( *argument ) ) argument++; if ( argument[0] == '\0' ) return; if ( !IS_NPC( ch ) && IS_SET( ch->act, PLR_AFK ) ) { send_to_char(AT_WHITE, "You're marked as AFK, do something about it!\n\r", ch); } if ( IS_AFFECTED3( ch, AFF_TORTURE ) && (IS_SET(ch->in_room->room_flags, ROOM_SAFE) ) ) send_to_char(AT_BLOOD, "Your tortured soul demands vengeance!\n\r", ch); /* * Implement freeze command. */ if ( !IS_NPC( ch ) && IS_SET( ch->act, PLR_FREEZE ) ) { send_to_char(AT_LBLUE, "You're totally frozen!\n\r", ch ); return; } /* * Implement stun. */ if ( IS_STUNNED( ch, STUN_COMMAND ) || IS_STUNNED( ch, STUN_TOTAL ) ) { send_to_char(AT_LBLUE, "You're too stunned to do anything!\n\r", ch ); return; } /* * Grab the command word. * Special parsing so ' can be a command, * also no spaces needed after punctuation. */ strcpy( logline, argument ); if ( !isalpha( argument[0] ) && !isdigit( argument[0] ) ) { command[0] = argument[0]; command[1] = '\0'; argument++; while ( isspace( *argument ) ) argument++; } else { argument = one_argument( argument, command ); } /* * Look for command in command table. */ found = FALSE; trust = get_trust( ch ); for ( cmd = 0; cmd_table[cmd].name[0] != '\0'; cmd++ ) { if ( command[0] == cmd_table[cmd].name[0] && !str_prefix( command, cmd_table[cmd].name ) && ( ( cmd_table[cmd].level <= trust ) || ( IS_SET( ch->affected_by2, CODER ) ) ) ) { found = TRUE; break; } } /* * Log and snoop. */ if ( cmd_table[cmd].log == LOG_NEVER ) strcpy( logline, "XXXXXXXX XXXXXXXX XXXXXXXX" ); /* * Builder Logs. * Added by Altrag. */ if ( cmd_table[cmd].log == LOG_BUILD ) { sprintf( log_buf, "%s: %s", ch->name, logline ); log_string( log_buf, CHANNEL_BUILD , get_trust( ch ) ); } if ( ( !IS_NPC( ch ) && IS_SET( ch->act, PLR_LOG ) ) || fLogAll || cmd_table[cmd].log == LOG_ALWAYS ) { sprintf( log_buf, "%s: %s", ch->name, logline ); log_string( log_buf, CHANNEL_GOD, ch->level - 1 ); } if ( ch->desc && ch->desc->snoop_by ) { sprintf( log_buf, "%s%%", ch->name ); write_to_buffer( ch->desc->snoop_by, log_buf, 0 ); write_to_buffer( ch->desc->snoop_by, logline, 0 ); write_to_buffer( ch->desc->snoop_by, "\n\r", 2 ); } if ( IS_AFFECTED2(ch,AFF_BERSERK) && trust < L_SEN) { if ( !found || (str_cmp( cmd_table[cmd].name, "flee" ) && str_cmp( cmd_table[cmd].name, "look" ) && str_cmp( cmd_table[cmd].name, "retreat" ) && str_cmp( cmd_table[cmd].name, "get" ) && str_cmp( cmd_table[cmd].name, "wield") && str_cmp( cmd_table[cmd].name, "dual" ) && str_cmp( cmd_table[cmd].name, "score")) ) { send_to_char( AT_BLOOD, "You cannot do that in such a rage!\n\r",ch); return; } } if ( IS_AFFECTED3(ch,AFF_BLOODTHIRSTY) && trust < L_SEN) { if ( !found || (str_cmp( cmd_table[cmd].name, "look" ) && str_cmp( cmd_table[cmd].name, "get" ) && str_cmp( cmd_table[cmd].name, "wield") && str_cmp( cmd_table[cmd].name, "dual" ) && str_cmp( cmd_table[cmd].name, "score")) ) { send_to_char( AT_BLOOD, "You cannot do that while so bloodthirsty!\n\r",ch); return; } } if ( IS_AFFECTED4(ch,AFF_BURROW) && trust < L_APP) { if ( !found || (str_cmp( cmd_table[cmd].name, "look" ) && str_cmp( cmd_table[cmd].name, "who" ) && str_cmp( cmd_table[cmd].name, "score")) ) { send_to_char( AT_BLOOD, "You must wait until the earth releases you!\n\r",ch); return; } } if ( !found ) { /* * Look for command in socials table. */ if ( IS_NPC(ch) || !check_alias( ch, command, argument ) ) if ( !check_social( ch, command, argument ) ) send_to_char(C_DEFAULT, "Huh?\n\r", ch ); return; } else if ( check_disabled ( ch, &cmd_table[cmd] ) ) { send_to_char (AT_WHITE, "This command has been temporarilly disabled by the Gods\n\r", ch ); return; } /* * Character not in position for command? */ if ( ch->position < cmd_table[cmd].position ) { switch( ch->position ) { case POS_DEAD: send_to_char(AT_RED, "Lie still; you are DEAD.\n\r", ch ); break; case POS_MORTAL: case POS_INCAP: send_to_char(AT_RED, "You are hurt far too bad for that.\n\r", ch ); break; case POS_STUNNED: send_to_char(AT_WHITE, "You are too stunned to do that.\n\r", ch ); break; case POS_SLEEPING: send_to_char(AT_BLUE, "In your dreams, or what?\n\r", ch ); break; case POS_RESTING: send_to_char(AT_BLUE, "Nah... You feel too relaxed...\n\r", ch ); break; case POS_GHOST: send_to_char(AT_LBLUE, "You are a ghost, and can't do that!\n\r", ch ); break; case POS_FIGHTING: send_to_char(AT_BLOOD, "No way! You are still fighting!\n\r", ch ); break; } return; } if ( IS_NPC(ch) ) /* PC's are logged in comm.c */ { /* char combuf [MAX_STRING_LENGTH]; extern int port; sprintf(combuf, "%s: [%d] %s %s\n\r", ctime( ¤t_time), ch->pIndexData->vnum, command, argument); append_file( ch, filname, combuf ); */ } /* * Dispatch the command. */ /* if ( IS_NPC( ch ) && !can_mob_use( ch, argument ) ) return; */ (*cmd_table[cmd].do_fun) ( ch, argument ); tail_chain( ); return; } bool check_alias( CHAR_DATA *ch, char *command, char *argument ) { ALIAS_DATA *al; char arg[MAX_STRING_LENGTH]; char newarg[MAX_STRING_LENGTH]; bool found; arg[0] = '\0'; newarg[0] = '\0'; while ( isspace(*argument) ) argument++; strcpy( arg, argument ); if ( IS_NPC( ch ) ) return FALSE; if ( !(ch->pcdata->alias_list) ) return FALSE; found = FALSE; for ( al = ch->pcdata->alias_list; al; al = al->next ) { if ( !str_cmp( al->old, command ) ) { strcpy( newarg, al->_new ); strcat( newarg, " " ); strcat( newarg, arg ); interpret( ch, newarg ); found = TRUE; break; } } return found; } bool check_social( CHAR_DATA *ch, char *command, char *argument ) { CHAR_DATA *victim; char arg [ MAX_INPUT_LENGTH ]; int cmd; bool found; found = FALSE; for ( cmd = 0; social_table[cmd].name[0] != '\0'; cmd++ ) { if ( command[0] == social_table[cmd].name[0] && !str_prefix( command, social_table[cmd].name ) ) { found = TRUE; break; } } if ( !found ) return FALSE; if ( !IS_NPC( ch ) && IS_SET( ch->act, PLR_NO_EMOTE ) ) { send_to_char(AT_LBLUE, "You are anti-social!\n\r", ch ); return TRUE; } switch ( ch->position ) { case POS_DEAD: send_to_char(AT_RED, "Lie still; you are DEAD.\n\r", ch ); return TRUE; case POS_INCAP: case POS_MORTAL: send_to_char(AT_RED, "You are hurt far too badly for that.\n\r", ch ); return TRUE; case POS_STUNNED: send_to_char(AT_WHITE, "You are too stunned to do that.\n\r", ch ); return TRUE; case POS_SLEEPING: /* * I just know this is the path to a 12" 'if' statement. :( * But two players asked for it already! -- Furey */ if ( !str_cmp( social_table[cmd].name, "snore" ) ) break; send_to_char(AT_BLUE, "In your dreams, or what?\n\r", ch ); return TRUE; } one_argument( argument, arg ); victim = NULL; if ( arg[0] == '\0' ) { act(AT_PINK, social_table[cmd].char_no_arg, ch, NULL, victim, TO_CHAR ); act(AT_PINK, social_table[cmd].others_no_arg, ch, NULL, victim, TO_ROOM ); } else if ( !( victim = get_char_world( ch, arg ) ) ) { send_to_char(AT_WHITE, "They aren't here.\n\r", ch ); } else if ( victim == ch ) { act(AT_PINK, social_table[cmd].char_auto, ch, NULL, victim, TO_CHAR ); act(AT_PINK, social_table[cmd].others_auto, ch, NULL, victim, TO_ROOM ); } else if ( !get_char_room( ch, arg ) && can_see( ch, victim ) ) { if ( !IS_NPC( victim ) ) { ROOM_INDEX_DATA *original; char *ldbase = "From far away, "; char ldmsg [ MAX_STRING_LENGTH ]; original = ch->in_room; char_from_room( ch ); char_to_room( ch, victim->in_room ); strcpy( ldmsg, ldbase ); strcat( ldmsg, social_table[cmd].char_found ); act(AT_PINK, ldmsg, ch, NULL, victim, TO_CHAR ); strcpy( ldmsg, ldbase ); strcat( ldmsg, social_table[cmd].vict_found ); act(AT_PINK, ldmsg, ch, NULL, victim, TO_VICT ); char_from_room( ch ); char_to_room( ch, original ); } else { send_to_char(AT_WHITE, "They aren't here.\n\r", ch ); } } else { act(AT_PINK, social_table[cmd].char_found, ch, NULL, victim, TO_CHAR ); act(AT_PINK, social_table[cmd].vict_found, ch, NULL, victim, TO_VICT ); act(AT_PINK, social_table[cmd].others_found, ch, NULL, victim, TO_NOTVICT ); if ( !IS_NPC( ch ) && IS_NPC( victim ) && !IS_AFFECTED( victim, AFF_CHARM ) && IS_AWAKE( victim ) && ( !victim->pIndexData->mobprogs ) ) { switch ( number_bits( 4 ) ) { case 0: if ( ( victim->level < ch->level ) && !( victim->fighting ) ) multi_hit( victim, ch, TYPE_UNDEFINED ); break; case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: act(AT_PINK, social_table[cmd].char_found, victim, NULL, ch, TO_CHAR ); act(AT_PINK, social_table[cmd].vict_found, victim, NULL, ch, TO_VICT ); act(AT_PINK, social_table[cmd].others_found, victim, NULL, ch, TO_NOTVICT ); break; case 9: case 10: case 11: case 12: act(AT_PINK, "You slap $N.", victim, NULL, ch, TO_CHAR ); act(AT_PINK, "$n slaps you.", victim, NULL, ch, TO_VICT ); act(AT_PINK, "$n slaps $N.", victim, NULL, ch, TO_NOTVICT ); break; } } } return TRUE; } /* * Return true if an argument is completely numeric. */ bool is_number( char *arg ) { if ( *arg == '\0' ) return FALSE; if ( *arg == '+' || *arg == '-' ) arg++; for ( ; *arg != '\0'; arg++ ) { if ( !isdigit( *arg ) ) return FALSE; } return TRUE; } /* * Given a string like 14.foo, return 14 and 'foo' */ int number_argument( char *argument, char *arg ) { char *pdot; int number; if (!str_cmp(argument, str_empty)) { strcpy(arg, ""); return 1; } for ( pdot = argument; *pdot != '\0'; pdot++ ) { if ( *pdot == '.' ) { *pdot = '\0'; number = atoi( argument ); *pdot = '.'; strcpy( arg, pdot+1 ); return number; } } strcpy( arg, argument ); return 1; } /* * Pick off one argument from a string and return the rest. * Understands quotes. */ char *one_argument( char *argument, char *arg_first ) { char cEnd; while ( isspace( *argument ) ) argument++; cEnd = ' '; if ( *argument == '\'' || *argument == '"' ) cEnd = *argument++; while ( *argument != '\0' ) { if ( *argument == cEnd ) { argument++; break; } *arg_first = LOWER( *argument ); arg_first++; argument++; } *arg_first = '\0'; while ( isspace( *argument ) ) argument++; return argument; } /* * Disable by: Erwin S. Andreasen (4u2@aabc.dk) * Disable upto level & disable all added by: Canth (canth@xs4all.nl) */ void do_disable (CHAR_DATA *ch, char *argument) { int i; DISABLED_DATA *p,*q; char buf[100]; char arg1 [ MAX_INPUT_LENGTH ]; char arg2 [ MAX_INPUT_LENGTH ]; if ( !authorized( ch, "disable" ) ) return; if (IS_NPC(ch)) { send_to_char (AT_WHITE, "RETURN first.\n\r",ch); return; } if (!argument[0]) /* Nothing specified. Show disabled commands. */ { if (!disabled_first) /* Any disabled at all ? */ { send_to_char (AT_WHITE, "There are no commands disabled.\n\r",ch); return; } send_to_char (AT_WHITE, "Disabled commands:\n\r" "Command To Level By Level Disabled by\n\r",ch); for (p = disabled_first; p; p = p->next) { sprintf (buf, "%-12s %5d %5d %-12s\n\r",p->command->name, p->uptolevel, p->dislevel, p->disabled_by); send_to_char (AT_WHITE, buf,ch); } return; } /* command given */ argument = one_argument( argument, arg1 ); one_argument( argument, arg2 ); /* First check if it is one of the disabled commands */ for (p = disabled_first; p ; p = p->next) if (!str_cmp(arg1, p->command->name)) break; if (p) /* this command is disabled */ { /* Optional: The level of the imm to enable the command must equal or exceed level of the one that disabled it */ if (get_trust(ch) < p->dislevel) { send_to_char (AT_WHITE, "This command was disabledby a higher power.\n\r",ch); return; } /* Remove */ if (disabled_first == p) /* node to be removed == head ? */ disabled_first = p->next; else /* Find the node before this one */ { for (q = disabled_first; q->next != p; q = q->next); /* empty for */ q->next = p->next; } free_disabled(p); save_disabled(); /* save to disk */ send_to_char (AT_WHITE, "Command enabled.\n\r",ch); } /* * Disable all to re-enable all disabled commands by Canth (canth@xs4all.nl) */ else if ( !str_cmp( arg1, "all" ) ) /* re-enable all commands */ { p = disabled_first; while( p ) { disabled_first = p->next; free_disabled(p); p = disabled_first; } save_disabled(); send_to_char(AT_WHITE, "All commands re-enabled", ch ); } else /* not a disabled command, check if that command exists */ { /* IQ test */ if (!str_cmp(arg1,"disable")) { send_to_char (AT_WHITE, "You cannot disable the disable command.\n\r",ch); return; } /* Search for the command */ for (i = 0; cmd_table[i].name[0] != '\0'; i++) if (!str_cmp(cmd_table[i].name, arg1)) break; /* Found? */ if (cmd_table[i].name[0] == '\0') { send_to_char (AT_WHITE, "No such command.\n\r",ch); return; } /* Can the imm use this command at all ? */ if (cmd_table[i].level > get_trust(ch)) { send_to_char (AT_WHITE, "You dot have access to that command; you cannot disable it.\n\r",ch); return; } /* Disable the command */ p = alloc_mem (sizeof(DISABLED_DATA)); p->command = &cmd_table[i]; p->disabled_by = str_dup (ch->name); /* save name of disabler */ p->dislevel = get_trust(ch); /* save trust */ if ( is_number( arg2 ) ) /* unusable upto & including level arg2 */ p->uptolevel = atoi( arg2 ); /* (no check for out of range) */ else p->uptolevel = get_trust( ch ); p->next = disabled_first; disabled_first = p; /* add before the current first element */ send_to_char (AT_WHITE, "Command disabled.\n\r",ch); save_disabled(); /* save to disk */ } } /* Check if that command is disabled Note that we check for equivalence of the do_fun pointers; this means that disabling 'chat' will also disable the '.' command */ bool check_disabled ( CHAR_DATA *ch, const struct cmd_type *command ) { DISABLED_DATA *p; for (p = disabled_first; p ; p = p->next) if (p->command->do_fun == command->do_fun && ch->level <= p->uptolevel) return TRUE; return FALSE; } /* Load disabled commands */ void load_disabled() { FILE *fp; DISABLED_DATA *p; char *name; int i; disabled_first = NULL; fp = fopen (DISABLED_FILE, "r"); if (!fp) /* No disabled file.. no disabled commands : */ return; name = fread_word (fp); while (str_cmp(name, END_MARKER)) /* as long as name is NOT END_MARKER :) */ { /* Find the command in the table */ for (i = 0; cmd_table[i].name[0] ; i++) if (!str_cmp(cmd_table[i].name, name)) break; if (!cmd_table[i].name[0]) /* command does not exist? */ { bug ("Skipping uknown command in " DISABLED_FILE " file.",0); fread_number(fp); /* uptolevel */ fread_number(fp); /* dislevel */ fread_word(fp); /* disabled_by */ } else /* add new disabled command */ { p = alloc_mem(sizeof(DISABLED_DATA)); p->command = &cmd_table[i]; p->uptolevel = fread_number(fp); p->dislevel = fread_number(fp); p->disabled_by = str_dup(fread_word(fp)); p->next = disabled_first; disabled_first = p; } name = fread_word(fp); } fclose (fp); } /* Save disabled commands */ void save_disabled() { #ifdef sql_system sql_save_disabled(); #else FILE *fp; DISABLED_DATA *p; if (!disabled_first) /* delete file if no commands are disabled */ { unlink (DISABLED_FILE); return; } fp = fopen (DISABLED_FILE, "w"); if (!fp) { bug ("Could not open " DISABLED_FILE " for writing",0); return; } for (p = disabled_first; p ; p = p->next) fprintf (fp, "%s %d %d %s\n", p->command->name, p->uptolevel, p->dislevel, p->disabled_by); fprintf (fp, "%s\n",END_MARKER); fclose (fp); #endif } void cleanup_disabled() { DISABLED_DATA* dptr = disabled_first; while(dptr) { disabled_first = dptr->next; free(dptr); dptr = disabled_first; } } void do_alias( CHAR_DATA *ch, char *argument ) { char arg[MAX_STRING_LENGTH]; char arg1[MAX_STRING_LENGTH]; ALIAS_DATA *al; ALIAS_DATA *oAl; if( IS_NPC( ch ) ) return; smash_tilde( argument ); argument = one_argument( argument, arg ); strcpy( arg1, argument ); if ( arg[0] == '\0' ) { if ( !ch->pcdata->alias_list ) { send_to_char( AT_WHITE, "You have no alias' set.\n\r", ch ); return; } send_to_char( AT_WHITE, "Your currently set alias' are:\n\r", ch ); for ( al = ch->pcdata->alias_list; al; al = al->next ) { sprintf( log_buf, " %-10s &B%s&w\n\r", al->old, al->_new ); send_to_char( AT_RED, log_buf, ch ); } send_to_char( AT_WHITE, "\n\r", ch ); return; } if ( arg1[0] == '\0' && ( !( ch->pcdata->alias_list ) ) ) { send_to_char( AT_WHITE, "You have no command alias' to remove!\n\r", ch ); return; } if ( arg1[0] != '\0' ) { for ( oAl = ch->pcdata->alias_list; oAl; oAl = oAl->next ) { if ( is_name( arg1, oAl->old ) || !str_prefix( arg, arg1 ) ) { send_to_char( AT_WHITE, "You cannot alias other alias' into your [new] string.\n\r", ch ); return; } } } for ( al = ch->pcdata->alias_list; al; al = al->next ) if ( !str_cmp( al->old, arg ) ) break; if ( arg1[0] == '\0' ) { if ( !al ) { send_to_char( C_DEFAULT, "Alias does not exist.\n\r", ch ); return; } if ( al == ch->pcdata->alias_list ) ch->pcdata->alias_list = al->next; else { for ( oAl = ch->pcdata->alias_list; oAl; oAl = oAl->next ) if ( oAl->next == al ) break; if ( !oAl ) { sprintf( log_buf, "Do_alias: bad alias - ch (%s) - [%s]", ch->name, arg ); bug( log_buf, 0 ); send_to_char(C_DEFAULT, "Alias does not exist.\n\r", ch ); return; } oAl->next = al->next; } free_alias( al); act( AT_WHITE, "Alias '$t' cleared.\n\r", ch, arg, NULL, TO_CHAR ); return; } if ( al ) { free_string( al->_new ); al->_new = str_dup( arg1 ); sprintf( log_buf, "Alias '%s' remade.\n\r", arg ); send_to_char( AT_WHITE, log_buf, ch ); return; } add_alias( ch, al, arg, arg1 ); sprintf( log_buf, "Alias '%s' added.\n\r", arg ); send_to_char( AT_WHITE, log_buf, ch ); return; } void add_alias( CHAR_DATA *ch, ALIAS_DATA *pAl, char *old, char *_new ) { pAl = new_alias(); pAl->old = str_dup( old ); pAl->_new = str_dup( _new ); pAl->next = ch->pcdata->alias_list; ch->pcdata->alias_list = pAl; return; } void do_countcommands( CHAR_DATA *ch, char *argument ) { char buf[MAX_STRING_LENGTH]; int scnt; for ( scnt = 0; skill_table[scnt].name[0] != '\0'; scnt++ ); sprintf(buf, "Command table size: %d\n\r" "Social table size: %d\n\r" "GSkill table size: %d\n\r" "Skill table size: %d\n\r", /* -1 from each for blank index entry at end. */ sizeof( cmd_table) / sizeof( cmd_table[0]) - 1, sizeof(social_table) / sizeof(social_table[0]) - 1, sizeof(gskill_table) / sizeof(gskill_table[0]) , scnt); /* Someone wanna explain why theres an error with sizeof(skill_table)?? */ send_to_char(AT_PINK, buf, ch ); return; } bool can_mob_use( CHAR_DATA *ch, char *argument) { if( IS_NPC( ch ) && IS_AFFECTED( ch, AFF_CHARM ) && ( !str_prefix( argument, "stun") || !str_prefix( argument, "slam" ) || !str_prefix( argument, "slit" ) || !str_prefix( argument, "steal" ) || !str_prefix( argument, "backstab") || !str_prefix( argument, "bs") || !str_prefix( argument, "snare") || !str_prefix( argument, "untangle") || !str_prefix( argument, "poison") || !str_prefix( argument, "depoison") || !str_prefix( argument, "double") || !str_prefix( argument, "dbs") || !str_prefix( argument, "assassinate") || !str_prefix( argument, "dim") || !str_prefix( argument, "patch") || !str_prefix( argument, "berserk") || !str_prefix( argument, "bloodthirsty") || !str_prefix( argument, "weaponmaster") || !str_prefix( argument, "break") || !str_prefix( argument, "thick") || !str_prefix( argument, "backkick") || !str_prefix( argument, "bk") || !str_prefix( argument, "claw") || !str_prefix( argument, "gouge") || !str_prefix( argument, "paralyse") || !str_prefix( argument, "quickness") ) ) { return FALSE; } return TRUE; }