/*************************************************************************** * 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. * * * * EnvyMud 2.0 improvements copyright (C) 1995 by Michael Quan and * * Mitchell Tse. * * * * EnvyMud 2.2 improvements copyright (C) 1996, 1997 by Michael Quan. * * * * GreedMud 0.88 improvements copyright (C) 1997, 1998 by Vasco Costa. * * * * 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. * * * * This code was written by Jason Dinkel and inspired by Russ Taylor, * * and has been used here for OLC - OLC would not be what it is without * * all the previous coders who released their source code. * ***************************************************************************/ #if defined( macintosh ) #include <types.h> #else #include <sys/types.h> #endif #include <stdio.h> #include <string.h> #include <time.h> #include "merc.h" /* * The code below uses a table lookup system that is based on suggestions * from Russ Taylor. There are many routines in handler.c that would benefit * with the use of tables. You may consider simplifying your code base by * implementing a system like below with such functions - Jason Dinkel */ struct flag_stat_type { const struct flag_type *structure; bool stat; bool vect; }; const struct flag_stat_type flag_stat_table [ ] = { /* structure stat vector */ { connected_flags, TRUE, FALSE }, { area_flags, FALSE, FALSE }, { sex_flags, TRUE, FALSE }, { size_flags, TRUE, FALSE }, { exit_flags, FALSE, FALSE }, { door_resets, TRUE, FALSE }, { room_flags, FALSE, FALSE }, { sector_flags, TRUE, FALSE }, { type_flags, TRUE, FALSE }, { extra_flags, FALSE, FALSE }, { wear_flags, FALSE, FALSE }, { act_flags, FALSE, FALSE }, { plr_flags, FALSE, FALSE }, { affect_flags, FALSE, TRUE }, { apply_flags, TRUE, FALSE }, { wear_loc_flags, TRUE, FALSE }, { wear_loc_strings, TRUE, FALSE }, { weapon_flags, TRUE, FALSE }, { container_flags, FALSE, FALSE }, { liquid_flags, TRUE, FALSE }, { mprog_type_flags, TRUE, FALSE }, { portal_door_flags, FALSE, FALSE }, { portal_flags, FALSE, FALSE }, { mana_flags, FALSE, FALSE }, { rank_flags, TRUE, FALSE }, { clan_flags, TRUE, FALSE }, { 0, 0, 0 } }; bool is_stat( const struct flag_type *flag_table ) { int flag; for ( flag = 0; flag_stat_table[flag].structure; flag++ ) { if ( flag_stat_table[flag].structure == flag_table && flag_stat_table[flag].stat ) return TRUE; } return FALSE; } bool is_vect( const struct flag_type *flag_table ) { int flag; for ( flag = 0; flag_stat_table[flag].structure; flag++ ) { if ( flag_stat_table[flag].structure == flag_table && flag_stat_table[flag].vect ) return TRUE; } return FALSE; } /* * This function is Russ Taylor's creation. Thanks Russ! * all code copyright (C) Russ Taylor, permission to use and/or distribute * has NOT been granted. Use only in this OLC package has been granted. */ int flag_lookup( const char *name, const struct flag_type *flag_table ) { int flag; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( !str_cmp( name, flag_table[flag].name ) && flag_table[flag].settable ) return flag_table[flag].bit; } return NO_FLAG; } int flag_slookup( const char *name, const struct flag_type *flag_table ) { int flag; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( !str_cmp( name, flag_table[flag].name ) ) return flag_table[flag].bit; } return NO_FLAG; } int flag_value( const struct flag_type *flag_table, char *argument ) { char word [ MAX_INPUT_LENGTH ]; int bit; int marked = 0; bool found = FALSE; if ( is_stat( flag_table ) ) { one_argument( argument, word ); bit = flag_slookup( word, flag_table ); return bit; } for ( ; ; ) { argument = one_argument( argument, word ); if ( word[0] == '\0' ) break; if ( ( bit = flag_lookup( word, flag_table ) ) != NO_FLAG ) { SET_BIT( marked, bit ); found = TRUE; } } if ( found ) return marked; else return NO_FLAG; } int fread_flag( FILE *fp, const struct flag_type *flag_table ) { char word [ MAX_INPUT_LENGTH ]; char buf [ MAX_STRING_LENGTH ]; char *argument; int bit; int marked = 0; bool found = FALSE; temp_fread_string( fp, buf ); argument = &buf[0]; if ( is_stat( flag_table ) ) { one_argument( argument, word ); bit = flag_slookup( word, flag_table ); return bit; } for ( ; ; ) { argument = one_argument( argument, word ); if ( word[0] == '\0' ) break; if ( ( bit = flag_slookup( word, flag_table ) ) != NO_FLAG ) { SET_BIT( marked, bit ); found = TRUE; } } return marked; } char *flag_string( const struct flag_type *flag_table, int bits ) { static char buf [ MAX_STRING_LENGTH ]; int flag; buf[0] = '\0'; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( !is_stat( flag_table ) && IS_SET( bits, flag_table[flag].bit ) ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); } else if ( flag_table[flag].bit == bits ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); break; } } return ( buf[0] != '\0' ) ? buf+1 : "none"; } char *flag_strings( const struct flag_type *flag_table, int bits ) { static char buf [ MAX_STRING_LENGTH ]; int flag; buf[0] = '\0'; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( !flag_table[flag].settable ) continue; if ( !is_stat( flag_table ) && IS_SET( bits, flag_table[flag].bit ) ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); } else if ( flag_table[flag].bit == bits ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); break; } } return ( buf[0] != '\0' ) ? buf+1 : ""; } u_intc *fread_vect( FILE *fp, const struct flag_type *flag_table, int *status ) { char word [ MAX_INPUT_LENGTH ]; char buf [ MAX_STRING_LENGTH ]; char *argument; int bit; static u_intc vector [ MAX_VECTOR ]; bool found; *status = 0; vzero( vector ); temp_fread_string( fp, buf ); argument = &buf[0]; if ( !is_vect( flag_table ) ) { *status = 1; return vector; } found = FALSE; for ( ; ; ) { argument = one_argument( argument, word ); if ( word[0] == '\0' ) break; if ( ( bit = flag_slookup( word, flag_table ) ) != NO_FLAG && bit >= 0 && bit < MAX_VECTOR*CHAR_BIT ) { set_bit( vector, bit ); found = TRUE; } } if ( !found ) *status = 2; return vector; } char *vect_string( const struct flag_type *flag_table, const u_intc *vector ) { static char buf [ MAX_STRING_LENGTH ]; int flag; buf[0] = '\0'; if ( !is_vect( flag_table ) ) return ""; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( flag_table[flag].bit < 0 || flag_table[flag].bit >= MAX_VECTOR*CHAR_BIT ) continue; if ( !is_stat( flag_table ) && is_set( vector, flag_table[flag].bit ) ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); } } return ( buf[0] != '\0' ) ? buf+1 : "none"; } char *vect_strings( const struct flag_type *flag_table, const u_intc *vector ) { static char buf [ MAX_STRING_LENGTH ]; int flag; buf[0] = '\0'; if ( !is_vect( flag_table ) ) return ""; for ( flag = 0; *flag_table[flag].name; flag++ ) { if ( !flag_table[flag].settable ) continue; if ( flag_table[flag].bit < 0 || flag_table[flag].bit >= MAX_VECTOR*CHAR_BIT ) continue; if ( !is_stat( flag_table ) && is_set( vector, flag_table[flag].bit ) ) { strcat( buf, " " ); strcat( buf, flag_table[flag].name ); } } return ( buf[0] != '\0' ) ? buf+1 : ""; } const struct flag_type connected_flags [ ] = { { "PLAYING", CON_PLAYING, FALSE }, { "GET_NAME", CON_GET_NAME, FALSE }, { "GET_OLD_PASSWORD", CON_GET_OLD_PASSWORD, FALSE }, { "CONFIRM_NEW_NAME", CON_CONFIRM_NEW_NAME, FALSE }, { "GET_NEW_PASSWORD", CON_GET_NEW_PASSWORD, FALSE }, { "CONFIRM_NEW_PASSWORD", CON_CONFIRM_NEW_PASSWORD, FALSE }, { "GET_COLOUR", CON_GET_COLOUR, FALSE }, { "DISPLAY_RACE", CON_DISPLAY_RACE, FALSE }, { "GET_NEW_RACE", CON_GET_NEW_RACE, FALSE }, { "CONFIRM_NEW_RACE", CON_CONFIRM_NEW_RACE, FALSE }, { "GET_NEW_SEX", CON_GET_NEW_SEX, FALSE }, { "DISPLAY_1ST_CLASS", CON_DISPLAY_1ST_CLASS, FALSE }, { "GET_1ST_CLASS", CON_GET_1ST_CLASS, FALSE }, { "CONFIRM_1ST_CLASS", CON_CONFIRM_1ST_CLASS, FALSE }, { "DEFAULT_CHOICE", CON_DEFAULT_CHOICE, FALSE }, { "DISPLAY_2ND_CLASS", CON_DISPLAY_2ND_CLASS, FALSE }, { "GET_2ND_CLASS", CON_GET_2ND_CLASS, FALSE }, { "CONFIRM_2ND_CLASS", CON_CONFIRM_2ND_CLASS, FALSE }, { "SHOW_MOTD", CON_SHOW_MOTD, FALSE }, { "READ_MOTD", CON_READ_MOTD, FALSE }, { "PASSWD_GET_OLD", CON_PASSWD_GET_OLD, FALSE }, { "PASSWD_GET_NEW", CON_PASSWD_GET_NEW, FALSE }, { "PASSWD_CONFIRM_NEW", CON_PASSWD_CONFIRM_NEW, FALSE }, { "RETIRE_GET_PASSWORD", CON_RETIRE_GET_PASSWORD, FALSE }, { "RETIRE_CONFIRM", CON_RETIRE_CONFIRM, FALSE }, { "AEDITOR", CON_AEDITOR, FALSE }, { "REDITOR", CON_REDITOR, FALSE }, { "MEDITOR", CON_MEDITOR, FALSE }, { "OEDITOR", CON_OEDITOR, FALSE }, { "MPEDITOR", CON_MPEDITOR, FALSE }, { "", 0, 0 } }; const struct flag_type area_flags [ ] = { { "none", AREA_NONE, FALSE }, { "changed", AREA_CHANGED, FALSE }, { "added", AREA_ADDED, FALSE }, { "loading", AREA_LOADING, FALSE }, { "verbose", AREA_VERBOSE, FALSE }, { "", 0, 0 } }; const struct flag_type sex_flags [ ] = { { "male", SEX_MALE, TRUE }, { "female", SEX_FEMALE, TRUE }, { "neutral", SEX_NEUTRAL, TRUE }, { "", 0, 0 } }; const struct flag_type size_flags [ ] = { { "any", SIZE_ANY, TRUE }, { "male", SIZE_MINUTE, TRUE }, { "minute", SIZE_MINUTE, TRUE }, { "small", SIZE_SMALL, TRUE }, { "petite", SIZE_PETITE, TRUE }, { "average", SIZE_AVERAGE, TRUE }, { "medium", SIZE_MEDIUM, TRUE }, { "large", SIZE_LARGE, TRUE }, { "huge", SIZE_HUGE, TRUE }, { "titanic", SIZE_TITANIC, TRUE }, { "gargantuan", SIZE_GARGANTUAN,TRUE }, { "", 0, 0 } }; const struct flag_type exit_flags [ ] = { { "door", EX_ISDOOR, TRUE }, { "closed", EX_CLOSED, TRUE }, { "locked", EX_LOCKED, TRUE }, { "bashed", EX_BASHED, FALSE }, { "bashproof", EX_BASHPROOF, TRUE }, { "pickproof", EX_PICKPROOF, TRUE }, { "passproof", EX_PASSPROOF, TRUE }, { "eat_key", EX_EAT_KEY, TRUE }, { "", 0, 0 } }; const struct flag_type door_resets [ ] = { { "open and unlocked", 0, TRUE }, { "closed and unlocked", 1, TRUE }, { "closed and locked", 2, TRUE }, { "", 0, 0 } }; const struct flag_type room_flags [ ] = { { "dark", ROOM_DARK, TRUE }, { "no_mob", ROOM_NO_MOB, TRUE }, { "indoors", ROOM_INDOORS, TRUE }, { "private", ROOM_PRIVATE, TRUE }, { "safe", ROOM_SAFE, TRUE }, { "solitary", ROOM_SOLITARY, TRUE }, { "pet_shop", ROOM_PET_SHOP, TRUE }, { "no_recall", ROOM_NO_RECALL, TRUE }, { "cone_of_silence", ROOM_CONE_OF_SILENCE, TRUE }, { "arena", ROOM_ARENA, TRUE }, { "", 0, 0 } }; const struct flag_type sector_flags [ ] = { { "inside", SECT_INSIDE, TRUE }, { "city", SECT_CITY, TRUE }, { "field", SECT_FIELD, TRUE }, { "forest", SECT_FOREST, TRUE }, { "hills", SECT_HILLS, TRUE }, { "mountain", SECT_MOUNTAIN, TRUE }, { "water_swim", SECT_WATER_SWIM, TRUE }, { "water_noswim", SECT_WATER_NOSWIM, TRUE }, { "underwater", SECT_UNDERWATER, TRUE }, { "air", SECT_AIR, TRUE }, { "desert", SECT_DESERT, TRUE }, { "dunno", SECT_DUNNO, TRUE }, { "iceland", SECT_ICELAND, TRUE }, { "", 0, 0 } }; const struct flag_type type_flags [ ] = { { "light", ITEM_LIGHT, TRUE }, { "scroll", ITEM_SCROLL, TRUE }, { "wand", ITEM_WAND, TRUE }, { "staff", ITEM_STAFF, TRUE }, { "weapon", ITEM_WEAPON, TRUE }, { "treasure", ITEM_TREASURE, TRUE }, { "armor", ITEM_ARMOR, TRUE }, { "potion", ITEM_POTION, TRUE }, { "furniture", ITEM_FURNITURE, TRUE }, { "trash", ITEM_TRASH, TRUE }, { "container", ITEM_CONTAINER, TRUE }, { "drink_con", ITEM_DRINK_CON, TRUE }, { "key", ITEM_KEY, TRUE }, { "food", ITEM_FOOD, TRUE }, { "money", ITEM_MONEY, TRUE }, { "boat", ITEM_BOAT, TRUE }, { "corpse_npc", ITEM_CORPSE_NPC, TRUE }, { "corpse_pc", ITEM_CORPSE_PC, TRUE }, { "fountain", ITEM_FOUNTAIN, TRUE }, { "pill", ITEM_PILL, TRUE }, { "portal", ITEM_PORTAL, TRUE }, { "warp_stone", ITEM_WARP_STONE, TRUE }, { "clothing", ITEM_CLOTHING, TRUE }, { "ranged_weapon", ITEM_RANGED_WEAPON, TRUE }, { "ammo", ITEM_AMMO, TRUE }, { "gem", ITEM_GEM, TRUE }, { "", 0, 0 } }; const struct flag_type extra_flags [ ] = { { "glow", ITEM_GLOW, TRUE }, { "hum", ITEM_HUM, TRUE }, { "dark", ITEM_DARK, TRUE }, { "lock", ITEM_LOCK, TRUE }, { "evil", ITEM_EVIL, TRUE }, { "invis", ITEM_INVIS, TRUE }, { "magic", ITEM_MAGIC, TRUE }, { "nodrop", ITEM_NODROP, TRUE }, { "bless", ITEM_BLESS, TRUE }, { "anti-good", ITEM_ANTI_GOOD, TRUE }, { "anti-evil", ITEM_ANTI_EVIL, TRUE }, { "anti-neutral", ITEM_ANTI_NEUTRAL, TRUE }, { "noremove", ITEM_NOREMOVE, TRUE }, { "inventory", ITEM_INVENTORY, TRUE }, { "poisoned", ITEM_POISONED, TRUE }, { "vampire-bane", ITEM_VAMPIRE_BANE, TRUE }, { "holy", ITEM_HOLY, TRUE }, { "visible_death", ITEM_VIS_DEATH, TRUE }, { "", 0, 0 } }; const struct flag_type wear_flags [ ] = { { "take", ITEM_TAKE, TRUE }, { "finger", ITEM_WEAR_FINGER, TRUE }, { "neck", ITEM_WEAR_NECK, TRUE }, { "body", ITEM_WEAR_BODY, TRUE }, { "head", ITEM_WEAR_HEAD, TRUE }, { "legs", ITEM_WEAR_LEGS, TRUE }, { "feet", ITEM_WEAR_FEET, TRUE }, { "hands", ITEM_WEAR_HANDS, TRUE }, { "arms", ITEM_WEAR_ARMS, TRUE }, { "shield", ITEM_WEAR_SHIELD, TRUE }, { "about", ITEM_WEAR_ABOUT, TRUE }, { "waist", ITEM_WEAR_WAIST, TRUE }, { "wrist", ITEM_WEAR_WRIST, TRUE }, { "wield", ITEM_WIELD, TRUE }, { "hold", ITEM_HOLD, TRUE }, { "missile", ITEM_MISSILE_WIELD, TRUE }, { "", 0, 0 } }; const struct flag_type act_flags [ ] = { { "npc", ACT_IS_NPC, FALSE }, { "sentinel", ACT_SENTINEL, TRUE }, { "scavenger", ACT_SCAVENGER, TRUE }, { "aggressive", ACT_AGGRESSIVE, TRUE }, { "stay_area", ACT_STAY_AREA, TRUE }, { "wimpy", ACT_WIMPY, TRUE }, { "pet", ACT_PET, TRUE }, { "train", ACT_TRAIN, TRUE }, { "practice", ACT_PRACTICE, TRUE }, { "mobinvis", ACT_MOBINVIS, TRUE }, { "mountable", ACT_MOUNTABLE, TRUE }, { "", 0, 0 } }; const struct flag_type plr_flags [ ] = { { "npc", PLR_IS_NPC, FALSE }, { "bought_pet", PLR_BOUGHT_PET, TRUE }, { "register", PLR_REGISTER, TRUE }, { "autoexit", PLR_AUTOEXIT, TRUE }, { "autoloot", PLR_AUTOLOOT, TRUE }, { "autosac", PLR_AUTOSAC, TRUE }, { "blank", PLR_BLANK, TRUE }, { "brief", PLR_BRIEF, TRUE }, { "combine", PLR_COMBINE, TRUE }, { "prompt", PLR_PROMPT, TRUE }, { "telnet_ga", PLR_TELNET_GA, TRUE }, { "holylight", PLR_HOLYLIGHT, TRUE }, { "wizinvis", PLR_WIZINVIS, TRUE }, { "wizbit", PLR_WIZBIT, TRUE }, { "silence", PLR_SILENCE, TRUE }, { "no_emote", PLR_NO_EMOTE, TRUE }, { "moved", PLR_MOVED, TRUE }, { "no_tell", PLR_NO_TELL, TRUE }, { "log", PLR_LOG, TRUE }, { "deny", PLR_DENY, TRUE }, { "freeze", PLR_FREEZE, TRUE }, { "thief", PLR_THIEF, TRUE }, { "killer", PLR_KILLER, TRUE }, { "autogold", PLR_AUTOGOLD, TRUE }, { "afk", PLR_AFK, TRUE }, { "colour", PLR_COLOUR, TRUE }, { "edit_info", PLR_EDIT_INFO, TRUE }, { "pager", PLR_PAGER, TRUE }, { "", 0, 0 } }; const struct flag_type affect_flags [ ] = { { "none", -1, FALSE }, { "blind", AFF_BLIND, TRUE }, { "invisible", AFF_INVISIBLE, TRUE }, { "detect-evil", AFF_DETECT_EVIL, TRUE }, { "detect-invis", AFF_DETECT_INVIS, TRUE }, { "detect-magic", AFF_DETECT_MAGIC, TRUE }, { "detect-hidden", AFF_DETECT_HIDDEN, TRUE }, { "hold", AFF_HOLD, TRUE }, { "sanctuary", AFF_SANCTUARY, TRUE }, { "faerie-fire", AFF_FAERIE_FIRE, TRUE }, { "infrared", AFF_INFRARED, TRUE }, { "curse", AFF_CURSE, TRUE }, { "poison", AFF_POISON, TRUE }, { "protect-evil", AFF_PROTECT_EVIL, TRUE }, { "sneak", AFF_SNEAK, TRUE }, { "hide", AFF_HIDE, TRUE }, { "sleep", AFF_SLEEP, TRUE }, { "charm", AFF_CHARM, TRUE }, { "flying", AFF_FLYING, TRUE }, { "pass-door", AFF_PASS_DOOR, TRUE }, { "waterwalk", AFF_WATERWALK, TRUE }, { "summoned", AFF_SUMMONED, FALSE }, { "mute", AFF_MUTE, TRUE }, { "gills", AFF_GILLS, TRUE }, { "vamp-bite", AFF_VAMP_BITE, TRUE }, { "ghoul", AFF_GHOUL, FALSE }, { "flaming", AFF_FLAMING, TRUE }, { "detect-good", AFF_DETECT_GOOD, TRUE }, { "protect-good", AFF_PROTECT_GOOD, TRUE }, { "plague", AFF_PLAGUE, TRUE }, { "", 0, 0 } }; /* * Used when adding an affect to tell where it goes. * See addaffect and delaffect in act_olc.c */ const struct flag_type apply_flags [ ] = { { "none", APPLY_NONE, TRUE }, { "strength", APPLY_STR, TRUE }, { "dexterity", APPLY_DEX, TRUE }, { "intelligence", APPLY_INT, TRUE }, { "wisdom", APPLY_WIS, TRUE }, { "constitution", APPLY_CON, TRUE }, { "sex", APPLY_SEX, TRUE }, { "class", APPLY_CLASS, TRUE }, { "level", APPLY_LEVEL, TRUE }, { "age", APPLY_AGE, TRUE }, { "height", APPLY_HEIGHT, TRUE }, { "weight", APPLY_WEIGHT, TRUE }, { "mana", APPLY_MANA, TRUE }, { "hp", APPLY_HIT, TRUE }, { "move", APPLY_MOVE, TRUE }, { "gold", APPLY_GOLD, TRUE }, { "experience", APPLY_EXP, TRUE }, { "ac", APPLY_AC, TRUE }, { "hitroll", APPLY_HITROLL, TRUE }, { "damroll", APPLY_DAMROLL, TRUE }, { "saving-para", APPLY_SAVING_PARA, TRUE }, { "saving-rod", APPLY_SAVING_ROD, TRUE }, { "saving-petri", APPLY_SAVING_PETRI, TRUE }, { "saving-breath", APPLY_SAVING_BREATH, TRUE }, { "saving-spell", APPLY_SAVING_SPELL, TRUE }, { "race", APPLY_RACE, TRUE }, { "resistant", APPLY_RESISTANT, TRUE }, { "immune", APPLY_IMMUNE, TRUE }, { "susceptible", APPLY_SUSCEPTIBLE, TRUE }, { "", 0, 0 } }; /* * What is seen. */ const struct flag_type wear_loc_strings [ ] = { { "in the inventory", WEAR_NONE, TRUE }, { "as a light", WEAR_LIGHT, TRUE }, { "on the left finger", WEAR_FINGER_L, TRUE }, { "on the right finger", WEAR_FINGER_R, TRUE }, { "around the neck (1)", WEAR_NECK_1, TRUE }, { "around the neck (2)", WEAR_NECK_2, TRUE }, { "on the body", WEAR_BODY, TRUE }, { "over the head", WEAR_HEAD, TRUE }, { "on the legs", WEAR_LEGS, TRUE }, { "on the feet", WEAR_FEET, TRUE }, { "on the hands", WEAR_HANDS, TRUE }, { "on the arms", WEAR_ARMS, TRUE }, { "as a shield", WEAR_SHIELD, TRUE }, { "about the shoulders", WEAR_ABOUT, TRUE }, { "around the waist", WEAR_WAIST, TRUE }, { "on the left wrist", WEAR_WRIST_L, TRUE }, { "on the right wrist", WEAR_WRIST_R, TRUE }, { "primary wield", WEAR_WIELD, TRUE }, { "held in the hands", WEAR_HOLD, TRUE }, { "second wield", WEAR_WIELD_2, TRUE }, { "missile wield", WEAR_MISSILE_WIELD, TRUE }, { "", 0, 0 } }; /* * What is typed. * neck2 should not be settable for loaded mobiles. */ const struct flag_type wear_loc_flags [ ] = { { "none", WEAR_NONE, TRUE }, { "light", WEAR_LIGHT, TRUE }, { "lfinger", WEAR_FINGER_L, TRUE }, { "rfinger", WEAR_FINGER_R, TRUE }, { "neck1", WEAR_NECK_1, TRUE }, { "neck2", WEAR_NECK_2, TRUE }, { "body", WEAR_BODY, TRUE }, { "head", WEAR_HEAD, TRUE }, { "legs", WEAR_LEGS, TRUE }, { "feet", WEAR_FEET, TRUE }, { "hands", WEAR_HANDS, TRUE }, { "arms", WEAR_ARMS, TRUE }, { "shield", WEAR_SHIELD, TRUE }, { "about", WEAR_ABOUT, TRUE }, { "waist", WEAR_WAIST, TRUE }, { "lwrist", WEAR_WRIST_L, TRUE }, { "rwrist", WEAR_WRIST_R, TRUE }, { "wielded", WEAR_WIELD, TRUE }, { "hold", WEAR_HOLD, TRUE }, { "sec_wield", WEAR_WIELD_2, TRUE }, { "mis_wield", WEAR_MISSILE_WIELD, TRUE }, { "", 0, 0 } }; const struct flag_type weapon_flags [ ] = { { "hit", 0, TRUE }, { "slice", 1, TRUE }, { "stab", 2, TRUE }, { "slash", 3, TRUE }, { "whip", 4, TRUE }, { "claw", 5, TRUE }, { "blast", 6, TRUE }, { "pound", 7, TRUE }, { "crush", 8, TRUE }, { "grep", 9, TRUE }, { "bite", 10, TRUE }, { "pierce", 11, TRUE }, { "suction", 12, TRUE }, { "chop", 13, TRUE }, { "vorpal", 14, TRUE }, { "cleave", 15, TRUE }, { "wail", 16, TRUE }, { "", 0, 0 } }; const struct flag_type container_flags [ ] = { { "closeable", 1, TRUE }, { "pickproof", 2, TRUE }, { "closed", 4, TRUE }, { "locked", 8, TRUE }, { "", 0, 0 } }; const struct flag_type portal_door_flags [ ] = { { "closeable", 1, TRUE }, { "pickproof", 2, TRUE }, { "closed", 4, TRUE }, { "locked", 8, TRUE }, { "", 0, 0 } }; const struct flag_type portal_flags [ ] = { { "nocursed", 1, TRUE }, { "gowithchar", 2, TRUE }, { "random", 4, TRUE }, { "buggy", 8, TRUE }, { "", 0, 0 } }; const struct flag_type mana_flags [ ] = { { "mana_earth", MANA_EARTH, TRUE }, { "mana_air", MANA_AIR, TRUE }, { "mana_fire", MANA_FIRE, TRUE }, { "mana_water", MANA_WATER, TRUE }, { "", 0, 0 } }; const struct flag_type liquid_flags [ ] = { { "water", 0, TRUE }, { "beer", 1, TRUE }, { "wine", 2, TRUE }, { "ale", 3, TRUE }, { "dark-ale", 4, TRUE }, { "whisky", 5, TRUE }, { "lemonade", 6, TRUE }, { "firebreather", 7, TRUE }, { "local-specialty", 8, TRUE }, { "slime-mold-juice", 9, TRUE }, { "milk", 10, TRUE }, { "tea", 11, TRUE }, { "coffee", 12, TRUE }, { "blood", 13, TRUE }, { "salt-water", 14, TRUE }, { "cola", 15, TRUE }, { "white wine", 16, TRUE }, { "root beer", 17, TRUE }, { "champagne", 18, TRUE }, { "vodka", 19, TRUE }, { "absinth", 20, TRUE }, { "brandy", 21, TRUE }, { "schnapps", 22, TRUE }, { "orange juice", 23, TRUE }, { "sherry", 24, TRUE }, { "rum", 25, TRUE }, { "port", 26, TRUE }, { "", 0, 0 } }; const struct flag_type mprog_type_flags [ ] = { { "in_file_prog", IN_FILE_PROG, TRUE }, { "act_prog", ACT_PROG, TRUE }, { "speech_prog", SPEECH_PROG, TRUE }, { "rand_prog", RAND_PROG, TRUE }, { "fight_prog", FIGHT_PROG, TRUE }, { "hitprcnt_prog", HITPRCNT_PROG, TRUE }, { "death_prog", DEATH_PROG, TRUE }, { "entry_prog", ENTRY_PROG, TRUE }, { "greet_prog", GREET_PROG, TRUE }, { "all_greet_prog", ALL_GREET_PROG, TRUE }, { "give_prog", GIVE_PROG, TRUE }, { "bribe_prog", BRIBE_PROG, TRUE }, { "", 0, 0 } }; const struct flag_type clan_flags [ ] = { { "clan", CLAN_PLAIN, TRUE }, { "npk_clan", CLAN_NOKILL, TRUE }, { "order", CLAN_ORDER, TRUE }, { "guild", CLAN_GUILD, TRUE }, { "", 0, 0 } }; const struct flag_type rank_flags [ ] = { { "exiled", RANK_EXILED, TRUE }, { "clansman", RANK_CLANSMAN, TRUE }, { "clanhero", RANK_CLANHERO, TRUE }, { "subchief", RANK_SUBCHIEF, TRUE }, { "chieftain", RANK_CHIEFTAIN, TRUE }, { "overlord", RANK_OVERLORD, TRUE }, { "", 0, 0 } }; struct wear_type { int wear_loc; int wear_bit; }; const struct wear_type wear_table_olc [ ] = { { WEAR_NONE, ITEM_TAKE }, { WEAR_LIGHT, ITEM_LIGHT }, { WEAR_FINGER_L, ITEM_WEAR_FINGER }, { WEAR_FINGER_R, ITEM_WEAR_FINGER }, { WEAR_NECK_1, ITEM_WEAR_NECK }, { WEAR_NECK_2, ITEM_WEAR_NECK }, { WEAR_BODY, ITEM_WEAR_BODY }, { WEAR_HEAD, ITEM_WEAR_HEAD }, { WEAR_LEGS, ITEM_WEAR_LEGS }, { WEAR_FEET, ITEM_WEAR_FEET }, { WEAR_HANDS, ITEM_WEAR_HANDS }, { WEAR_ARMS, ITEM_WEAR_ARMS }, { WEAR_SHIELD, ITEM_WEAR_SHIELD }, { WEAR_ABOUT, ITEM_WEAR_ABOUT }, { WEAR_WAIST, ITEM_WEAR_WAIST }, { WEAR_WRIST_L, ITEM_WEAR_WRIST }, { WEAR_WRIST_R, ITEM_WEAR_WRIST }, { WEAR_WIELD, ITEM_WIELD }, { WEAR_HOLD, ITEM_HOLD }, { WEAR_MISSILE_WIELD, ITEM_MISSILE_WIELD }, { NO_FLAG, NO_FLAG } }; int wear_loc( int bits, int count ) { int flag; for ( flag = 0; wear_table_olc[flag].wear_bit != NO_FLAG; flag++ ) if ( IS_SET( bits, wear_table_olc[flag].wear_bit ) && --count < 1 ) return wear_table_olc[flag].wear_loc; return NO_FLAG; } int wear_bit( int loc ) { int flag; for ( flag = 0; wear_table_olc[flag].wear_loc != NO_FLAG; flag++ ) if ( loc == wear_table_olc[flag].wear_loc ) return wear_table_olc[flag].wear_bit; return 0; }