/*************************************************************************** * God Wars Mud improvements copyright (C) 1994, 1995, 1996 by Richard * * Woolcock. This mud is NOT to be copied in whole or in part, or to be * * run without the permission of Richard Woolcock. Nobody else has * * permission to authorise the use of this code. * ***************************************************************************/ #if defined(macintosh) #include <types.h> #else #include <sys/types.h> #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include "merc.h" struct flag_stat_type { const struct flag_type *structure; bool stat; }; /***************************************************************************** Name: flag_stat_table Purpose: This table catagorizes the tables following the lookup functions below into stats and flags. Flags can be toggled but stats can only be assigned. Update this table when a new set of flags is installed. ****************************************************************************/ const struct flag_stat_type flag_stat_table[] = { /* { structure stat }, */ { area_flags, FALSE }, { sex_flags, TRUE }, { exit_flags, FALSE }, { door_resets, TRUE }, { room_flags, FALSE }, { sector_flags, TRUE }, { type_flags, TRUE }, { extra_flags, FALSE }, { wear_flags, FALSE }, { act_flags, FALSE }, { affect_flags, FALSE }, { apply_flags, TRUE }, { wear_loc_flags, TRUE }, { wear_loc_strings, TRUE }, { weapon_flags, TRUE }, { container_flags, FALSE }, { liquid_flags, TRUE }, /* END */ { 0, 0 } }; /***************************************************************************** Name: is_stat( table ) Purpose: Returns TRUE if the table is a stat table and FALSE if flag. Called by: flag_value and flag_string. Note: This function is local and used only in bit.c. ****************************************************************************/ 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; } /***************************************************************************** Name: flag_string( table, flags/stat ) Purpose: Returns string with name(s) of the flags or stat entered. Called by: act_olc.c, olc.c, and olc_save.c. ****************************************************************************/ char *flag_string( const struct flag_type *flag_table, int bits ) { static char buf[512]; int flag; buf[0] = '\0'; for (flag = 0; *flag_table[flag].name; flag++) /* OLC 1.1b */ { 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"; } const struct flag_type area_flags[] = { { "none", AREA_NONE, FALSE }, { "changed", AREA_CHANGED, FALSE }, { "added", AREA_ADDED, FALSE }, { "loading", AREA_LOADING, 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 container_flags[] = { { "closeable", 1, TRUE }, { "pickproof", 2, TRUE }, { "closed", 4, TRUE }, { "locked", 8, 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 }, { "cum", 16, TRUE }, { "cunt-juice", 17, TRUE }, { "urine", 18, 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 }, { "suck", 12, 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 }, { "neck", WEAR_NECK_1, 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 }, { "face", WEAR_FACE, 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 }, { "about the body", 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 }, { "on the face", WEAR_FACE, TRUE }, { "as a shield", WEAR_SHIELD, TRUE }, { "first hand", WEAR_WIELD, TRUE }, { "second hand", WEAR_HOLD, TRUE }, { "left scabbard", WEAR_SCABBARD_L,TRUE }, { "right scabbard", WEAR_SCABBARD_R,TRUE }, { "", 0 } }; 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 }, { "polymorph", APPLY_POLY, TRUE }, { "", 0, 0 } }; const struct flag_type affect_flags[] = { { "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 }, { "shadowplane", AFF_SHADOWPLANE, TRUE }, { "sanctuary", AFF_SANCTUARY, TRUE }, { "faerie-fire", AFF_FAERIE_FIRE, TRUE }, { "infrared", AFF_INFRARED, TRUE }, { "curse", AFF_CURSE, TRUE }, { "flaming", AFF_FLAMING, TRUE }, { "poison", AFF_POISON, TRUE }, { "protect", AFF_PROTECT, TRUE }, { "ethereal", AFF_ETHEREAL, 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 }, { "polymorph", AFF_POLYMORPH, FALSE }, { "shadowsight", AFF_SHADOWSIGHT, TRUE }, { "web", AFF_WEBBED, 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 }, { "train", ACT_TRAIN, TRUE }, { "practice", ACT_PRACTICE, TRUE }, { "mount", ACT_MOUNT, TRUE }, { "no_parts", ACT_NOPARTS, TRUE }, { "no_exp", ACT_NOEXP, 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 }, { "face", ITEM_WEAR_FACE, 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-container", ITEM_DRINK_CON, TRUE }, { "key", ITEM_KEY, TRUE }, { "food", ITEM_FOOD, TRUE }, { "money", ITEM_MONEY, TRUE }, { "boat", ITEM_BOAT, TRUE }, { "npc corpse", ITEM_CORPSE_NPC, TRUE }, { "pc corpse", ITEM_CORPSE_PC, FALSE }, { "fountain", ITEM_FOUNTAIN, TRUE }, { "pill", ITEM_PILL, TRUE }, { "portal", ITEM_PORTAL, TRUE }, { "egg", ITEM_EGG, TRUE }, { "voodoo", ITEM_VOODOO, TRUE }, { "stake", ITEM_STAKE, TRUE }, { "missile", ITEM_MISSILE, TRUE }, { "ammo", ITEM_AMMO, TRUE }, { "quest", ITEM_QUEST, TRUE }, { "symbol", ITEM_SYMBOL, TRUE }, { "book", ITEM_BOOK, TRUE }, { "page", ITEM_PAGE, TRUE }, { "tool", ITEM_TOOL, TRUE }, { "wall", ITEM_WALL, TRUE }, { "", 0, 0 } }; const struct flag_type extra_flags[] = { { "glow", ITEM_GLOW, TRUE }, { "hum", ITEM_HUM, TRUE }, { "thrown", ITEM_THROWN, TRUE }, { "keep", ITEM_KEEP, TRUE }, { "vanish", ITEM_VANISH, 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 }, { "shadowplane", ITEM_SHADOWPLANE, TRUE }, { "loyal", ITEM_LOYAL, 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 exit_flags[] = { { "door", EX_ISDOOR, TRUE }, { "closed", EX_CLOSED, TRUE }, { "locked", EX_LOCKED, TRUE }, { "pickproof", EX_PICKPROOF, 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 }, { "no_recall", ROOM_NO_RECALL, TRUE }, { "no_teleport", ROOM_NO_TELEPORT, TRUE }, { "total_darkness", ROOM_TOTAL_DARKNESS, TRUE }, /* Leave the bottom part */ { "", 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 }, { "swim", SECT_WATER_SWIM, TRUE }, { "noswim", SECT_WATER_NOSWIM, TRUE }, { "air", SECT_AIR, TRUE }, { "desert", SECT_DESERT, TRUE }, { "", 0, 0 } }; char *room_bit_name( int room_flags ) { static char buf[512]; buf[0] = '\0'; if ( room_flags & ROOM_DARK ) strcat( buf, " dark" ); if ( room_flags & ROOM_NO_MOB ) strcat( buf, " no_mobs" ); if ( room_flags & ROOM_INDOORS ) strcat( buf, " indoors" ); if ( room_flags & ROOM_PRIVATE ) strcat( buf, " private" ); if ( room_flags & ROOM_SAFE ) strcat( buf, " safe" ); if ( room_flags & ROOM_SOLITARY ) strcat( buf, " solitary" ); if ( room_flags & ROOM_PET_SHOP ) strcat( buf, " pet_shop" ); if ( room_flags & ROOM_NO_RECALL ) strcat( buf, " no_recall" ); if ( room_flags & ROOM_NO_TELEPORT ) strcat( buf, " no_teleport" ); if ( room_flags & ROOM_TOTAL_DARKNESS ) strcat( buf, " total_darkness" ); return ( buf[0] != '\0' ) ? buf+1 : "none"; } int room_name_bit( char* buf ) { if ( !str_cmp( buf, "dark" ) ) return ROOM_DARK; if ( !str_cmp( buf, "no_mobs" ) ) return ROOM_NO_MOB; if ( !str_cmp( buf, "indoors" ) ) return ROOM_INDOORS; if ( !str_cmp( buf, "private" ) ) return ROOM_PRIVATE; if ( !str_cmp( buf, "safe" ) ) return ROOM_SAFE; if ( !str_cmp( buf, "solitary" ) ) return ROOM_SOLITARY; if ( !str_cmp( buf, "pet_shop" ) ) return ROOM_PET_SHOP; if ( !str_cmp( buf, "no_recall" ) ) return ROOM_NO_RECALL; if ( !str_cmp( buf, "no_teleport" ) ) return ROOM_NO_TELEPORT; if ( !str_cmp( buf, "total_darkness" ) ) return ROOM_TOTAL_DARKNESS; return 0; } int sector_number( char *argument ) { if ( !str_cmp( argument, "inside" ) ) return SECT_INSIDE; if ( !str_cmp( argument, "city" ) ) return SECT_CITY; if ( !str_cmp( argument, "field" ) ) return SECT_FIELD; if ( !str_cmp( argument, "forest" ) ) return SECT_FOREST; if ( !str_cmp( argument, "hills" ) ) return SECT_HILLS; if ( !str_cmp( argument, "mountain" ) ) return SECT_MOUNTAIN; if ( !str_cmp( argument, "swim" ) ) return SECT_WATER_SWIM; if ( !str_cmp( argument, "noswim" ) ) return SECT_WATER_NOSWIM; if ( !str_cmp( argument, "underwater" ) ) return SECT_UNDERWATER; if ( !str_cmp( argument, "air" ) ) return SECT_AIR; if ( !str_cmp( argument, "desert" ) ) return SECT_DESERT; return SECT_MAX; } char *sector_name( int sect ) { if ( sect == SECT_INSIDE ) return "inside"; if ( sect == SECT_CITY ) return "city"; if ( sect == SECT_FIELD ) return "field"; if ( sect == SECT_FOREST ) return "forest"; if ( sect == SECT_HILLS ) return "hills"; if ( sect == SECT_MOUNTAIN ) return "mountain"; if ( sect == SECT_WATER_SWIM ) return "swim"; if ( sect == SECT_WATER_NOSWIM ) return "noswim"; if ( sect == SECT_UNDERWATER ) return "underwater"; if ( sect == SECT_AIR ) return "air"; if ( sect == SECT_DESERT ) return "desert"; return "unknown"; } /* * Return ascii name of an item type. */ char *item_type_name( int item_type ) { switch ( item_type ) { case ITEM_LIGHT: return "light"; case ITEM_SCROLL: return "scroll"; case ITEM_WAND: return "wand"; case ITEM_STAFF: return "staff"; case ITEM_WEAPON: return "weapon"; case ITEM_TREASURE: return "treasure"; case ITEM_ARMOR: return "armor"; case ITEM_POTION: return "potion"; case ITEM_FURNITURE: return "furniture"; case ITEM_TRASH: return "trash"; case ITEM_CONTAINER: return "container"; case ITEM_DRINK_CON: return "drink container"; case ITEM_KEY: return "key"; case ITEM_FOOD: return "food"; case ITEM_MONEY: return "money"; case ITEM_BOAT: return "boat"; case ITEM_CORPSE_NPC: return "npc corpse"; case ITEM_CORPSE_PC: return "pc corpse"; case ITEM_FOUNTAIN: return "fountain"; case ITEM_PILL: return "pill"; case ITEM_PORTAL: return "portal"; case ITEM_EGG: return "egg"; case ITEM_VOODOO: return "voodoo doll"; case ITEM_STAKE: return "stake"; case ITEM_MISSILE: return "missile"; case ITEM_AMMO: return "ammo"; case ITEM_QUEST: return "quest token"; case ITEM_QUESTCARD: return "quest card"; case ITEM_QUESTMACHINE: return "quest generator"; case ITEM_SYMBOL: return "magical symbol"; case ITEM_BOOK: return "book"; case ITEM_PAGE: return "page"; case ITEM_TOOL: return "tool"; case ITEM_WALL: return "wall"; case ITEM_WARD: return "ward"; } bug( "Item_type_name: unknown type %d.", item_type ); return "(unknown)"; } int item_name_type( char *name ) { if ( !str_cmp( name, "light" ) ) return ITEM_LIGHT; if ( !str_cmp( name, "scroll" ) ) return ITEM_SCROLL; if ( !str_cmp( name, "wand" ) ) return ITEM_WAND; if ( !str_cmp( name, "staff" ) ) return ITEM_STAFF; if ( !str_cmp( name, "weapon" ) ) return ITEM_WEAPON; if ( !str_cmp( name, "treasure" ) ) return ITEM_TREASURE; if ( !str_cmp( name, "armor" ) ) return ITEM_ARMOR; if ( !str_cmp( name, "potion" ) ) return ITEM_POTION; if ( !str_cmp( name, "furniture" ) ) return ITEM_FURNITURE; if ( !str_cmp( name, "trash" ) ) return ITEM_TRASH; if ( !str_cmp( name, "container" ) ) return ITEM_CONTAINER; if ( !str_cmp( name, "drink" ) ) return ITEM_DRINK_CON; if ( !str_cmp( name, "key" ) ) return ITEM_KEY; if ( !str_cmp( name, "food" ) ) return ITEM_FOOD; if ( !str_cmp( name, "money" ) ) return ITEM_MONEY; if ( !str_cmp( name, "boat" ) ) return ITEM_BOAT; if ( !str_cmp( name, "corpse" ) ) return ITEM_CORPSE_NPC; if ( !str_cmp( name, "fountain" ) ) return ITEM_FOUNTAIN; if ( !str_cmp( name, "pill" ) ) return ITEM_PILL; if ( !str_cmp( name, "portal" ) ) return ITEM_PORTAL; if ( !str_cmp( name, "egg" ) ) return ITEM_EGG; if ( !str_cmp( name, "stake" ) ) return ITEM_STAKE; if ( !str_cmp( name, "missile" ) ) return ITEM_MISSILE; if ( !str_cmp( name, "ammo" ) ) return ITEM_AMMO; return 0; } /* * Return ascii name of extra flags vector. */ char *extra_bit_name( int extra_flags ) { static char buf[512]; buf[0] = '\0'; if ( extra_flags & ITEM_GLOW ) strcat( buf, " glow" ); if ( extra_flags & ITEM_HUM ) strcat( buf, " hum" ); if ( extra_flags & ITEM_INVIS ) strcat( buf, " invis" ); if ( extra_flags & ITEM_MAGIC ) strcat( buf, " magic" ); if ( extra_flags & ITEM_NODROP ) strcat( buf, " nodrop" ); if ( extra_flags & ITEM_ANTI_GOOD ) strcat( buf, " anti-good" ); if ( extra_flags & ITEM_ANTI_EVIL ) strcat( buf, " anti-evil" ); if ( extra_flags & ITEM_ANTI_NEUTRAL ) strcat( buf, " anti-neutral" ); if ( extra_flags & ITEM_BLESS ) strcat( buf, " bless" ); if ( extra_flags & ITEM_NOREMOVE ) strcat( buf, " noremove" ); if ( extra_flags & ITEM_INVENTORY ) strcat( buf, " inventory" ); if ( extra_flags & ITEM_LOYAL ) strcat( buf, " loyal" ); if ( extra_flags & ITEM_SHADOWPLANE ) strcat( buf, " shadowplane" ); if ( extra_flags & ITEM_THROWN ) strcat( buf, " thrown" ); if ( extra_flags & ITEM_KEEP ) strcat( buf, " keep" ); if ( extra_flags & ITEM_VANISH ) strcat( buf, " illusion" ); return ( buf[0] != '\0' ) ? buf+1 : "none"; } int extra_name_bit( char* buf ) { if (!str_cmp( buf, "glow" ) ) return ITEM_GLOW ; if (!str_cmp( buf, "hum" ) ) return ITEM_HUM ; if (!str_cmp( buf, "thrown" ) ) return ITEM_THROWN ; if (!str_cmp( buf, "invis" ) ) return ITEM_INVIS ; if (!str_cmp( buf, "magic" ) ) return ITEM_MAGIC ; if (!str_cmp( buf, "nodrop" ) ) return ITEM_NODROP ; if (!str_cmp( buf, "bless" ) ) return ITEM_BLESS ; if (!str_cmp( buf, "anti-good" ) ) return ITEM_ANTI_GOOD ; if (!str_cmp( buf, "anti-evil" ) ) return ITEM_ANTI_EVIL ; if (!str_cmp( buf, "anti-neutral") ) return ITEM_ANTI_NEUTRAL; if (!str_cmp( buf, "noremove" ) ) return ITEM_NOREMOVE ; if (!str_cmp( buf, "inventory" ) ) return ITEM_INVENTORY ; if (!str_cmp( buf, "loyal" ) ) return ITEM_LOYAL ; if (!str_cmp( buf, "shadowplane" ) ) return ITEM_SHADOWPLANE ; if (!str_cmp( buf, "illusion" ) ) return ITEM_VANISH ; return 0; } /* * Returns the name of a wear bit. */ char *wear_bit_name( int wear ) { static char buf[512]; buf[0] = '\0'; if ( wear & ITEM_TAKE ) strcat( buf, " take" ); if ( wear & ITEM_WEAR_FINGER ) strcat( buf, " finger" ); if ( wear & ITEM_WEAR_NECK ) strcat( buf, " neck" ); if ( wear & ITEM_WEAR_BODY ) strcat( buf, " body" ); if ( wear & ITEM_WEAR_HEAD ) strcat( buf, " head" ); if ( wear & ITEM_WEAR_LEGS ) strcat( buf, " legs" ); if ( wear & ITEM_WEAR_FEET ) strcat( buf, " feet" ); if ( wear & ITEM_WEAR_HANDS ) strcat( buf, " hands" ); if ( wear & ITEM_WEAR_ARMS ) strcat( buf, " arms" ); if ( wear & ITEM_WEAR_ABOUT ) strcat( buf, " about" ); if ( wear & ITEM_WEAR_WAIST ) strcat( buf, " waist" ); if ( wear & ITEM_WEAR_WRIST ) strcat( buf, " wrist" ); if ( wear & ITEM_WIELD ) strcat( buf, " hold" ); if ( wear & ITEM_WEAR_FACE ) strcat( buf, " face" ); return ( buf[0] != '\0' ) ? buf+1 : "none"; } /* * Returns the bit, given a certain name. */ int wear_name_bit( char* buf ) { if (!str_cmp( buf, "take" ) ) return ITEM_TAKE; if (!str_cmp( buf, "finger" ) ) return ITEM_WEAR_FINGER; if (!str_cmp( buf, "neck" ) ) return ITEM_WEAR_NECK; if (!str_cmp( buf, "body" ) ) return ITEM_WEAR_BODY; if (!str_cmp( buf, "head" ) ) return ITEM_WEAR_HEAD; if (!str_cmp( buf, "legs" ) ) return ITEM_WEAR_LEGS; if (!str_cmp( buf, "feet" ) ) return ITEM_WEAR_FEET; if (!str_cmp( buf, "hands" ) ) return ITEM_WEAR_HANDS; if (!str_cmp( buf, "arms" ) ) return ITEM_WEAR_ARMS; if (!str_cmp( buf, "about" ) ) return ITEM_WEAR_ABOUT; if (!str_cmp( buf, "waist" ) ) return ITEM_WEAR_WAIST; if (!str_cmp( buf, "wrist" ) ) return ITEM_WEAR_WRIST; if (!str_cmp( buf, "hold" ) ) return ITEM_WIELD; if (!str_cmp( buf, "face" ) ) return ITEM_WEAR_FACE; return 0; } int act_name_bit( char* buf ) { if ( !str_cmp( buf, "sentinel" ) ) return ACT_SENTINEL; if ( !str_cmp( buf, "scavenger" ) ) return ACT_SCAVENGER; if ( !str_cmp( buf, "aggressive" ) ) return ACT_AGGRESSIVE; if ( !str_cmp( buf, "stay_area" ) ) return ACT_STAY_AREA; if ( !str_cmp( buf, "wimpy" ) ) return ACT_WIMPY; if ( !str_cmp( buf, "mount" ) ) return ACT_MOUNT; if ( !str_cmp( buf, "no_parts" ) ) return ACT_NOPARTS; if ( !str_cmp( buf, "no_exp" ) ) return ACT_NOEXP; if ( !str_cmp( buf, "skilled" ) ) return ACT_SKILLED; return 0; } /* * Return bit vector */ int affect_name_bit( char* buf ) { if (!str_cmp( buf, "blind" )) return AFF_BLIND; if (!str_cmp( buf, "invisible" )) return AFF_INVISIBLE; if (!str_cmp( buf, "detect-evil" )) return AFF_DETECT_EVIL; if (!str_cmp( buf, "detect-invis" )) return AFF_DETECT_INVIS; if (!str_cmp( buf, "detect-magic" )) return AFF_DETECT_MAGIC; if (!str_cmp( buf, "detect-hidden" )) return AFF_DETECT_HIDDEN; if (!str_cmp( buf, "shadowplane" )) return AFF_SHADOWPLANE; if (!str_cmp( buf, "sanctuary" )) return AFF_SANCTUARY; if (!str_cmp( buf, "faerie-fire" )) return AFF_FAERIE_FIRE; if (!str_cmp( buf, "infrared" )) return AFF_INFRARED; if (!str_cmp( buf, "curse" )) return AFF_CURSE; if (!str_cmp( buf, "flaming" )) return AFF_FLAMING; if (!str_cmp( buf, "poison" )) return AFF_POISON; if (!str_cmp( buf, "protect" )) return AFF_PROTECT; if (!str_cmp( buf, "ethereal" )) return AFF_ETHEREAL; if (!str_cmp( buf, "sneak" )) return AFF_SNEAK; if (!str_cmp( buf, "hide" )) return AFF_HIDE; if (!str_cmp( buf, "sleep" )) return AFF_SLEEP; if (!str_cmp( buf, "charm" )) return AFF_CHARM; if (!str_cmp( buf, "flying" )) return AFF_FLYING; if (!str_cmp( buf, "pass-door" )) return AFF_PASS_DOOR; if (!str_cmp( buf, "shadowsight" )) return AFF_SHADOWSIGHT; if (!str_cmp( buf, "rotting" )) return AFF_ROT; if (!str_cmp( buf, "coward" )) return AFF_FEAR; return 0; } int affect_name_loc( char* name ) { if ( !str_cmp( name, "none" ) ) return APPLY_NONE; if ( !str_cmp( name, "strength" ) ) return APPLY_STR; if ( !str_cmp( name, "dexterity" ) ) return APPLY_DEX; if ( !str_cmp( name, "intelligence" ) ) return APPLY_INT; if ( !str_cmp( name, "wisdom" ) ) return APPLY_WIS; if ( !str_cmp( name, "constitution" ) ) return APPLY_CON; if ( !str_cmp( name, "height" ) ) return APPLY_HEIGHT; if ( !str_cmp( name, "weight" ) ) return APPLY_WEIGHT; if ( !str_cmp( name, "mana" ) ) return APPLY_MANA; if ( !str_cmp( name, "hp" ) ) return APPLY_HIT; if ( !str_cmp( name, "move" ) ) return APPLY_MOVE; if ( !str_cmp( name, "ac" ) ) return APPLY_AC; if ( !str_cmp( name, "hit" ) ) return APPLY_HITROLL; if ( !str_cmp( name, "dam" ) ) return APPLY_DAMROLL; if ( !str_cmp( name, "blood_pool" ) ) return APPLY_BLOOD_MAX; if ( !str_cmp( name, "blood_potency" ) ) return APPLY_BLOOD_POT; return APPLY_NONE; } int wear_name_loc( char *buf ) { if ( !str_cmp( buf, "light" ) ) return WEAR_LIGHT; if ( !str_cmp( buf, "lfinger" ) ) return WEAR_FINGER_L; if ( !str_cmp( buf, "rfinger" ) ) return WEAR_FINGER_R; if ( !str_cmp( buf, "neck1" ) ) return WEAR_NECK_1; if ( !str_cmp( buf, "neck2" ) ) return WEAR_NECK_2; if ( !str_cmp( buf, "body" ) ) return WEAR_BODY; if ( !str_cmp( buf, "head" ) ) return WEAR_HEAD; if ( !str_cmp( buf, "legs" ) ) return WEAR_LEGS; if ( !str_cmp( buf, "feet" ) ) return WEAR_FEET; if ( !str_cmp( buf, "hands" ) ) return WEAR_HANDS; if ( !str_cmp( buf, "arms" ) ) return WEAR_ARMS; if ( !str_cmp( buf, "about" ) ) return WEAR_ABOUT; if ( !str_cmp( buf, "waist" ) ) return WEAR_WAIST; if ( !str_cmp( buf, "lwrist" ) ) return WEAR_WRIST_L; if ( !str_cmp( buf, "rwrist" ) ) return WEAR_WRIST_R; if ( !str_cmp( buf, "hold" ) ) return WEAR_WIELD; if ( !str_cmp( buf, "face" ) ) return WEAR_FACE; return WEAR_NONE; } /* * Return ascii name of wear location. */ char *wear_loc_name( int wearloc ) { switch( wearloc ) { default: return "unknown"; case WEAR_NONE: return "in the inventory"; case WEAR_LIGHT: return "as a light"; case WEAR_FINGER_L: return "on the left finger"; case WEAR_FINGER_R: return "on the right finger"; case WEAR_NECK_1: return "around the neck (1)"; case WEAR_NECK_2: return "around the neck (2)"; case WEAR_BODY: return "on the body"; case WEAR_HEAD: return "over the head"; case WEAR_LEGS: return "on the legs"; case WEAR_FEET: return "on the feet"; case WEAR_HANDS: return "on the hands"; case WEAR_ARMS: return "on the arms"; case WEAR_ABOUT: return "about the shoulders"; case WEAR_WAIST: return "around the waist"; case WEAR_WRIST_L: return "on the left wrist"; case WEAR_WRIST_R: return "on the right wrist"; case WEAR_WIELD: return "in the hand"; case WEAR_FACE: return "on the face"; } } char *act_bit_name( int act ) { static char buf[512]; buf[0] = '\0'; if ( act & ACT_IS_NPC ) strcat( buf, " npc" ); if ( act & ACT_SENTINEL ) strcat( buf, " sentinel" ); if ( act & ACT_SCAVENGER ) strcat( buf, " scavenger" ); if ( act & ACT_AGGRESSIVE ) strcat( buf, " aggressive" ); if ( act & ACT_STAY_AREA ) strcat( buf, " stay_area" ); if ( act & ACT_WIMPY ) strcat( buf, " wimpy" ); if ( act & ACT_PET ) strcat( buf, " pet" ); if ( act & ACT_TRAIN ) strcat( buf, " trainer" ); if ( act & ACT_PRACTICE ) strcat( buf, " practitioner" ); if ( act & ACT_MOUNT ) strcat( buf, " mount" ); if ( act & ACT_NOPARTS ) strcat( buf, " no_parts" ); if ( act & ACT_NOEXP ) strcat( buf, " no_ext" ); if ( act & ACT_SKILLED ) strcat( buf, " skilled" ); return ( buf[0] != '\0' ) ? buf+1 : "none"; } int get_weapon_type( char *arg ) { if (!str_cmp( arg, "hit" ) ) return 0; if (!str_cmp( arg, "slice" ) ) return 1; if (!str_cmp( arg, "stab" ) ) return 2; if (!str_cmp( arg, "slash" ) ) return 3; if (!str_cmp( arg, "whip" ) ) return 4; if (!str_cmp( arg, "claw" ) ) return 5; if (!str_cmp( arg, "blast" ) ) return 6; if (!str_cmp( arg, "pound" ) ) return 7; if (!str_cmp( arg, "crush" ) ) return 8; if (!str_cmp( arg, "grep" ) ) return 9; if (!str_cmp( arg, "bite" ) ) return 10; if (!str_cmp( arg, "pierce" ) ) return 11; if (!str_cmp( arg, "suction") ) return 12; if (!str_cmp( arg, "chop" ) ) return 13; return 0; } /* * Use this in dam_message in fight.c if you like. */ char * get_type_weapon( int arg ) { switch ( arg ) { case 0: return "hit"; case 1: return "slice"; case 2: return "stab"; case 3: return "slash"; case 4: return "whip"; case 5: return "claw"; case 6: return "blast"; case 7: return "pound"; case 8: return "crush"; case 9: return "grep"; case 10: return "bite"; case 11: return "pierce"; case 12: return "suction"; case 13: return "chop"; } bug( "Get_type_weapon: unknown type %d.", arg ); return "(unknown)"; } int get_container_flags( char *arg ) { if (!str_cmp( arg, "closeable" ) ) return 1; if (!str_cmp( arg, "pickproof" ) ) return 2; if (!str_cmp( arg, "closed" ) ) return 4; if (!str_cmp( arg, "locked" ) ) return 8; return 0; } char * get_flags_container( int arg ) { static char buf[512]; buf[0] = '\0'; if ( arg & 1 ) strcat( buf, " closeable" ); if ( arg & 2 ) strcat( buf, " pickproof" ); if ( arg & 4 ) strcat( buf, " closed" ); if ( arg & 8 ) strcat( buf, " locked" ); return ( buf[0] != '\0' ) ? buf+1 : "none"; } int get_liquid_type( char *arg ) { if (!str_cmp( arg, "water" ) ) return 0; if (!str_cmp( arg, "beer" ) ) return 1; if (!str_cmp( arg, "wine" ) ) return 2; if (!str_cmp( arg, "ale" ) ) return 3; if (!str_cmp( arg, "dark_ale" ) ) return 4; if (!str_cmp( arg, "whisky" ) ) return 5; if (!str_cmp( arg, "lemonade" ) ) return 6; if (!str_cmp( arg, "firebreather" ) ) return 7; if (!str_cmp( arg, "local_specialty" ) ) return 8; if (!str_cmp( arg, "slime_mold_juice" ) ) return 9; if (!str_cmp( arg, "milk" ) ) return 10; if (!str_cmp( arg, "tea" ) ) return 11; if (!str_cmp( arg, "coffee" ) ) return 12; if (!str_cmp( arg, "blood" ) ) return 13; if (!str_cmp( arg, "salt_water" ) ) return 14; if (!str_cmp( arg, "cola" ) ) return 15; return 0; } char * get_type_liquid( int arg ) { switch ( arg ) { case 0: return "water"; case 1: return "beer"; case 2: return "wine"; case 3: return "ale"; case 4: return "dark_ale"; case 5: return "whisky"; case 6: return "lemonade"; case 7: return "firebreather"; case 8: return "local_specialty"; case 9: return "slime_mold_juice"; case 10: return "milk"; case 11: return "tea"; case 12: return "coffee"; case 13: return "blood"; case 14: return "sale_water"; case 15: return "cola"; } bug( "Get_type_liquid: unknown type %d.", arg ); return "(unknown)"; }