--- deliantra/server/common/item.C 2006/09/03 00:18:40 1.3 +++ deliantra/server/common/item.C 2006/12/30 21:07:46 1.16 @@ -1,9 +1,4 @@ /* - * static char *rcsid_item_c = - * "$Id: item.C,v 1.3 2006/09/03 00:18:40 root Exp $"; - */ - -/* CrossFire, A Multiplayer game for X-windows Copyright (C) 2002 Mark Wedel & Crossfire Development Team @@ -23,7 +18,7 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - The authors can be reached via e-mail at crossfire-devel@real-time.com + The authors can be reached via e-mail at */ #include @@ -53,43 +48,42 @@ * "This item goes %s\n", with the use/nonuse values filling in the %s */ Body_Locations body_locations[NUM_BODY_LOCATIONS] = { -{"body_range", "in your range slot", "in a human's range slot"}, -{"body_arm", "on your arm", "on a human's arm"}, -{"body_torso", "on your body", "on a human's torso"}, -{"body_head", "on your head", "on a human's head"}, -{"body_neck", "around your neck", "around a humans neck"}, -{"body_skill", "in your skill slot", "in a human's skill slot"}, -{"body_finger", "on your finger", "on a human's finger"}, -{"body_shoulder", "around your shoulders", "around a human's shoulders"}, -{"body_foot", "on your feet", "on a human's feet"}, -{"body_hand", "on your hands", "on a human's hands"}, -{"body_wrist", "around your wrists", "around a human's wrist"}, -{"body_waist", "around your waist", "around a human's waist"}, - + {"body_range", "in your range slot", "in a human's range slot"}, + {"body_arm", "on your arm", "on a human's arm"}, + {"body_torso", "on your body", "on a human's torso"}, + {"body_head", "on your head", "on a human's head"}, + {"body_neck", "around your neck", "around a humans neck"}, + {"body_skill", "in your skill slot", "in a human's skill slot"}, + {"body_finger", "on your finger", "on a human's finger"} , + {"body_shoulder", "around your shoulders", "around a human's shoulders"}, + {"body_foot", "on your feet", "on a human's feet"}, + {"body_hand", "on your hands", "on a human's hands"}, + {"body_wrist", "around your wrists", "around a human's wrist"}, + {"body_waist", "around your waist", "around a human's waist"}, /*{"body_dragon_torso", "your body", "a dragon's body"} */ }; static char numbers[21][20] = { - "no","","two","three","four","five","six","seven","eight","nine","ten", - "eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen", - "eighteen","nineteen","twenty" + "no", "", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", + "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", + "eighteen", "nineteen", "twenty" }; static char numbers_10[10][20] = { - "zero","ten","twenty","thirty","fourty","fifty","sixty","seventy", - "eighty","ninety" + "zero", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", + "eighty", "ninety" }; static char levelnumbers[21][20] = { - "zeroth","first", "second", "third", "fourth", "fifth", "sixth", "seventh", + "zeroth", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteen", "nineteen", "twentieth" }; static char levelnumbers_10[11][20] = { - "zeroth","tenth","twentieth","thirtieth","fortieth","fiftieth","sixtieth", - "seventieth","eightieth","ninetieth" + "zeroth", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", + "seventieth", "eightieth", "ninetieth" }; /* The following is a large table of item types, the fields are: @@ -99,129 +93,119 @@ * define.h */ static const typedata item_types[] = { -{PLAYER, "player", "players", 0, 0}, -{ROD, "rod", "rods", SK_THAUMATURGY, 0}, -{TREASURE, "treasure", "treasure", 0, 0}, -{POTION, "potion", "potions", SK_ALCHEMY, 0}, -{FOOD, "food", "food", SK_WOODSMAN, 0}, -{POISON, "poison", "poisons", SK_ALCHEMY, 0}, -{BOOK, "book", "books", SK_LITERACY, 0}, -{CLOCK, "clock", "clocks", 0, 0}, -{LIGHTNING, "lightning", "lightning", 0, 0}, -{ARROW, "arrow", "arrows", SK_BOWYER, 0}, -{BOW, "bow", "bows", SK_BOWYER, 0}, -{WEAPON, "weapon", "weapons", SK_SMITHERY, 0}, -{ARMOUR, "armour", "armour", SK_SMITHERY, 0}, -{PEDESTAL, "pedestal", "pedestals", 0, 0}, -{ALTAR, "altar", "altars", 0, 0}, -{LOCKED_DOOR, "locked door", "locked doors", 0, 0}, -{SPECIAL_KEY, "special key", "special keys", 0, 0}, -{MAP, "map", "maps", 0, 0}, -{DOOR, "door", "doors", 0, 0}, -{KEY, "key", "keys", 0, 0}, -{TIMED_GATE, "timed_gate", "timed_gates", 0, 0}, -{TRIGGER, "trigger", "triggers", 0, 0}, -{GRIMREAPER, "grimreaper", "grimreapers", 0, 0}, -{MAGIC_EAR, "magic ear", "magic ears", 0, 0}, -{TRIGGER_BUTTON, "trigger button", "trigger buttons", 0, 0}, -{TRIGGER_ALTAR, "trigger altar", "trigger altars", 0, 0}, -{TRIGGER_PEDESTAL, "trigger pedestal", "trigger pedestals", 0, 0}, -{SHIELD, "shield", "shields", SK_SMITHERY, 0}, -{HELMET, "helmet", "helmets", SK_SMITHERY, 0}, -{HORN, "horn", "horns", SK_THAUMATURGY, 0}, -{MONEY, "money", "money", 0, 0}, -{CLASS, "class", "classes", 0, 0}, -{GRAVESTONE, "gravestone", "gravestones", 0, 0}, -{AMULET, "amulet", "amulets", SK_JEWELER, 0}, -{PLAYERMOVER, "player mover", "player movers", 0, 0}, -{TELEPORTER, "teleporter", "teleporters", 0, 0}, -{CREATOR, "creator", "creators", 0, 0}, -{SKILL, "skill", "skills", 0, 0}, -{EXPERIENCE, "experience", "experience", 0, 0}, -{EARTHWALL, "earthwall", "earthwalls", 0, 0}, -{GOLEM, "golem", "golems", 0, 0}, -{THROWN_OBJ, "projectile", "projectiles", 0, 0}, -{BLINDNESS, "blindness", "blindness", 0, 0}, -{GOD, "god", "gods", 0, 0}, -{DETECTOR, "detector", "detectors", 0, 0}, -{TRIGGER_MARKER, "trigger marker", "trigger markers", 0, 0}, -{DEAD_OBJECT, "dead object", "dead objects", 0, 0}, -{DRINK, "drink", "drinks", SK_WOODSMAN, SK_ALCHEMY}, -{MARKER, "marker", "markers", 0, 0}, -{HOLY_ALTAR, "holy altar", "holy altars", 0, 0}, -{PLAYER_CHANGER, "player changer", "player changers", 0, 0}, -{BATTLEGROUND, "battleground", "battlegrounds", 0, 0}, -{PEACEMAKER, "peacemaker", "peacemakers", 0, 0}, -{GEM, "gem", "gems", SK_JEWELER, 0}, -{FIREWALL, "firewall", "firewalls", 0, 0}, -{ANVIL, "anvil", "anvils", 0, 0}, -{CHECK_INV, "inventory checker", "inventory checkers", 0, 0}, -{MOOD_FLOOR, "mood floor", "mood floors", 0, 0}, -{EXIT, "exit", "exits", 0, 0}, -{ENCOUNTER, "encounter", "encounters", 0, 0}, -{SHOP_FLOOR, "shop floor", "shop floors", 0, 0}, -{SHOP_MAT, "shop mat", "shop mats", 0, 0}, -{RING, "ring", "rings", SK_JEWELER, 0}, -{FLOOR, "floor", "floors", 0, 0}, -{FLESH, "flesh", "flesh", SK_WOODSMAN, 0}, -{INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0}, -{SKILL_TOOL, "skill tool", "skill tools", 0, 0}, -{LIGHTER, "lighter", "lighters", 0, 0}, -{TRAP_PART, "trap part", "trap parts", 0, 0}, -{WALL, "wall", "walls", 0, 0}, -{LIGHT_SOURCE, "light source", "light sources", 0, 0}, -{MISC_OBJECT, "bric-a-brac", "bric-a-brac", 0, 0}, -{MONSTER, "monster", "monsters", 0, 0}, -{SPAWN_GENERATOR, "monster generator", "monster generators", 0, 0}, -{LAMP, "lamp", "lamps", 0, 0}, -{DUPLICATOR, "duplicator", "duplicators", 0, 0}, -{TOOL, "tool", "tools", 0, 0}, -{SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0}, -{BUILDFAC, "building facility", "building facilities", 0, 0}, -{CLOAK, "cloak", "cloaks", SK_SMITHERY, 0}, -{SPINNER, "spinner", "spinners", 0, 0}, -{GATE, "gate", "gates", 0, 0}, -{BUTTON, "button", "buttons", 0, 0}, -{CF_HANDLE, "cf handle", "cf handles", 0, 0}, -{HOLE, "hole", "holes", 0, 0}, -{TRAPDOOR, "trapdoor", "trapdoors", 0, 0}, -{SIGN, "sign", "signs", 0, 0}, -{BOOTS, "boots", "boots", SK_SMITHERY, 0}, -{GLOVES, "gloves", "gloves", SK_SMITHERY, 0}, -{SPELL, "spell", "spells", 0, 0}, -{SPELL_EFFECT, "spell effect", "spell effects", 0, 0}, -{CONVERTER, "converter", "converters", 0, 0}, -{BRACERS, "bracers", "bracers", SK_SMITHERY, 0}, -{POISONING, "poisoning", "poisonings", 0, 0}, -{SAVEBED, "savebed", "savebeds", 0, 0}, -{POISONCLOUD, "poison cloud", "poison clouds", 0, 0}, -{FIREHOLES, "fireholes", "fireholes", 0, 0}, -{WAND, "wand", "wands", SK_THAUMATURGY, 0}, -{SCROLL, "scroll", "scrolls", SK_LITERACY, 0}, -{DIRECTOR, "director", "directors", 0, 0}, -{GIRDLE, "girdle", "girdles", SK_SMITHERY, 0}, -{FORCE, "force", "forces", 0, 0}, -{POTION_EFFECT, "potion effect", "potion effects", 0, 0}, -{CLOSE_CON, "closed container", "closed container", 0, 0}, -{CONTAINER, "container", "containers", SK_ALCHEMY, 0}, -{ARMOUR_IMPROVER, "armour improver", "armour improvers", 0, 0}, -{WEAPON_IMPROVER, "weapon improver", "weapon improvers", 0, 0}, -{SKILLSCROLL, "skillscroll", "skillscrolls", 0, 0}, -{DEEP_SWAMP, "deep swamp", "deep swamps", 0, 0}, -{IDENTIFY_ALTAR, "identify altar", "identify altars", 0, 0}, -{MENU, "inventory list", "inventory lists", 0, 0}, -{RUNE, "rune", "runes", 0, 0}, -{TRAP, "trap", "traps", 0, 0}, -{POWER_CRYSTAL, "power_crystal", "power_crystals", 0, 0}, -{CORPSE, "corpse", "corpses", 0, 0}, -{DISEASE, "disease", "diseases", 0, 0}, -{SYMPTOM, "symptom", "symptoms", 0, 0}, -{BUILDER, "item builder", "item builders", 0, 0}, -{MATERIAL, "building material", "building materials", 0, 0}, -{ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0}, + {PLAYER, "player", "players", 0, 0}, + {ROD, "rod", "rods", SK_THAUMATURGY, 0}, + {TREASURE, "treasure", "treasure", 0, 0}, + {POTION, "potion", "potions", SK_ALCHEMY, 0}, + {FOOD, "food", "food", SK_WOODSMAN, 0}, + {POISON, "poison", "poisons", SK_ALCHEMY, 0}, + {BOOK, "book", "books", SK_LITERACY, 0}, + {CLOCK, "clock", "clocks", 0, 0}, + {ARROW, "arrow", "arrows", SK_BOWYER, 0}, + {BOW, "bow", "bows", SK_BOWYER, 0}, + {WEAPON, "weapon", "weapons", SK_SMITHERY, 0}, + {ARMOUR, "armour", "armour", SK_SMITHERY, 0}, + {PEDESTAL, "pedestal", "pedestals", 0, 0}, + {ALTAR, "altar", "altars", 0, 0}, + {LOCKED_DOOR, "locked door", "locked doors", 0, 0}, + {SPECIAL_KEY, "special key", "special keys", 0, 0}, + {MAP, "map", "maps", 0, 0}, + {DOOR, "door", "doors", 0, 0}, + {KEY, "key", "keys", 0, 0}, + {TIMED_GATE, "timed_gate", "timed_gates", 0, 0}, + {TRIGGER, "trigger", "triggers", 0, 0}, + {GRIMREAPER, "grimreaper", "grimreapers", 0, 0}, + {MAGIC_EAR, "magic ear", "magic ears", 0, 0}, + {TRIGGER_BUTTON, "trigger button", "trigger buttons", 0, 0}, + {TRIGGER_ALTAR, "trigger altar", "trigger altars", 0, 0}, + {TRIGGER_PEDESTAL, "trigger pedestal", "trigger pedestals", 0, 0}, + {SHIELD, "shield", "shields", SK_SMITHERY, 0}, + {HELMET, "helmet", "helmets", SK_SMITHERY, 0}, + {HORN, "horn", "horns", SK_THAUMATURGY, 0}, + {MONEY, "money", "money", 0, 0}, + {CLASS, "class", "classes", 0, 0}, + {GRAVESTONE, "gravestone", "gravestones", 0, 0}, + {AMULET, "amulet", "amulets", SK_JEWELER, 0}, + {PLAYERMOVER, "player mover", "player movers", 0, 0}, + {TELEPORTER, "teleporter", "teleporters", 0, 0}, + {CREATOR, "creator", "creators", 0, 0}, + {SKILL, "skill", "skills", 0, 0}, + {EARTHWALL, "earthwall", "earthwalls", 0, 0}, + {GOLEM, "golem", "golems", 0, 0}, + {THROWN_OBJ, "projectile", "projectiles", 0, 0}, + {BLINDNESS, "blindness", "blindness", 0, 0}, + {GOD, "god", "gods", 0, 0}, + {DETECTOR, "detector", "detectors", 0, 0}, + {TRIGGER_MARKER, "trigger marker", "trigger markers", 0, 0}, + {DEAD_OBJECT, "dead object", "dead objects", 0, 0}, + {DRINK, "drink", "drinks", SK_WOODSMAN, SK_ALCHEMY}, + {MARKER, "marker", "markers", 0, 0}, + {HOLY_ALTAR, "holy altar", "holy altars", 0, 0}, + {PLAYER_CHANGER, "player changer", "player changers", 0, 0}, + {BATTLEGROUND, "battleground", "battlegrounds", 0, 0}, + {PEACEMAKER, "peacemaker", "peacemakers", 0, 0}, + {GEM, "gem", "gems", SK_JEWELER, 0}, + {FIREWALL, "firewall", "firewalls", 0, 0}, + {ANVIL, "anvil", "anvils", 0, 0}, + {CHECK_INV, "inventory checker", "inventory checkers", 0, 0}, + {MOOD_FLOOR, "mood floor", "mood floors", 0, 0}, + {EXIT, "exit", "exits", 0, 0}, + {ENCOUNTER, "encounter", "encounters", 0, 0}, + {SHOP_FLOOR, "shop floor", "shop floors", 0, 0}, + {SHOP_MAT, "shop mat", "shop mats", 0, 0}, + {RING, "ring", "rings", SK_JEWELER, 0}, + {FLOOR, "floor", "floors", 0, 0}, + {FLESH, "flesh", "flesh", SK_WOODSMAN, 0}, + {INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0}, + {SKILL_TOOL, "skill tool", "skill tools", 0, 0}, + {LIGHTER, "lighter", "lighters", 0, 0}, + {BUILDABLE_WALL, "buildable wall", "buildable walls", 0, 0}, + {MISC_OBJECT, "bric-a-brac", "bric-a-brac", 0, 0}, + {LAMP, "lamp", "lamps", 0, 0}, + {DUPLICATOR, "duplicator", "duplicators", 0, 0}, + {SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0}, + {CLOAK, "cloak", "cloaks", SK_SMITHERY, 0}, + {SPINNER, "spinner", "spinners", 0, 0}, + {GATE, "gate", "gates", 0, 0}, + {BUTTON, "button", "buttons", 0, 0}, + {CF_HANDLE, "cf handle", "cf handles", 0, 0}, + {HOLE, "hole", "holes", 0, 0}, + {TRAPDOOR, "trapdoor", "trapdoors", 0, 0}, + {SIGN, "sign", "signs", 0, 0}, + {BOOTS, "boots", "boots", SK_SMITHERY, 0}, + {GLOVES, "gloves", "gloves", SK_SMITHERY, 0}, + {SPELL, "spell", "spells", 0, 0}, + {SPELL_EFFECT, "spell effect", "spell effects", 0, 0}, + {CONVERTER, "converter", "converters", 0, 0}, + {BRACERS, "bracers", "bracers", SK_SMITHERY, 0}, + {POISONING, "poisoning", "poisonings", 0, 0}, + {SAVEBED, "savebed", "savebeds", 0, 0}, + {WAND, "wand", "wands", SK_THAUMATURGY, 0}, + {SCROLL, "scroll", "scrolls", SK_LITERACY, 0}, + {DIRECTOR, "director", "directors", 0, 0}, + {GIRDLE, "girdle", "girdles", SK_SMITHERY, 0}, + {FORCE, "force", "forces", 0, 0}, + {POTION_EFFECT, "potion effect", "potion effects", 0, 0}, + {CLOSE_CON, "closed container", "closed container", 0, 0}, + {CONTAINER, "container", "containers", SK_ALCHEMY, 0}, + {ARMOUR_IMPROVER, "armour improver", "armour improvers", 0, 0}, + {WEAPON_IMPROVER, "weapon improver", "weapon improvers", 0, 0}, + {SKILLSCROLL, "skillscroll", "skillscrolls", 0, 0}, + {DEEP_SWAMP, "deep swamp", "deep swamps", 0, 0}, + {IDENTIFY_ALTAR, "identify altar", "identify altars", 0, 0}, + {MENU, "inventory list", "inventory lists", 0, 0}, + {RUNE, "rune", "runes", 0, 0}, + {TRAP, "trap", "traps", 0, 0}, + {POWER_CRYSTAL, "power_crystal", "power_crystals", 0, 0}, + {CORPSE, "corpse", "corpses", 0, 0}, + {DISEASE, "disease", "diseases", 0, 0}, + {SYMPTOM, "symptom", "symptoms", 0, 0}, + {BUILDER, "item builder", "item builders", 0, 0}, + {MATERIAL, "building material", "building materials", 0, 0}, + {ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0}, }; -const int item_types_size=sizeof(item_types)/sizeof(*item_types); +const int item_types_size = sizeof (item_types) / sizeof (*item_types); materialtype_t *materialt; @@ -258,17 +242,20 @@ * custom objects can use whatever they want. */ static int enc_to_item_power[21] = { -0, 0, 1, 2, 3, 4, /* 5 */ -5, 7, 9, 11, 13, /* 10 */ -15, 18, 21, 24, 27, /* 15 */ -30, 35, 40, 45, 50 /* 20 */ + 0, 0, 1, 2, 3, 4, /* 5 */ + 5, 7, 9, 11, 13, /* 10 */ + 15, 18, 21, 24, 27, /* 15 */ + 30, 35, 40, 45, 50 /* 20 */ }; -int get_power_from_ench(int ench) +int +get_power_from_ench (int ench) { - if (ench < 0) ench = 0; - if (ench > 20) ench = 20; - return enc_to_item_power[ench]; + if (ench < 0) + ench = 0; + if (ench > 20) + ench = 20; + return enc_to_item_power[ench]; } /* This takes an object 'op' and figures out what its item_power @@ -278,121 +265,150 @@ * If flag is 1, we return the number of enchantment, and not the * the power. This is used in the treasure code. */ -int calc_item_power(const object *op, int flag) +int +calc_item_power (const object *op, int flag) { - int i, tmp, enc; + int i, tmp, enc; - enc = 0; - for (i=0; istats, i); - - /* This protection logic is pretty flawed. 20% fire resistance - * is much more valuable than 20% confusion, or 20% slow, or - * several others. Start at 1 - ignore physical - all that normal - * armour shouldn't be counted against - */ - tmp = 0; - for (i=1; iresist[i]; - - /* Add/substract 10 so that the rounding works out right */ - if (tmp>0) enc += (tmp+10)/20; - else if (tmp<0) enc += (tmp - 10) / 20; - - enc += op->magic; - - /* For each attacktype a weapon has, one more encantment. Start at 1 - - * physical doesn't count against total. - */ - if (op->type == WEAPON) { - for (i=1; iattacktype & (1 << i)) enc++; - if (op->slaying) enc += 2; /* What it slays is probably more relevent */ - } - /* Items the player can equip */ - if ((op->type == WEAPON) || (op->type == ARMOUR) || (op->type == HELMET) || - (op->type == SHIELD) || (op->type == RING) || - (op->type == BOOTS) || (op->type == GLOVES) || - (op->type == AMULET ) || (op->type == GIRDLE) || - (op->type == BRACERS ) || (op->type == CLOAK)) { - enc += op->stats.food; /* sustenance */ - enc += op->stats.hp; /* hp regen */ - enc += op->stats.sp; /* mana regen */ - enc += op->stats.grace; /* grace regen */ - enc += op->stats.exp; /* speed bonus */ - } - enc += op->stats.luck; - - /* Do spell paths now */ - for (i=1; ipath_attuned& (1 << i)) enc++; - else if (op->path_denied & (1 << i)) enc-=2; - else if (op->path_repelled & (1 << i)) enc--; - } - - if(QUERY_FLAG(op,FLAG_LIFESAVE)) enc += 5; - if(QUERY_FLAG(op,FLAG_REFL_SPELL)) enc += 3; - if(QUERY_FLAG(op,FLAG_REFL_MISSILE)) enc += 2; - if(QUERY_FLAG(op,FLAG_STEALTH)) enc += 1; - if(QUERY_FLAG(op,FLAG_XRAYS)) enc += 2; - if(QUERY_FLAG(op,FLAG_SEE_IN_DARK)) enc += 1; - if(QUERY_FLAG(op,FLAG_MAKE_INVIS)) enc += 1; + enc = 0; + for (i = 0; i < NUM_STATS; i++) + enc += get_attr_value (&op->stats, i); + + /* This protection logic is pretty flawed. 20% fire resistance + * is much more valuable than 20% confusion, or 20% slow, or + * several others. Start at 1 - ignore physical - all that normal + * armour shouldn't be counted against + */ + tmp = 0; + for (i = 1; i < NROFATTACKS; i++) + tmp += op->resist[i]; + + /* Add/substract 10 so that the rounding works out right */ + if (tmp > 0) + enc += (tmp + 10) / 20; + else if (tmp < 0) + enc += (tmp - 10) / 20; + + enc += op->magic; + + /* For each attacktype a weapon has, one more encantment. Start at 1 - + * physical doesn't count against total. + */ + if (op->type == WEAPON) + { + for (i = 1; i < NROFATTACKS; i++) + if (op->attacktype & (1 << i)) + enc++; + if (op->slaying) + enc += 2; /* What it slays is probably more relevent */ + } + /* Items the player can equip */ + if ((op->type == WEAPON) || (op->type == ARMOUR) || (op->type == HELMET) || + (op->type == SHIELD) || (op->type == RING) || + (op->type == BOOTS) || (op->type == GLOVES) || + (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK)) + { + enc += op->stats.food; /* sustenance */ + enc += op->stats.hp; /* hp regen */ + enc += op->stats.sp; /* mana regen */ + enc += op->stats.grace; /* grace regen */ + enc += op->stats.exp; /* speed bonus */ + } + enc += op->stats.luck; + + /* Do spell paths now */ + for (i = 1; i < NRSPELLPATHS; i++) + { + if (op->path_attuned & (1 << i)) + enc++; + else if (op->path_denied & (1 << i)) + enc -= 2; + else if (op->path_repelled & (1 << i)) + enc--; + } + + if (QUERY_FLAG (op, FLAG_LIFESAVE)) + enc += 5; + if (QUERY_FLAG (op, FLAG_REFL_SPELL)) + enc += 3; + if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) + enc += 2; + if (QUERY_FLAG (op, FLAG_STEALTH)) + enc += 1; + if (QUERY_FLAG (op, FLAG_XRAYS)) + enc += 2; + if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) + enc += 1; + if (QUERY_FLAG (op, FLAG_MAKE_INVIS)) + enc += 1; - return get_power_from_ench(enc); + return get_power_from_ench (enc); } /* returns the typedata that has a number equal to itemtype, if there * isn't one, returns NULL */ -const typedata *get_typedata(int itemtype) { - int i; - for (i=0;iresist[tmpvar] && (op->type != FLESH || atnr_is_dragon_enabled(tmpvar)==1)) { - if (!newline) - sprintf(buf1,"(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]); - else - sprintf(buf1,"%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]); + static char buf[VERY_BIG_BUF]; + char buf1[VERY_BIG_BUF]; + int tmpvar; + + buf[0] = 0; + for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++) + { + if (op->resist[tmpvar] && (op->type != FLESH || atnr_is_dragon_enabled (tmpvar) == 1)) + { + if (!newline) + sprintf (buf1, "(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]); + else + sprintf (buf1, "%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]); - strcat(buf, buf1); - } + strcat (buf, buf1); + } } - return buf; + return buf; } @@ -402,16 +418,18 @@ * The buffer will be overwritten by the next call to query_weight(). */ -char *query_weight(const object *op) { +char * +query_weight (const object *op) +{ static char buf[10]; - sint32 i=(op->nrof?op->nrof:1)*op->weight+op->carrying; + sint32 i = (op->nrof ? op->nrof : 1) * op->weight + op->carrying; - if(op->weight<0) + if (op->weight < 0) return " "; - if(i%1000) - sprintf(buf,"%6.1f",i/1000.0); + if (i % 1000) + sprintf (buf, "%6.1f", i / 1000.0); else - sprintf(buf,"%4d ",i/1000); + sprintf (buf, "%4d ", i / 1000); return buf; } @@ -420,18 +438,22 @@ * the number requested (of the form first, second, third...) */ -char *get_levelnumber(int i) { +char * +get_levelnumber (int i) +{ static char buf[MAX_BUF]; - if (i > 99) { - sprintf(buf, "%d.", i); - return buf; - } - if(i < 21) + + if (i > 99) + { + sprintf (buf, "%d.", i); + return buf; + } + if (i < 21) return levelnumbers[i]; - if(!(i%10)) - return levelnumbers_10[i/10]; - strcpy(buf, numbers_10[i/10]); - strcat(buf, levelnumbers[i%10]); + if (!(i % 10)) + return levelnumbers_10[i / 10]; + strcpy (buf, numbers_10[i / 10]); + strcat (buf, levelnumbers[i % 10]); return buf; } @@ -443,14 +465,18 @@ * It is currently only used by the query_name() function. */ -char *get_number(int i) { - if(i<=20) +char * +get_number (int i) +{ + if (i <= 20) return numbers[i]; - else { - static char buf[MAX_BUF]; - sprintf(buf,"%d",i); - return buf; - } + else + { + static char buf[MAX_BUF]; + + sprintf (buf, "%d", i); + return buf; + } } /* @@ -462,136 +488,150 @@ * Or make FULL_RING_DESCRIPTION standard part of a game and let * client handle names. */ + /* Aug 95 modified this slightly so that Skill tools don't have magic bonus * from stats.sp - b.t. */ -char *ring_desc (const object *op) +char * +ring_desc (const object *op) { - static char buf[VERY_BIG_BUF]; - int attr, val,len; - - buf[0] = 0; - - if (! QUERY_FLAG(op, FLAG_IDENTIFIED)) - return buf; - - for (attr=0; attrstats),attr))!=0) { - sprintf (buf+strlen(buf), "(%s%+d)", short_stat_name[attr], val); - } - } - if(op->stats.exp) - sprintf(buf+strlen(buf), "(speed %+lld)", (long long)op->stats.exp); - if(op->stats.wc) - sprintf(buf+strlen(buf), "(wc%+d)", op->stats.wc); - if(op->stats.dam) - sprintf(buf+strlen(buf), "(dam%+d)", op->stats.dam); - if(op->stats.ac) - sprintf(buf+strlen(buf), "(ac%+d)", op->stats.ac); - - strcat(buf,describe_resistance(op, 0)); - - if (op->stats.food != 0) - sprintf(buf+strlen(buf), "(sustenance%+d)", op->stats.food); - /* else if (op->stats.food < 0) - sprintf(buf+strlen(buf), "(hunger%+d)", op->stats.food); */ - if(op->stats.grace) - sprintf(buf+strlen(buf), "(grace%+d)", op->stats.grace); - if(op->stats.sp && op->type!=SKILL) - sprintf(buf+strlen(buf), "(magic%+d)", op->stats.sp); - if(op->stats.hp) - sprintf(buf+strlen(buf), "(regeneration%+d)", op->stats.hp); - if(op->stats.luck) - sprintf(buf+strlen(buf), "(luck%+d)", op->stats.luck); - if(QUERY_FLAG(op,FLAG_LIFESAVE)) - strcat(buf,"(lifesaving)"); - if(QUERY_FLAG(op,FLAG_REFL_SPELL)) - strcat(buf,"(reflect spells)"); - if(QUERY_FLAG(op,FLAG_REFL_MISSILE)) - strcat(buf,"(reflect missiles)"); - if(QUERY_FLAG(op,FLAG_STEALTH)) - strcat(buf,"(stealth)"); - /* Shorten some of the names, so they appear better in the windows */ - len=strlen(buf); - DESCRIBE_PATH_SAFE(buf, op->path_attuned, "Attuned", &len, VERY_BIG_BUF); - DESCRIBE_PATH_SAFE(buf, op->path_repelled, "Repelled", &len, VERY_BIG_BUF); - DESCRIBE_PATH_SAFE(buf, op->path_denied, "Denied", &len, VERY_BIG_BUF); - - /* if(op->item_power) - sprintf(buf+strlen(buf), "(item_power %+d)",op->item_power); - */ - if(buf[0] == 0 && op->type!=SKILL) - strcpy(buf,"of adornment"); + static char buf[VERY_BIG_BUF]; + int attr, val, len; + buf[0] = 0; + if (!QUERY_FLAG (op, FLAG_IDENTIFIED)) return buf; + + for (attr = 0; attr < NUM_STATS; attr++) + { + if ((val = get_attr_value (&(op->stats), attr)) != 0) + { + sprintf (buf + strlen (buf), "(%s%+d)", short_stat_name[attr], val); + } + } + if (op->stats.exp) + sprintf (buf + strlen (buf), "(speed %+lld)", (long long) op->stats.exp); + if (op->stats.wc) + sprintf (buf + strlen (buf), "(wc%+d)", op->stats.wc); + if (op->stats.dam) + sprintf (buf + strlen (buf), "(dam%+d)", op->stats.dam); + if (op->stats.ac) + sprintf (buf + strlen (buf), "(ac%+d)", op->stats.ac); + + strcat (buf, describe_resistance (op, 0)); + + if (op->stats.food != 0) + sprintf (buf + strlen (buf), "(sustenance%+d)", op->stats.food); + /* else if (op->stats.food < 0) + sprintf(buf+strlen(buf), "(hunger%+d)", op->stats.food); */ + if (op->stats.grace) + sprintf (buf + strlen (buf), "(grace%+d)", op->stats.grace); + if (op->stats.sp && op->type != SKILL) + sprintf (buf + strlen (buf), "(magic%+d)", op->stats.sp); + if (op->stats.hp) + sprintf (buf + strlen (buf), "(regeneration%+d)", op->stats.hp); + if (op->stats.luck) + sprintf (buf + strlen (buf), "(luck%+d)", op->stats.luck); + if (QUERY_FLAG (op, FLAG_LIFESAVE)) + strcat (buf, "(lifesaving)"); + if (QUERY_FLAG (op, FLAG_REFL_SPELL)) + strcat (buf, "(reflect spells)"); + if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) + strcat (buf, "(reflect missiles)"); + if (QUERY_FLAG (op, FLAG_STEALTH)) + strcat (buf, "(stealth)"); + /* Shorten some of the names, so they appear better in the windows */ + len = strlen (buf); + DESCRIBE_PATH_SAFE (buf, op->path_attuned, "Attuned", &len, VERY_BIG_BUF); + DESCRIBE_PATH_SAFE (buf, op->path_repelled, "Repelled", &len, VERY_BIG_BUF); + DESCRIBE_PATH_SAFE (buf, op->path_denied, "Denied", &len, VERY_BIG_BUF); + + /* if(op->item_power) + sprintf(buf+strlen(buf), "(item_power %+d)",op->item_power); + */ + if (buf[0] == 0 && op->type != SKILL) + strcpy (buf, "of adornment"); + + + return buf; } /* * query_short_name(object) is similar to query_name, but doesn't * contain any information about object status (worn/cursed/etc.) */ -const char *query_short_name(const object *op) +const char * +query_short_name (const object *op) { - static char buf[HUGE_BUF]; - char buf2[HUGE_BUF]; - int len=0; - - if(op->name == NULL) - return "(null)"; - if(!op->nrof && !op->weight && !op->title && !is_magical(op)) - return op->name; /* To speed things up (or make things slower?) */ - - if (op->nrof <= 1) - safe_strcat(buf,op->name, &len, HUGE_BUF); - else - safe_strcat(buf,op->name_pl, &len, HUGE_BUF); - - if (op->title && QUERY_FLAG(op,FLAG_IDENTIFIED)) { - safe_strcat(buf, " ", &len, HUGE_BUF); - safe_strcat(buf, op->title, &len, HUGE_BUF); + static char buf[HUGE_BUF]; + char buf2[HUGE_BUF]; + int len = 0; + + if (op->name == NULL) + return "(null)"; + + if (!op->nrof && !op->weight && !op->title && !is_magical (op)) + return op->name; /* To speed things up (or make things slower?) */ + + if (op->nrof <= 1) + safe_strcat (buf, op->name, &len, HUGE_BUF); + else + safe_strcat (buf, op->name_pl, &len, HUGE_BUF); + + if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) + { + safe_strcat (buf, " ", &len, HUGE_BUF); + safe_strcat (buf, op->title, &len, HUGE_BUF); } - switch(op->type) { + switch (op->type) + { case SPELLBOOK: case SCROLL: case WAND: case ROD: - if (QUERY_FLAG(op,FLAG_IDENTIFIED)||QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { - if(!op->title) { - safe_strcat(buf," of ", &len, HUGE_BUF); - if (op->inv) - safe_strcat(buf,op->inv->name, &len, HUGE_BUF); - else - LOG(llevError,"Spellbook %s lacks inventory\n", &op->name); + if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) + { + if (!op->title) + { + safe_strcat (buf, " of ", &len, HUGE_BUF); + if (op->inv) + safe_strcat (buf, op->inv->name, &len, HUGE_BUF); + else + LOG (llevError, "Spellbook %s lacks inventory\n", &op->name); } - if(op->type != SPELLBOOK) { - sprintf(buf2, " (lvl %d)", op->level); - safe_strcat(buf, buf2, &len, HUGE_BUF); + if (op->type != SPELLBOOK) + { + sprintf (buf2, " (lvl %d)", op->level); + safe_strcat (buf, buf2, &len, HUGE_BUF); } } - break; + break; - case SKILL: - case AMULET: - case RING: - if (!op->title) { - /* If ring has a title, full description isn't so useful */ - char *s = ring_desc(op); - if (s[0]) { - safe_strcat (buf, " ", &len, HUGE_BUF); - safe_strcat(buf, s, &len, HUGE_BUF); + case SKILL: + case AMULET: + case RING: + if (!op->title) + { + /* If ring has a title, full description isn't so useful */ + char *s = ring_desc (op); + + if (s[0]) + { + safe_strcat (buf, " ", &len, HUGE_BUF); + safe_strcat (buf, s, &len, HUGE_BUF); + } + } + break; + default: + if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) + { + sprintf (buf2, " %+d", op->magic); + safe_strcat (buf, buf2, &len, HUGE_BUF); } - } - break; - default: - if(op->magic && ((QUERY_FLAG(op,FLAG_BEEN_APPLIED) && - need_identify(op)) || QUERY_FLAG(op,FLAG_IDENTIFIED))) { - sprintf(buf2, " %+d", op->magic); - safe_strcat(buf, buf2, &len, HUGE_BUF); - } } - return buf; + return buf; } /* @@ -605,98 +645,104 @@ * use several names much easier (don't need to store them to temp variables.) * */ -char *query_name(const object *op) { - static char buf[5][HUGE_BUF]; - static int use_buf=0; - int len=0; +char * +query_name (const object *op) +{ + static char buf[5][HUGE_BUF]; + static int use_buf = 0; + int len = 0; + #ifdef NEW_MATERIAL_CODE - materialtype_t *mt; + materialtype_t *mt; #endif - use_buf++; - use_buf %=5; + use_buf++; + use_buf %= 5; #ifdef NEW_MATERIAL_CODE - if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname) { - mt = name_to_material(op->materialname); - if (mt) { - safe_strcat(buf[use_buf], mt->description, &len, HUGE_BUF); - safe_strcat(buf[use_buf], " ", &len, HUGE_BUF); + if ((op->is_armor () || op->is_weapon ()) && op->materialname) + { + mt = name_to_material (op->materialname); + if (mt) + { + safe_strcat (buf[use_buf], mt->description, &len, HUGE_BUF); + safe_strcat (buf[use_buf], " ", &len, HUGE_BUF); } } #endif - safe_strcat(buf[use_buf], query_short_name(op), &len, HUGE_BUF); + safe_strcat (buf[use_buf], query_short_name (op), &len, HUGE_BUF); - if (QUERY_FLAG(op,FLAG_INV_LOCKED)) - safe_strcat(buf[use_buf], " *", &len, HUGE_BUF); - if (op->type == CONTAINER && ((op->env && op->env->container == op) || - (!op->env && QUERY_FLAG(op,FLAG_APPLIED)))) - safe_strcat(buf[use_buf]," (open)", &len, HUGE_BUF); - - if (QUERY_FLAG(op,FLAG_KNOWN_CURSED)) { - if(QUERY_FLAG(op,FLAG_DAMNED)) - safe_strcat(buf[use_buf], " (damned)", &len, HUGE_BUF); - else if(QUERY_FLAG(op,FLAG_CURSED)) - safe_strcat(buf[use_buf], " (cursed)", &len, HUGE_BUF); - } - /* Basically, if the object is known magical (detect magic spell on it), - * and it isn't identified, print out the fact that - * it is magical. Assume that the detect magical spell will only set - * KNOWN_MAGICAL if the item actually is magical. - * - * Changed in V 0.91.4 - still print that the object is magical even - * if it has been applied. Equipping an item does not tell full - * abilities, especially for artifact items. - */ - if (QUERY_FLAG(op,FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op,FLAG_IDENTIFIED)) - safe_strcat(buf[use_buf], " (magic)", &len, HUGE_BUF); + if (QUERY_FLAG (op, FLAG_INV_LOCKED)) + safe_strcat (buf[use_buf], " *", &len, HUGE_BUF); + if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED)))) + safe_strcat (buf[use_buf], " (open)", &len, HUGE_BUF); + + if (QUERY_FLAG (op, FLAG_KNOWN_CURSED)) + { + if (QUERY_FLAG (op, FLAG_DAMNED)) + safe_strcat (buf[use_buf], " (damned)", &len, HUGE_BUF); + else if (QUERY_FLAG (op, FLAG_CURSED)) + safe_strcat (buf[use_buf], " (cursed)", &len, HUGE_BUF); + } + /* Basically, if the object is known magical (detect magic spell on it), + * and it isn't identified, print out the fact that + * it is magical. Assume that the detect magical spell will only set + * KNOWN_MAGICAL if the item actually is magical. + * + * Changed in V 0.91.4 - still print that the object is magical even + * if it has been applied. Equipping an item does not tell full + * abilities, especially for artifact items. + */ + if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED)) + safe_strcat (buf[use_buf], " (magic)", &len, HUGE_BUF); #if 0 - /* item_power will be returned in desribe_item - it shouldn't really - * be returned in the name. - */ - if(op->item_power) - sprintf(buf[use_buf]+strlen(buf[use_buf]), "(item_power %+d)", - op->item_power); + /* item_power will be returned in desribe_item - it shouldn't really + * be returned in the name. + */ + if (op->item_power) + sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power); #endif - if (QUERY_FLAG(op,FLAG_APPLIED)) { - switch(op->type) { - case BOW: - case WAND: - case ROD: - case HORN: - safe_strcat(buf[use_buf]," (readied)", &len, HUGE_BUF); - break; - case WEAPON: - safe_strcat(buf[use_buf]," (wielded)", &len, HUGE_BUF); - break; - case ARMOUR: - case HELMET: - case SHIELD: - case RING: - case BOOTS: - case GLOVES: - case AMULET: - case GIRDLE: - case BRACERS: - case CLOAK: - safe_strcat(buf[use_buf]," (worn)", &len, HUGE_BUF); - break; - case CONTAINER: - safe_strcat(buf[use_buf]," (active)", &len, HUGE_BUF); - break; - case SKILL: - default: - safe_strcat(buf[use_buf]," (applied)", &len, HUGE_BUF); + if (QUERY_FLAG (op, FLAG_APPLIED)) + { + switch (op->type) + { + case BOW: + case WAND: + case ROD: + case HORN: + safe_strcat (buf[use_buf], " (readied)", &len, HUGE_BUF); + break; + case WEAPON: + safe_strcat (buf[use_buf], " (wielded)", &len, HUGE_BUF); + break; + case ARMOUR: + case HELMET: + case SHIELD: + case RING: + case BOOTS: + case GLOVES: + case AMULET: + case GIRDLE: + case BRACERS: + case CLOAK: + safe_strcat (buf[use_buf], " (worn)", &len, HUGE_BUF); + break; + case CONTAINER: + safe_strcat (buf[use_buf], " (active)", &len, HUGE_BUF); + break; + case SKILL: + default: + safe_strcat (buf[use_buf], " (applied)", &len, HUGE_BUF); } } - if(QUERY_FLAG(op, FLAG_UNPAID)) - safe_strcat(buf[use_buf]," (unpaid)", &len, HUGE_BUF); + if (QUERY_FLAG (op, FLAG_UNPAID)) + safe_strcat (buf[use_buf], " (unpaid)", &len, HUGE_BUF); - return buf[use_buf]; + return buf[use_buf]; } /* @@ -708,87 +754,99 @@ * and sending to client. * If plural is set, we generate the plural name of this. */ -const char *query_base_name(const object *op, int plural) { - static char buf[MAX_BUF], buf2[MAX_BUF]; - int len; - materialtype_t *mt; +const char * +query_base_name (const object *op, int plural) +{ + static char buf[MAX_BUF], buf2[MAX_BUF]; + int len; + materialtype_t *mt; - if((!plural && !op->name) || (plural && !op->name_pl)) - return "(null)"; + if ((!plural && !op->name) || (plural && !op->name_pl)) + return "(null)"; - if(!op->nrof && !op->weight && !op->title && !is_magical(op)) - return op->name; /* To speed things up (or make things slower?) */ + if (!op->nrof && !op->weight && !op->title && !is_magical (op)) + return op->name; /* To speed things up (or make things slower?) */ - if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname) - mt = name_to_material(op->materialname); + if ((op->is_armor () || op->is_weapon ()) && op->materialname) + mt = name_to_material (op->materialname); #ifdef NEW_MATERIAL_CODE - if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname && mt && - op->arch->clone.materialname != mt->name && - !(op->material & M_SPECIAL)) { - strcpy(buf, mt->description); - len=strlen(buf); - safe_strcat(buf, " ", &len, MAX_BUF); - if (!plural) - safe_strcat(buf, op->name, &len, MAX_BUF); - else - safe_strcat(buf, op->name_pl, &len, MAX_BUF); - } else { + if ((op->is_armor () || op->is_weapon ()) && op->materialname && mt && + op->arch->clone.materialname != mt->name && !(op->material & M_SPECIAL)) + { + strcpy (buf, mt->description); + len = strlen (buf); + safe_strcat (buf, " ", &len, MAX_BUF); + if (!plural) + safe_strcat (buf, op->name, &len, MAX_BUF); + else + safe_strcat (buf, op->name_pl, &len, MAX_BUF); + } + else + { #endif - if (!plural) - strcpy(buf, op->name); - else - strcpy(buf, op->name_pl); - len=strlen(buf); + if (!plural) + strcpy (buf, op->name); + else + strcpy (buf, op->name_pl); + len = strlen (buf); #ifdef NEW_MATERIAL_CODE } #endif - if (op->title && QUERY_FLAG(op,FLAG_IDENTIFIED)) { - safe_strcat(buf, " ", &len, MAX_BUF); - safe_strcat(buf, op->title, &len, MAX_BUF); + if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) + { + safe_strcat (buf, " ", &len, MAX_BUF); + safe_strcat (buf, op->title, &len, MAX_BUF); } - switch(op->type) { + switch (op->type) + { case SPELLBOOK: case SCROLL: case WAND: case ROD: - if (QUERY_FLAG(op,FLAG_IDENTIFIED)||QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { - if(!op->title) { - safe_strcat(buf," of ", &len, MAX_BUF); - if (op->inv) - safe_strcat(buf,op->inv->name, &len, MAX_BUF); - else - LOG(llevError,"Spellbook %s lacks inventory\n", &op->name); + if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) + { + if (!op->title) + { + safe_strcat (buf, " of ", &len, MAX_BUF); + if (op->inv) + safe_strcat (buf, op->inv->name, &len, MAX_BUF); + else + LOG (llevError, "Spellbook %s lacks inventory\n", &op->name); } - if(op->type != SPELLBOOK) { - sprintf(buf2, " (lvl %d)", op->level); - safe_strcat(buf, buf2, &len, MAX_BUF); + if (op->type != SPELLBOOK) + { + sprintf (buf2, " (lvl %d)", op->level); + safe_strcat (buf, buf2, &len, MAX_BUF); } } - break; + break; - case SKILL: - case AMULET: - case RING: - if (!op->title) { - /* If ring has a title, full description isn't so useful */ - char *s = ring_desc(op); - if (s[0]) { - safe_strcat (buf, " ", &len, MAX_BUF); - safe_strcat (buf, s, &len, MAX_BUF); + case SKILL: + case AMULET: + case RING: + if (!op->title) + { + /* If ring has a title, full description isn't so useful */ + char *s = ring_desc (op); + + if (s[0]) + { + safe_strcat (buf, " ", &len, MAX_BUF); + safe_strcat (buf, s, &len, MAX_BUF); + } + } + break; + default: + if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) + { + sprintf (buf + strlen (buf), " %+d", op->magic); } - } - break; - default: - if(op->magic && ((QUERY_FLAG(op,FLAG_BEEN_APPLIED) && - need_identify(op)) || QUERY_FLAG(op,FLAG_IDENTIFIED))) { - sprintf(buf + strlen(buf), " %+d", op->magic); - } } - return buf; + return buf; } /* Break this off from describe_item - that function was way @@ -798,143 +856,165 @@ * in a static buffer. */ -static char *describe_monster(const object *op) { - char buf[MAX_BUF]; - static char retbuf[VERY_BIG_BUF]; - int i; - - retbuf[0]='\0'; - - /* Note that the resolution this provides for players really isn't - * very good. Any player with a speed greater than .67 will - * fall into the 'lightning fast movement' category. - */ - if(FABS(op->speed)>MIN_ACTIVE_SPEED) { - switch((int)((FABS(op->speed))*15)) { +static char * +describe_monster (const object *op) +{ + char buf[MAX_BUF]; + static char retbuf[VERY_BIG_BUF]; + int i; + + retbuf[0] = '\0'; + + /* Note that the resolution this provides for players really isn't + * very good. Any player with a speed greater than .67 will + * fall into the 'lightning fast movement' category. + */ + if (op->has_active_speed ()) + { + switch ((int) ((FABS (op->speed)) * 15)) + { case 0: - strcat(retbuf,"(very slow movement)"); - break; + strcat (retbuf, "(very slow movement)"); + break; case 1: - strcat(retbuf,"(slow movement)"); - break; + strcat (retbuf, "(slow movement)"); + break; case 2: - strcat(retbuf,"(normal movement)"); - break; + strcat (retbuf, "(normal movement)"); + break; case 3: case 4: - strcat(retbuf,"(fast movement)"); - break; + strcat (retbuf, "(fast movement)"); + break; case 5: case 6: - strcat(retbuf,"(very fast movement)"); - break; + strcat (retbuf, "(very fast movement)"); + break; case 7: case 8: case 9: case 10: - strcat(retbuf,"(extremely fast movement)"); - break; + strcat (retbuf, "(extremely fast movement)"); + break; default: - strcat(retbuf,"(lightning fast movement)"); - break; + strcat (retbuf, "(lightning fast movement)"); + break; } } - if(QUERY_FLAG(op,FLAG_UNDEAD)) - strcat(retbuf,"(undead)"); - if(QUERY_FLAG(op,FLAG_SEE_INVISIBLE)) - strcat(retbuf,"(see invisible)"); - if(QUERY_FLAG(op,FLAG_USE_WEAPON)) - strcat(retbuf,"(wield weapon)"); - if(QUERY_FLAG(op,FLAG_USE_BOW)) - strcat(retbuf,"(archer)"); - if(QUERY_FLAG(op,FLAG_USE_ARMOUR)) - strcat(retbuf,"(wear armour)"); - if(QUERY_FLAG(op,FLAG_USE_RING)) - strcat(retbuf,"(wear ring)"); - if(QUERY_FLAG(op,FLAG_USE_SCROLL)) - strcat(retbuf,"(read scroll)"); - if(QUERY_FLAG(op,FLAG_USE_RANGE)) - strcat(retbuf,"(fires wand/rod/horn)"); - if(QUERY_FLAG(op,FLAG_CAN_USE_SKILL)) - strcat(retbuf,"(skill user)"); - if(QUERY_FLAG(op,FLAG_CAST_SPELL)) - strcat(retbuf,"(spellcaster)"); - if(QUERY_FLAG(op,FLAG_FRIENDLY)) - strcat(retbuf,"(friendly)"); - if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE)) - strcat(retbuf,"(unaggressive)"); - if(QUERY_FLAG(op,FLAG_HITBACK)) - strcat(retbuf,"(hitback)"); - if(QUERY_FLAG(op,FLAG_STEALTH)) - strcat(retbuf,"(stealthy)"); - if(op->randomitems != NULL) { - treasure *t; - int first = 1; - for(t=op->randomitems->items; t != NULL; t=t->next) - if(t->item && (t->item->clone.type == SPELL)) { - if(first) { - first = 0; - strcat(retbuf,"(Spell abilities:)"); - } - strcat(retbuf,"("); - strcat(retbuf,t->item->clone.name); - strcat(retbuf,")"); - } - } - if (op->type == PLAYER) { - if(op->contr->digestion) { - if(op->contr->digestion!=0) - sprintf(buf,"(sustenance%+d)",op->contr->digestion); - strcat(retbuf,buf); - } - if(op->contr->gen_grace) { - sprintf(buf,"(grace%+d)",op->contr->gen_grace); - strcat(retbuf,buf); - } - if(op->contr->gen_sp) { - sprintf(buf,"(magic%+d)",op->contr->gen_sp); - strcat(retbuf,buf); - } - if(op->contr->gen_hp) { - sprintf(buf,"(regeneration%+d)",op->contr->gen_hp); - strcat(retbuf,buf); - } - if(op->stats.luck) { - sprintf(buf,"(luck%+d)",op->stats.luck); - strcat(retbuf,buf); + if (QUERY_FLAG (op, FLAG_UNDEAD)) + strcat (retbuf, "(undead)"); + if (QUERY_FLAG (op, FLAG_SEE_INVISIBLE)) + strcat (retbuf, "(see invisible)"); + if (QUERY_FLAG (op, FLAG_USE_WEAPON)) + strcat (retbuf, "(wield weapon)"); + if (QUERY_FLAG (op, FLAG_USE_BOW)) + strcat (retbuf, "(archer)"); + if (QUERY_FLAG (op, FLAG_USE_ARMOUR)) + strcat (retbuf, "(wear armour)"); + if (QUERY_FLAG (op, FLAG_USE_RING)) + strcat (retbuf, "(wear ring)"); + if (QUERY_FLAG (op, FLAG_USE_SCROLL)) + strcat (retbuf, "(read scroll)"); + if (QUERY_FLAG (op, FLAG_USE_RANGE)) + strcat (retbuf, "(fires wand/rod/horn)"); + if (QUERY_FLAG (op, FLAG_CAN_USE_SKILL)) + strcat (retbuf, "(skill user)"); + if (QUERY_FLAG (op, FLAG_CAST_SPELL)) + strcat (retbuf, "(spellcaster)"); + if (QUERY_FLAG (op, FLAG_FRIENDLY)) + strcat (retbuf, "(friendly)"); + if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE)) + strcat (retbuf, "(unaggressive)"); + if (QUERY_FLAG (op, FLAG_HITBACK)) + strcat (retbuf, "(hitback)"); + if (QUERY_FLAG (op, FLAG_STEALTH)) + strcat (retbuf, "(stealthy)"); + if (op->randomitems != NULL) + { + treasure *t; + int first = 1; + + for (t = op->randomitems->items; t != NULL; t = t->next) + if (t->item && (t->item->clone.type == SPELL)) + { + if (first) + { + first = 0; + strcat (retbuf, "(Spell abilities:)"); + } + strcat (retbuf, "("); + strcat (retbuf, t->item->clone.name); + strcat (retbuf, ")"); + } + } + if (op->type == PLAYER) + { + if (op->contr->digestion) + { + if (op->contr->digestion != 0) + sprintf (buf, "(sustenance%+d)", op->contr->digestion); + strcat (retbuf, buf); + } + if (op->contr->gen_grace) + { + sprintf (buf, "(grace%+d)", op->contr->gen_grace); + strcat (retbuf, buf); + } + if (op->contr->gen_sp) + { + sprintf (buf, "(magic%+d)", op->contr->gen_sp); + strcat (retbuf, buf); + } + if (op->contr->gen_hp) + { + sprintf (buf, "(regeneration%+d)", op->contr->gen_hp); + strcat (retbuf, buf); + } + if (op->stats.luck) + { + sprintf (buf, "(luck%+d)", op->stats.luck); + strcat (retbuf, buf); } } - /* describe attacktypes */ - if (is_dragon_pl(op)) { - /* for dragon players display the attacktypes from clawing skill - * Break apart the for loop - move the comparison checking down - - * this makes it more readable. - */ - object *tmp; - - for (tmp=op->inv; tmp!=NULL; tmp=tmp->below) - if (tmp->type == SKILL && !strcmp(tmp->name, "clawing")) break; - - if (tmp && tmp->attacktype!=0) { - DESCRIBE_ABILITY(retbuf, tmp->attacktype, "Claws"); - } - else { - DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks"); - } - } else { - DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks"); - } - DESCRIBE_PATH(retbuf, op->path_attuned, "Attuned"); - DESCRIBE_PATH(retbuf, op->path_repelled, "Repelled"); - DESCRIBE_PATH(retbuf, op->path_denied, "Denied"); - for (i=0; i < NROFATTACKS; i++) { - if (op->resist[i]) { - sprintf(buf, "(%s %+d)", resist_plus[i], op->resist[i]); - strcat(retbuf, buf); + /* describe attacktypes */ + if (is_dragon_pl (op)) + { + /* for dragon players display the attacktypes from clawing skill + * Break apart the for loop - move the comparison checking down - + * this makes it more readable. + */ + object *tmp; + + for (tmp = op->inv; tmp != NULL; tmp = tmp->below) + if (tmp->type == SKILL && !strcmp (tmp->name, "clawing")) + break; + + if (tmp && tmp->attacktype != 0) + { + DESCRIBE_ABILITY (retbuf, tmp->attacktype, "Claws"); + } + else + { + DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks"); + } + } + else + { + DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks"); + } + DESCRIBE_PATH (retbuf, op->path_attuned, "Attuned"); + DESCRIBE_PATH (retbuf, op->path_repelled, "Repelled"); + DESCRIBE_PATH (retbuf, op->path_denied, "Denied"); + for (i = 0; i < NROFATTACKS; i++) + { + if (op->resist[i]) + { + sprintf (buf, "(%s %+d)", resist_plus[i], op->resist[i]); + strcat (retbuf, buf); } } - return retbuf; + return retbuf; } @@ -965,24 +1045,30 @@ * item (eg, debug dump or the like) */ -char *describe_item(const object *op, object *owner) { - char buf[MAX_BUF]; - static char retbuf[VERY_BIG_BUF]; - int identified,i; - - retbuf[0]='\0'; - if(QUERY_FLAG(op,FLAG_MONSTER) || op->type==PLAYER) { - return describe_monster(op); - } - /* figure this out once, instead of making multiple calls to need_identify. - * also makes the code easier to read. - */ - if (!need_identify(op) || QUERY_FLAG(op, FLAG_IDENTIFIED)) identified = 1; - else { - strcpy(retbuf,"(unidentified)"); - identified = 0; +char * +describe_item (const object *op, object *owner) +{ + char buf[MAX_BUF]; + static char retbuf[VERY_BIG_BUF]; + int identified, i; + + retbuf[0] = '\0'; + if (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) + { + return describe_monster (op); + } + /* figure this out once, instead of making multiple calls to need_identify. + * also makes the code easier to read. + */ + if (!need_identify (op) || QUERY_FLAG (op, FLAG_IDENTIFIED)) + identified = 1; + else + { + strcpy (retbuf, "(unidentified)"); + identified = 0; } - switch(op->type) { + switch (op->type) + { case BOW: case ARROW: case WAND: @@ -998,97 +1084,109 @@ case BRACERS: case CLOAK: case SKILL_TOOL: - break; /* We have more information to do below this switch */ + break; /* We have more information to do below this switch */ case POWER_CRYSTAL: - if (op->stats.maxsp>1000){ /*higher capacity crystals*/ - i = (op->stats.maxsp%100)/10; - if (i) - snprintf(buf,MAX_BUF,"(capacity %d.%dk). It is ",op->stats.maxsp/100,i); - else - snprintf(buf,MAX_BUF,"(capacity %dk). It is ",op->stats.maxsp/100); - }else - snprintf(buf,MAX_BUF,"(capacity %d). It is ",op->stats.maxsp); - strcat(retbuf,buf); - i = (op->stats.sp*10)/op->stats.maxsp; - if (op->stats.sp==0) - strcat(retbuf,"empty."); - else if (i==0) - strcat(retbuf,"almost empty."); - else if (i<3) - strcat(retbuf,"partially filled."); - else if (i<6) - strcat(retbuf,"half full."); - else if (i<9) - strcat(retbuf,"well charged."); - else if (op->stats.sp == op->stats.maxsp) - strcat(retbuf,"fully charged."); - else - strcat(retbuf,"almost full."); - break; + if (op->stats.maxsp > 1000) + { /*higher capacity crystals */ + i = (op->stats.maxsp % 100) / 10; + if (i) + snprintf (buf, MAX_BUF, "(capacity %d.%dk). It is ", op->stats.maxsp / 100, i); + else + snprintf (buf, MAX_BUF, "(capacity %dk). It is ", op->stats.maxsp / 100); + } + else + snprintf (buf, MAX_BUF, "(capacity %d). It is ", op->stats.maxsp); + strcat (retbuf, buf); + i = (op->stats.sp * 10) / op->stats.maxsp; + if (op->stats.sp == 0) + strcat (retbuf, "empty."); + else if (i == 0) + strcat (retbuf, "almost empty."); + else if (i < 3) + strcat (retbuf, "partially filled."); + else if (i < 6) + strcat (retbuf, "half full."); + else if (i < 9) + strcat (retbuf, "well charged."); + else if (op->stats.sp == op->stats.maxsp) + strcat (retbuf, "fully charged."); + else + strcat (retbuf, "almost full."); + break; case FOOD: case FLESH: case DRINK: - if(identified || QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { - sprintf(buf,"(food+%d)", op->stats.food); - strcat(retbuf, buf); - - if (op->type == FLESH && op->last_eat>0 && atnr_is_dragon_enabled(op->last_eat)) { - sprintf(buf, "(%s metabolism)", change_resist_msg[op->last_eat]); - strcat(retbuf, buf); + if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) + { + sprintf (buf, "(food+%d)", op->stats.food); + strcat (retbuf, buf); + + if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled (op->last_eat)) + { + sprintf (buf, "(%s metabolism)", change_resist_msg[op->last_eat]); + strcat (retbuf, buf); } - - if (!QUERY_FLAG(op,FLAG_CURSED)) { - if (op->stats.hp) - strcat(retbuf,"(heals)"); - if (op->stats.sp) - strcat(retbuf,"(spellpoint regen)"); + + if (!QUERY_FLAG (op, FLAG_CURSED)) + { + if (op->stats.hp) + strcat (retbuf, "(heals)"); + if (op->stats.sp) + strcat (retbuf, "(spellpoint regen)"); } - else { - if (op->stats.hp) - strcat(retbuf,"(damages)"); - if (op->stats.sp) - strcat(retbuf,"(spellpoint depletion)"); + else + { + if (op->stats.hp) + strcat (retbuf, "(damages)"); + if (op->stats.sp) + strcat (retbuf, "(spellpoint depletion)"); } } - break; + break; case SKILL: case RING: case AMULET: - if(op->item_power) { - sprintf(buf,"(item_power %+d)",op->item_power); - strcat(retbuf,buf); + if (op->item_power) + { + sprintf (buf, "(item_power %+d)", op->item_power); + strcat (retbuf, buf); } - if (op->title) - strcat (retbuf, ring_desc(op)); - return retbuf; + if (op->title) + strcat (retbuf, ring_desc (op)); + return retbuf; default: - return retbuf; + return retbuf; } - /* Down here, we more further describe equipment type items. - * only describe them if they have been identified or the like. - */ - if (identified || QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { - int attr,val; - - for (attr=0; attrstats),attr))!=0) { - sprintf(buf, "(%s%+d)", short_stat_name[attr], val); - strcat(retbuf,buf); + /* Down here, we more further describe equipment type items. + * only describe them if they have been identified or the like. + */ + if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) + { + int attr, val; + + for (attr = 0; attr < NUM_STATS; attr++) + { + if ((val = get_attr_value (&(op->stats), attr)) != 0) + { + sprintf (buf, "(%s%+d)", short_stat_name[attr], val); + strcat (retbuf, buf); } } - if(op->stats.exp) { - sprintf(buf,"(speed %+lld)", (long long)op->stats.exp); - strcat(retbuf,buf); + if (op->stats.exp) + { + sprintf (buf, "(speed %+lld)", (long long) op->stats.exp); + strcat (retbuf, buf); } - switch(op->type) { + switch (op->type) + { case BOW: case ARROW: case GIRDLE: @@ -1104,70 +1202,77 @@ case BRACERS: case FORCE: case CLOAK: - if(op->stats.wc) { - sprintf(buf,"(wc%+d)",op->stats.wc); - strcat(retbuf,buf); + if (op->stats.wc) + { + sprintf (buf, "(wc%+d)", op->stats.wc); + strcat (retbuf, buf); } - if(op->stats.dam) { - sprintf(buf,"(dam%+d)",op->stats.dam); - strcat(retbuf,buf); + if (op->stats.dam) + { + sprintf (buf, "(dam%+d)", op->stats.dam); + strcat (retbuf, buf); } - if(op->stats.ac) { - sprintf(buf,"(ac%+d)",op->stats.ac); - strcat(retbuf,buf); + if (op->stats.ac) + { + sprintf (buf, "(ac%+d)", op->stats.ac); + strcat (retbuf, buf); } - if ((op->type==WEAPON || op->type == BOW) && op->level>0) { - sprintf(buf,"(improved %d/%d)",op->last_eat,op->level); - strcat(retbuf,buf); + if ((op->type == WEAPON || op->type == BOW) && op->level > 0) + { + sprintf (buf, "(improved %d/%d)", op->last_eat, op->level); + strcat (retbuf, buf); } - break; - - default: - break; - } - if(QUERY_FLAG(op,FLAG_XRAYS)) - strcat(retbuf,"(xray-vision)"); - if(QUERY_FLAG(op,FLAG_SEE_IN_DARK)) - strcat(retbuf,"(infravision)"); - - /* levitate was what is was before, so we'll keep it */ - if (op->move_type & MOVE_FLY_LOW) - strcat(retbuf,"(levitate)"); + break; - if (op->move_type & MOVE_FLY_HIGH) - strcat(retbuf,"(fly)"); - - if (op->move_type & MOVE_SWIM) - strcat(retbuf,"(swim)"); - - /* walking is presumed as 'normal', so doesn't need mentioning */ - - if(op->item_power) { - sprintf(buf,"(item_power %+d)",op->item_power); - strcat(retbuf,buf); + default: + break; } - } /* End if identified or applied */ - - /* This blocks only deals with fully identified object. - * it is intentional that this is not an 'else' from a above - - * in this way, information is added. - */ - if(identified) { - int more_info = 0; - - switch(op->type) { - case ROD: /* These use stats.sp for spell selection and stats.food */ - case HORN: /* and stats.hp for spell-point regeneration... */ + if (QUERY_FLAG (op, FLAG_XRAYS)) + strcat (retbuf, "(xray-vision)"); + if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) + strcat (retbuf, "(infravision)"); + + /* levitate was what is was before, so we'll keep it */ + if (op->move_type & MOVE_FLY_LOW) + strcat (retbuf, "(levitate)"); + + if (op->move_type & MOVE_FLY_HIGH) + strcat (retbuf, "(fly)"); + + if (op->move_type & MOVE_SWIM) + strcat (retbuf, "(swim)"); + + /* walking is presumed as 'normal', so doesn't need mentioning */ + + if (op->item_power) + { + sprintf (buf, "(item_power %+d)", op->item_power); + strcat (retbuf, buf); + } + } /* End if identified or applied */ + + /* This blocks only deals with fully identified object. + * it is intentional that this is not an 'else' from a above - + * in this way, information is added. + */ + if (identified) + { + int more_info = 0; + + switch (op->type) + { + case ROD: /* These use stats.sp for spell selection and stats.food */ + case HORN: /* and stats.hp for spell-point regeneration... */ case BOW: case ARROW: case WAND: case FOOD: case FLESH: case DRINK: - more_info = 0; - break; + more_info = 0; + break; - /* Armor type objects */ + /* Armor type objects */ case ARMOUR: case HELMET: case SHIELD: @@ -1176,78 +1281,88 @@ case GIRDLE: case BRACERS: case CLOAK: - if (ARMOUR_SPEED(op)) { - sprintf(buf,"(Max speed %1.2f)", ARMOUR_SPEED(op) / 10.0); - strcat(retbuf, buf); + if (ARMOUR_SPEED (op)) + { + sprintf (buf, "(Max speed %1.2f)", ARMOUR_SPEED (op) / 10.0); + strcat (retbuf, buf); } - if (ARMOUR_SPELLS(op)) { - sprintf(buf,"(Spell regen penalty %d)", ARMOUR_SPELLS(op)); - strcat(retbuf, buf); + if (ARMOUR_SPELLS (op)) + { + sprintf (buf, "(Spell regen penalty %d)", ARMOUR_SPELLS (op)); + strcat (retbuf, buf); } - more_info=1; - break; + more_info = 1; + break; case WEAPON: - /* Calculate it the same way fix_player does so the results - * make sense. - */ - i = (WEAPON_SPEED(op)*2-op->magic)/2; - if (i<0) i=0; - - sprintf(buf,"(weapon speed %d)", i); - strcat(retbuf, buf); - more_info=1; - break; - - } - if (more_info) { - if(op->stats.food) { - if(op->stats.food!=0) - sprintf(buf,"(sustenance%+d)",op->stats.food); - strcat(retbuf,buf); + /* Calculate it the same way fix_player does so the results + * make sense. + */ + i = (WEAPON_SPEED (op) * 2 - op->magic) / 2; + if (i < 0) + i = 0; + + sprintf (buf, "(weapon speed %d)", i); + strcat (retbuf, buf); + more_info = 1; + break; + + } + if (more_info) + { + if (op->stats.food) + { + if (op->stats.food != 0) + sprintf (buf, "(sustenance%+d)", op->stats.food); + strcat (retbuf, buf); } - if(op->stats.grace) { - sprintf(buf,"(grace%+d)",op->stats.grace); - strcat(retbuf,buf); + if (op->stats.grace) + { + sprintf (buf, "(grace%+d)", op->stats.grace); + strcat (retbuf, buf); } - if(op->stats.sp) { - sprintf(buf,"(magic%+d)",op->stats.sp); - strcat(retbuf,buf); + if (op->stats.sp) + { + sprintf (buf, "(magic%+d)", op->stats.sp); + strcat (retbuf, buf); } - if(op->stats.hp) { - sprintf(buf,"(regeneration%+d)",op->stats.hp); - strcat(retbuf,buf); + if (op->stats.hp) + { + sprintf (buf, "(regeneration%+d)", op->stats.hp); + strcat (retbuf, buf); } } - if(op->stats.luck) { - sprintf(buf,"(luck%+d)",op->stats.luck); - strcat(retbuf,buf); - } - if(QUERY_FLAG(op,FLAG_LIFESAVE)) - strcat(retbuf,"(lifesaving)"); - if(QUERY_FLAG(op,FLAG_REFL_SPELL)) - strcat(retbuf,"(reflect spells)"); - if(QUERY_FLAG(op,FLAG_REFL_MISSILE)) - strcat(retbuf,"(reflect missiles)"); - if(QUERY_FLAG(op,FLAG_STEALTH)) - strcat(retbuf,"(stealth)"); - if(op->slaying!=NULL && op->type != FOOD) { - sprintf(buf,"(slay %s)", &op->slaying); - strcat(retbuf,buf); - } - DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks"); - /* resistance on flesh is only visible for quetzals. If - * non flesh, everyone can see its resistances - */ - if (op->type != FLESH || (owner && is_dragon_pl(owner))) - strcat(retbuf,describe_resistance(op, 0)); - DESCRIBE_PATH(retbuf, op->path_attuned, "Attuned"); - DESCRIBE_PATH(retbuf, op->path_repelled, "Repelled"); - DESCRIBE_PATH(retbuf, op->path_denied, "Denied"); + if (op->stats.luck) + { + sprintf (buf, "(luck%+d)", op->stats.luck); + strcat (retbuf, buf); + } + if (QUERY_FLAG (op, FLAG_LIFESAVE)) + strcat (retbuf, "(lifesaving)"); + if (QUERY_FLAG (op, FLAG_REFL_SPELL)) + strcat (retbuf, "(reflect spells)"); + if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) + strcat (retbuf, "(reflect missiles)"); + if (QUERY_FLAG (op, FLAG_STEALTH)) + strcat (retbuf, "(stealth)"); + if (op->slaying != NULL && op->type != FOOD) + { + sprintf (buf, "(slay %s)", &op->slaying); + strcat (retbuf, buf); + } + DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks"); + /* resistance on flesh is only visible for quetzals. If + * non flesh, everyone can see its resistances + */ + if (op->type != FLESH || (owner && is_dragon_pl (owner))) + strcat (retbuf, describe_resistance (op, 0)); + DESCRIBE_PATH (retbuf, op->path_attuned, "Attuned"); + DESCRIBE_PATH (retbuf, op->path_repelled, "Repelled"); + DESCRIBE_PATH (retbuf, op->path_denied, "Denied"); } - return retbuf; + return retbuf; } /* Return true if the item is magical. A magical item is one that @@ -1257,70 +1372,73 @@ * should be marked as magical. */ -int is_magical(const object *op) { - int i; - - /* living creatures are considered non magical */ - if (QUERY_FLAG(op, FLAG_ALIVE)) return 0; - - /* This is a test for it being an artifact, as artifacts have titles */ - if (op->title!=NULL) return 1; +int +is_magical (const object *op) +{ + int i; - /* Handle rings and amulets specially. If they change any of these - * values, it means they are magical. - */ - if ((op->type==AMULET || op->type==RING) && - (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || - op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck)) - return 1; - - /* Check for stealty, speed, flying, or just plain magic in the boots */ - /* Presume any boots that hvae a move_type are special. */ - if (op->type== BOOTS && - ((QUERY_FLAG(op, FLAG_STEALTH) || op->move_type || op->stats.exp))) - return 1; - - /* Take care of amulet/shield that reflects spells/missiles */ - if ((op->type==AMULET || op->type==SHIELD) && - (QUERY_FLAG(op, FLAG_REFL_SPELL) || QUERY_FLAG(op, FLAG_REFL_MISSILE))) - return 1; - - /* Take care of helmet of xrays */ - if (op->type==HELMET && QUERY_FLAG(op,FLAG_XRAYS)) return 1; - - /* Potions & rods are always magical. Wands/staves are also magical, - * assuming they still have any charges left. - */ - if (op->type==POTION || op->type==ROD || - (op->type==WAND && op->stats.food)) - return 1; - - /* if something gives a protection, either positive or negative, its magical */ - /* This is really a pretty bad hack - as of now, ATNR_PHYSICAL is 0, - * so this always works out fine. - */ - for (i=ATNR_PHYSICAL+1; iresist[i]) return 1; - - /* Physical protection is expected on some item types, so they should - * not be considered magical. - */ - if (op->resist[ATNR_PHYSICAL] && op->type != HELMET && op->type != SHIELD && - op->type != BOOTS && op->type != GLOVES && op->type != ARMOUR) return 1; - - /* power crystal, spellbooks, and scrolls are always magical. */ - if (op->magic || op->type==POWER_CRYSTAL || op->type==SPELLBOOK || - op->type==SCROLL || op->type==GIRDLE) - return 1; - - /* Check to see if it increases/decreases any stats */ - for (i=0; istats),i)!=0) return 1; - - /* If it doesn't fall into any of the above categories, must - * be non magical. - */ + /* living creatures are considered non magical */ + if (QUERY_FLAG (op, FLAG_ALIVE)) return 0; + + /* This is a test for it being an artifact, as artifacts have titles */ + if (op->title != NULL) + return 1; + + /* Handle rings and amulets specially. If they change any of these + * values, it means they are magical. + */ + if ((op->type == AMULET || op->type == RING) && + (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck)) + return 1; + + /* Check for stealty, speed, flying, or just plain magic in the boots */ + /* Presume any boots that hvae a move_type are special. */ + if (op->type == BOOTS && ((QUERY_FLAG (op, FLAG_STEALTH) || op->move_type || op->stats.exp))) + return 1; + + /* Take care of amulet/shield that reflects spells/missiles */ + if ((op->type == AMULET || op->type == SHIELD) && (QUERY_FLAG (op, FLAG_REFL_SPELL) || QUERY_FLAG (op, FLAG_REFL_MISSILE))) + return 1; + + /* Take care of helmet of xrays */ + if (op->type == HELMET && QUERY_FLAG (op, FLAG_XRAYS)) + return 1; + + /* Potions & rods are always magical. Wands/staves are also magical, + * assuming they still have any charges left. + */ + if (op->type == POTION || op->type == ROD || (op->type == WAND && op->stats.food)) + return 1; + + /* if something gives a protection, either positive or negative, its magical */ + /* This is really a pretty bad hack - as of now, ATNR_PHYSICAL is 0, + * so this always works out fine. + */ + for (i = ATNR_PHYSICAL + 1; i < NROFATTACKS; i++) + if (op->resist[i]) + return 1; + + /* Physical protection is expected on some item types, so they should + * not be considered magical. + */ + if (op->resist[ATNR_PHYSICAL] && op->type != HELMET && op->type != SHIELD && + op->type != BOOTS && op->type != GLOVES && op->type != ARMOUR) + return 1; + + /* power crystal, spellbooks, and scrolls are always magical. */ + if (op->magic || op->type == POWER_CRYSTAL || op->type == SPELLBOOK || op->type == SCROLL || op->type == GIRDLE) + return 1; + + /* Check to see if it increases/decreases any stats */ + for (i = 0; i < NUM_STATS; i++) + if (get_attr_value (&(op->stats), i) != 0) + return 1; + + /* If it doesn't fall into any of the above categories, must + * be non magical. + */ + return 0; } /* need_identify returns true if the item should be identified. This @@ -1328,8 +1446,11 @@ * should need it. */ -int need_identify(const object *op) { - switch(op->type) { +int +need_identify (const object *op) +{ + switch (op->type) + { case RING: case WAND: case ROD: @@ -1362,54 +1483,57 @@ case POISON: case BOOK: case SKILL_TOOL: - return 1; + return 1; } - /* Try to track down some stuff that may show up here. Thus, the - * archetype file can be updated, and this function removed. - */ + /* Try to track down some stuff that may show up here. Thus, the + * archetype file can be updated, and this function removed. + */ #if 0 - LOG(llevDebug,"need_identify: %s does not need to be id'd\n", op->name); + LOG (llevDebug, "need_identify: %s does not need to be id'd\n", op->name); #endif - return 0; + return 0; } - /* * Supposed to fix face-values as well here, but later. */ +void +identify (object *op) +{ + object *pl; -void identify(object *op) { - object *pl; - - SET_FLAG(op,FLAG_IDENTIFIED); - CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL); - CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT); - - /* - * We want autojoining of equal objects: - */ - if (QUERY_FLAG(op,FLAG_CURSED) || QUERY_FLAG(op,FLAG_DAMNED)) - SET_FLAG(op,FLAG_KNOWN_CURSED); - - if (op->type == POTION) { - if (op->inv && op->randomitems) - op->title = op->inv->name; - else if (op->arch) - { - op->name = op->arch->clone.name; - op->name_pl = op->arch->clone.name_pl; - } + SET_FLAG (op, FLAG_IDENTIFIED); + CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL); + CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT); + + /* + * We want autojoining of equal objects: + */ + if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)) + SET_FLAG (op, FLAG_KNOWN_CURSED); + + if (op->type == POTION) + { + if (op->inv && op->randomitems) + op->title = op->inv->name; + else if (op->arch) + { + op->name = op->arch->clone.name; + op->name_pl = op->arch->clone.name_pl; + } } - /* If the object is on a map, make sure we update its face */ - if (op->map) - update_object(op,UP_OBJ_FACE); - else { - pl = is_player_inv(op->env); - if (pl) - /* A lot of the values can change from an update - might as well send - * it all. - */ - esrv_send_item(pl, op); + /* If the object is on a map, make sure we update its face */ + if (op->map) + update_object (op, UP_OBJ_FACE); + else + { + pl = op->in_player (); + if (pl) + /* A lot of the values can change from an update - might as well send + * it all. + */ + esrv_send_item (pl, op); } } +