ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/item.C
(Generate patch)

Comparing deliantra/server/common/item.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.18 by pippijn, Sat Jan 6 14:42:28 2007 UTC

1/*
2 * static char *rcsid_item_c =
3 * "$Id: item.C,v 1.2 2006/08/29 08:01:35 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
11 7
12 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
21 17
22 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 23*/
28 24
29#include <global.h> 25#include <global.h>
30#include <funcpoint.h> 26#include <funcpoint.h>
31#include <living.h> 27#include <living.h>
… …
51 * may be better. 47 * may be better.
52 * Basically, for the use/nonuse, the code does something like: 48 * Basically, for the use/nonuse, the code does something like:
53 * "This item goes %s\n", with the use/nonuse values filling in the %s 49 * "This item goes %s\n", with the use/nonuse values filling in the %s
54 */ 50 */
55Body_Locations body_locations[NUM_BODY_LOCATIONS] = { 51Body_Locations body_locations[NUM_BODY_LOCATIONS] = {
56{"body_range", "in your range slot", "in a human's range slot"}, 52 {"body_range", "in your range slot", "in a human's range slot"},
57{"body_arm", "on your arm", "on a human's arm"}, 53 {"body_arm", "on your arm", "on a human's arm"},
58{"body_torso", "on your body", "on a human's torso"}, 54 {"body_torso", "on your body", "on a human's torso"},
59{"body_head", "on your head", "on a human's head"}, 55 {"body_head", "on your head", "on a human's head"},
60{"body_neck", "around your neck", "around a humans neck"}, 56 {"body_neck", "around your neck", "around a humans neck"},
61{"body_skill", "in your skill slot", "in a human's skill slot"}, 57 {"body_skill", "in your skill slot", "in a human's skill slot"},
62{"body_finger", "on your finger", "on a human's finger"}, 58 {"body_finger", "on your finger", "on a human's finger"} ,
63{"body_shoulder", "around your shoulders", "around a human's shoulders"}, 59 {"body_shoulder", "around your shoulders", "around a human's shoulders"},
64{"body_foot", "on your feet", "on a human's feet"}, 60 {"body_foot", "on your feet", "on a human's feet"},
65{"body_hand", "on your hands", "on a human's hands"}, 61 {"body_hand", "on your hands", "on a human's hands"},
66{"body_wrist", "around your wrists", "around a human's wrist"}, 62 {"body_wrist", "around your wrists", "around a human's wrist"},
67{"body_waist", "around your waist", "around a human's waist"}, 63 {"body_waist", "around your waist", "around a human's waist"},
68
69/*{"body_dragon_torso", "your body", "a dragon's body"} */ 64/*{"body_dragon_torso", "your body", "a dragon's body"} */
70}; 65};
71 66
72static char numbers[21][20] = { 67static char numbers[21][20] = {
73 "no","","two","three","four","five","six","seven","eight","nine","ten", 68 "no", "", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
74 "eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen", 69 "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",
75 "eighteen","nineteen","twenty" 70 "eighteen", "nineteen", "twenty"
76}; 71};
77 72
78static char numbers_10[10][20] = { 73static char numbers_10[10][20] = {
79 "zero","ten","twenty","thirty","fourty","fifty","sixty","seventy", 74 "zero", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy",
80 "eighty","ninety" 75 "eighty", "ninety"
81}; 76};
82 77
83static char levelnumbers[21][20] = { 78static char levelnumbers[21][20] = {
84 "zeroth","first", "second", "third", "fourth", "fifth", "sixth", "seventh", 79 "zeroth", "first", "second", "third", "fourth", "fifth", "sixth", "seventh",
85 "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", 80 "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth",
86 "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteen", 81 "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteen",
87 "nineteen", "twentieth" 82 "nineteen", "twentieth"
88}; 83};
89 84
90static char levelnumbers_10[11][20] = { 85static char levelnumbers_10[11][20] = {
91 "zeroth","tenth","twentieth","thirtieth","fortieth","fiftieth","sixtieth", 86 "zeroth", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth",
92 "seventieth","eightieth","ninetieth" 87 "seventieth", "eightieth", "ninetieth"
93}; 88};
94 89
95/* The following is a large table of item types, the fields are: 90/* The following is a large table of item types, the fields are:
96 * item number, item name, item name (plural), and two numbers that are the skills 91 * item number, item name, item name (plural), and two numbers that are the skills
97 * used to identify them. Anytime a new item type is added or removed, this list 92 * used to identify them. Anytime a new item type is added or removed, this list
98 * should be altered to reflect that. The defines for the numerical values are in 93 * should be altered to reflect that. The defines for the numerical values are in
99 * define.h 94 * define.h
100 */ 95 */
101static const typedata item_types[] = { 96static const typedata item_types[] = {
102{PLAYER, "player", "players", 0, 0}, 97 {PLAYER, "player", "players", 0, 0},
103{ROD, "rod", "rods", SK_THAUMATURGY, 0}, 98 {ROD, "rod", "rods", SK_THAUMATURGY, 0},
104{TREASURE, "treasure", "treasure", 0, 0}, 99 {TREASURE, "treasure", "treasure", 0, 0},
105{POTION, "potion", "potions", SK_ALCHEMY, 0}, 100 {POTION, "potion", "potions", SK_ALCHEMY, 0},
106{FOOD, "food", "food", SK_WOODSMAN, 0}, 101 {FOOD, "food", "food", SK_WOODSMAN, 0},
107{POISON, "poison", "poisons", SK_ALCHEMY, 0}, 102 {POISON, "poison", "poisons", SK_ALCHEMY, 0},
108{BOOK, "book", "books", SK_LITERACY, 0}, 103 {BOOK, "book", "books", SK_LITERACY, 0},
109{CLOCK, "clock", "clocks", 0, 0}, 104 {CLOCK, "clock", "clocks", 0, 0},
110{LIGHTNING, "lightning", "lightning", 0, 0},
111{ARROW, "arrow", "arrows", SK_BOWYER, 0}, 105 {ARROW, "arrow", "arrows", SK_BOWYER, 0},
112{BOW, "bow", "bows", SK_BOWYER, 0}, 106 {BOW, "bow", "bows", SK_BOWYER, 0},
113{WEAPON, "weapon", "weapons", SK_SMITHERY, 0}, 107 {WEAPON, "weapon", "weapons", SK_SMITHERY, 0},
114{ARMOUR, "armour", "armour", SK_SMITHERY, 0}, 108 {ARMOUR, "armour", "armour", SK_SMITHERY, 0},
115{PEDESTAL, "pedestal", "pedestals", 0, 0}, 109 {PEDESTAL, "pedestal", "pedestals", 0, 0},
116{ALTAR, "altar", "altars", 0, 0}, 110 {ALTAR, "altar", "altars", 0, 0},
117{LOCKED_DOOR, "locked door", "locked doors", 0, 0}, 111 {LOCKED_DOOR, "locked door", "locked doors", 0, 0},
118{SPECIAL_KEY, "special key", "special keys", 0, 0}, 112 {SPECIAL_KEY, "special key", "special keys", 0, 0},
119{MAP, "map", "maps", 0, 0}, 113 {MAP, "map", "maps", 0, 0},
120{DOOR, "door", "doors", 0, 0}, 114 {DOOR, "door", "doors", 0, 0},
121{KEY, "key", "keys", 0, 0}, 115 {KEY, "key", "keys", 0, 0},
122{TIMED_GATE, "timed_gate", "timed_gates", 0, 0}, 116 {TIMED_GATE, "timed_gate", "timed_gates", 0, 0},
123{TRIGGER, "trigger", "triggers", 0, 0}, 117 {TRIGGER, "trigger", "triggers", 0, 0},
124{GRIMREAPER, "grimreaper", "grimreapers", 0, 0}, 118 {GRIMREAPER, "grimreaper", "grimreapers", 0, 0},
125{MAGIC_EAR, "magic ear", "magic ears", 0, 0}, 119 {MAGIC_EAR, "magic ear", "magic ears", 0, 0},
126{TRIGGER_BUTTON, "trigger button", "trigger buttons", 0, 0}, 120 {TRIGGER_BUTTON, "trigger button", "trigger buttons", 0, 0},
127{TRIGGER_ALTAR, "trigger altar", "trigger altars", 0, 0}, 121 {TRIGGER_ALTAR, "trigger altar", "trigger altars", 0, 0},
128{TRIGGER_PEDESTAL, "trigger pedestal", "trigger pedestals", 0, 0}, 122 {TRIGGER_PEDESTAL, "trigger pedestal", "trigger pedestals", 0, 0},
129{SHIELD, "shield", "shields", SK_SMITHERY, 0}, 123 {SHIELD, "shield", "shields", SK_SMITHERY, 0},
130{HELMET, "helmet", "helmets", SK_SMITHERY, 0}, 124 {HELMET, "helmet", "helmets", SK_SMITHERY, 0},
131{HORN, "horn", "horns", SK_THAUMATURGY, 0}, 125 {HORN, "horn", "horns", SK_THAUMATURGY, 0},
132{MONEY, "money", "money", 0, 0}, 126 {MONEY, "money", "money", 0, 0},
133{CLASS, "class", "classes", 0, 0}, 127 {CLASS, "class", "classes", 0, 0},
134{GRAVESTONE, "gravestone", "gravestones", 0, 0}, 128 {GRAVESTONE, "gravestone", "gravestones", 0, 0},
135{AMULET, "amulet", "amulets", SK_JEWELER, 0}, 129 {AMULET, "amulet", "amulets", SK_JEWELER, 0},
136{PLAYERMOVER, "player mover", "player movers", 0, 0}, 130 {PLAYERMOVER, "player mover", "player movers", 0, 0},
137{TELEPORTER, "teleporter", "teleporters", 0, 0}, 131 {TELEPORTER, "teleporter", "teleporters", 0, 0},
138{CREATOR, "creator", "creators", 0, 0}, 132 {CREATOR, "creator", "creators", 0, 0},
139{SKILL, "skill", "skills", 0, 0}, 133 {SKILL, "skill", "skills", 0, 0},
140{EXPERIENCE, "experience", "experience", 0, 0},
141{EARTHWALL, "earthwall", "earthwalls", 0, 0}, 134 {EARTHWALL, "earthwall", "earthwalls", 0, 0},
142{GOLEM, "golem", "golems", 0, 0}, 135 {GOLEM, "golem", "golems", 0, 0},
143{THROWN_OBJ, "projectile", "projectiles", 0, 0}, 136 {THROWN_OBJ, "projectile", "projectiles", 0, 0},
144{BLINDNESS, "blindness", "blindness", 0, 0}, 137 {BLINDNESS, "blindness", "blindness", 0, 0},
145{GOD, "god", "gods", 0, 0}, 138 {GOD, "god", "gods", 0, 0},
146{DETECTOR, "detector", "detectors", 0, 0}, 139 {DETECTOR, "detector", "detectors", 0, 0},
147{TRIGGER_MARKER, "trigger marker", "trigger markers", 0, 0}, 140 {TRIGGER_MARKER, "trigger marker", "trigger markers", 0, 0},
148{DEAD_OBJECT, "dead object", "dead objects", 0, 0}, 141 {DEAD_OBJECT, "dead object", "dead objects", 0, 0},
149{DRINK, "drink", "drinks", SK_WOODSMAN, SK_ALCHEMY}, 142 {DRINK, "drink", "drinks", SK_WOODSMAN, SK_ALCHEMY},
150{MARKER, "marker", "markers", 0, 0}, 143 {MARKER, "marker", "markers", 0, 0},
151{HOLY_ALTAR, "holy altar", "holy altars", 0, 0}, 144 {HOLY_ALTAR, "holy altar", "holy altars", 0, 0},
152{PLAYER_CHANGER, "player changer", "player changers", 0, 0}, 145 {PLAYER_CHANGER, "player changer", "player changers", 0, 0},
153{BATTLEGROUND, "battleground", "battlegrounds", 0, 0}, 146 {BATTLEGROUND, "battleground", "battlegrounds", 0, 0},
154{PEACEMAKER, "peacemaker", "peacemakers", 0, 0}, 147 {PEACEMAKER, "peacemaker", "peacemakers", 0, 0},
155{GEM, "gem", "gems", SK_JEWELER, 0}, 148 {GEM, "gem", "gems", SK_JEWELER, 0},
156{FIREWALL, "firewall", "firewalls", 0, 0}, 149 {FIREWALL, "firewall", "firewalls", 0, 0},
157{ANVIL, "anvil", "anvils", 0, 0}, 150 {ANVIL, "anvil", "anvils", 0, 0},
158{CHECK_INV, "inventory checker", "inventory checkers", 0, 0}, 151 {CHECK_INV, "inventory checker", "inventory checkers", 0, 0},
159{MOOD_FLOOR, "mood floor", "mood floors", 0, 0}, 152 {MOOD_FLOOR, "mood floor", "mood floors", 0, 0},
160{EXIT, "exit", "exits", 0, 0}, 153 {EXIT, "exit", "exits", 0, 0},
161{ENCOUNTER, "encounter", "encounters", 0, 0}, 154 {ENCOUNTER, "encounter", "encounters", 0, 0},
162{SHOP_FLOOR, "shop floor", "shop floors", 0, 0}, 155 {SHOP_FLOOR, "shop floor", "shop floors", 0, 0},
163{SHOP_MAT, "shop mat", "shop mats", 0, 0}, 156 {SHOP_MAT, "shop mat", "shop mats", 0, 0},
164{RING, "ring", "rings", SK_JEWELER, 0}, 157 {RING, "ring", "rings", SK_JEWELER, 0},
165{FLOOR, "floor", "floors", 0, 0}, 158 {FLOOR, "floor", "floors", 0, 0},
166{FLESH, "flesh", "flesh", SK_WOODSMAN, 0}, 159 {FLESH, "flesh", "flesh", SK_WOODSMAN, 0},
167{INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0}, 160 {INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0},
168{SKILL_TOOL, "skill tool", "skill tools", 0, 0}, 161 {SKILL_TOOL, "skill tool", "skill tools", 0, 0},
169{LIGHTER, "lighter", "lighters", 0, 0}, 162 {LIGHTER, "lighter", "lighters", 0, 0},
170{TRAP_PART, "trap part", "trap parts", 0, 0}, 163 {BUILDABLE_WALL, "buildable wall", "buildable walls", 0, 0},
171{WALL, "wall", "walls", 0, 0},
172{LIGHT_SOURCE, "light source", "light sources", 0, 0},
173{MISC_OBJECT, "bric-a-brac", "bric-a-brac", 0, 0}, 164 {MISC_OBJECT, "bric-a-brac", "bric-a-brac", 0, 0},
174{MONSTER, "monster", "monsters", 0, 0},
175{SPAWN_GENERATOR, "monster generator", "monster generators", 0, 0},
176{LAMP, "lamp", "lamps", 0, 0}, 165 {LAMP, "lamp", "lamps", 0, 0},
177{DUPLICATOR, "duplicator", "duplicators", 0, 0}, 166 {DUPLICATOR, "duplicator", "duplicators", 0, 0},
178{TOOL, "tool", "tools", 0, 0},
179{SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0}, 167 {SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0},
180{BUILDFAC, "building facility", "building facilities", 0, 0},
181{CLOAK, "cloak", "cloaks", SK_SMITHERY, 0}, 168 {CLOAK, "cloak", "cloaks", SK_SMITHERY, 0},
182{SPINNER, "spinner", "spinners", 0, 0}, 169 {SPINNER, "spinner", "spinners", 0, 0},
183{GATE, "gate", "gates", 0, 0}, 170 {GATE, "gate", "gates", 0, 0},
184{BUTTON, "button", "buttons", 0, 0}, 171 {BUTTON, "button", "buttons", 0, 0},
185{CF_HANDLE, "cf handle", "cf handles", 0, 0}, 172 {CF_HANDLE, "cf handle", "cf handles", 0, 0},
186{HOLE, "hole", "holes", 0, 0}, 173 {HOLE, "hole", "holes", 0, 0},
187{TRAPDOOR, "trapdoor", "trapdoors", 0, 0}, 174 {TRAPDOOR, "trapdoor", "trapdoors", 0, 0},
188{SIGN, "sign", "signs", 0, 0}, 175 {SIGN, "sign", "signs", 0, 0},
189{BOOTS, "boots", "boots", SK_SMITHERY, 0}, 176 {BOOTS, "boots", "boots", SK_SMITHERY, 0},
190{GLOVES, "gloves", "gloves", SK_SMITHERY, 0}, 177 {GLOVES, "gloves", "gloves", SK_SMITHERY, 0},
191{SPELL, "spell", "spells", 0, 0}, 178 {SPELL, "spell", "spells", 0, 0},
192{SPELL_EFFECT, "spell effect", "spell effects", 0, 0}, 179 {SPELL_EFFECT, "spell effect", "spell effects", 0, 0},
193{CONVERTER, "converter", "converters", 0, 0}, 180 {CONVERTER, "converter", "converters", 0, 0},
194{BRACERS, "bracers", "bracers", SK_SMITHERY, 0}, 181 {BRACERS, "bracers", "bracers", SK_SMITHERY, 0},
195{POISONING, "poisoning", "poisonings", 0, 0}, 182 {POISONING, "poisoning", "poisonings", 0, 0},
196{SAVEBED, "savebed", "savebeds", 0, 0}, 183 {SAVEBED, "savebed", "savebeds", 0, 0},
197{POISONCLOUD, "poison cloud", "poison clouds", 0, 0},
198{FIREHOLES, "fireholes", "fireholes", 0, 0},
199{WAND, "wand", "wands", SK_THAUMATURGY, 0}, 184 {WAND, "wand", "wands", SK_THAUMATURGY, 0},
200{SCROLL, "scroll", "scrolls", SK_LITERACY, 0}, 185 {SCROLL, "scroll", "scrolls", SK_LITERACY, 0},
201{DIRECTOR, "director", "directors", 0, 0}, 186 {DIRECTOR, "director", "directors", 0, 0},
202{GIRDLE, "girdle", "girdles", SK_SMITHERY, 0}, 187 {GIRDLE, "girdle", "girdles", SK_SMITHERY, 0},
203{FORCE, "force", "forces", 0, 0}, 188 {FORCE, "force", "forces", 0, 0},
204{POTION_EFFECT, "potion effect", "potion effects", 0, 0}, 189 {POTION_EFFECT, "potion effect", "potion effects", 0, 0},
205{CLOSE_CON, "closed container", "closed container", 0, 0}, 190 {CLOSE_CON, "closed container", "closed container", 0, 0},
206{CONTAINER, "container", "containers", SK_ALCHEMY, 0}, 191 {CONTAINER, "container", "containers", SK_ALCHEMY, 0},
207{ARMOUR_IMPROVER, "armour improver", "armour improvers", 0, 0}, 192 {ARMOUR_IMPROVER, "armour improver", "armour improvers", 0, 0},
208{WEAPON_IMPROVER, "weapon improver", "weapon improvers", 0, 0}, 193 {WEAPON_IMPROVER, "weapon improver", "weapon improvers", 0, 0},
209{SKILLSCROLL, "skillscroll", "skillscrolls", 0, 0}, 194 {SKILLSCROLL, "skillscroll", "skillscrolls", 0, 0},
210{DEEP_SWAMP, "deep swamp", "deep swamps", 0, 0}, 195 {DEEP_SWAMP, "deep swamp", "deep swamps", 0, 0},
211{IDENTIFY_ALTAR, "identify altar", "identify altars", 0, 0}, 196 {IDENTIFY_ALTAR, "identify altar", "identify altars", 0, 0},
212{MENU, "inventory list", "inventory lists", 0, 0}, 197 {MENU, "inventory list", "inventory lists", 0, 0},
213{RUNE, "rune", "runes", 0, 0}, 198 {RUNE, "rune", "runes", 0, 0},
214{TRAP, "trap", "traps", 0, 0}, 199 {TRAP, "trap", "traps", 0, 0},
215{POWER_CRYSTAL, "power_crystal", "power_crystals", 0, 0}, 200 {POWER_CRYSTAL, "power_crystal", "power_crystals", 0, 0},
216{CORPSE, "corpse", "corpses", 0, 0}, 201 {CORPSE, "corpse", "corpses", 0, 0},
217{DISEASE, "disease", "diseases", 0, 0}, 202 {DISEASE, "disease", "diseases", 0, 0},
218{SYMPTOM, "symptom", "symptoms", 0, 0}, 203 {SYMPTOM, "symptom", "symptoms", 0, 0},
219{BUILDER, "item builder", "item builders", 0, 0}, 204 {BUILDER, "item builder", "item builders", 0, 0},
220{MATERIAL, "building material", "building materials", 0, 0}, 205 {MATERIAL, "building material", "building materials", 0, 0},
221{ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0}, 206 {ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0},
222}; 207};
223 208
224const int item_types_size=sizeof(item_types)/sizeof(*item_types); 209const int item_types_size = sizeof (item_types) / sizeof (*item_types);
225 210
226materialtype_t *materialt; 211materialtype_t *materialt;
227 212
228/* 213/*
229materialtype material[NROFMATERIALS] = { 214materialtype material[NROFMATERIALS] = {
… …
256 * able to use 2-3 of the most powerful items. 241 * able to use 2-3 of the most powerful items.
257 * note that this table is only really used for program generated items - 242 * note that this table is only really used for program generated items -
258 * custom objects can use whatever they want. 243 * custom objects can use whatever they want.
259 */ 244 */
260static int enc_to_item_power[21] = { 245static int enc_to_item_power[21] = {
2610, 0, 1, 2, 3, 4, /* 5 */ 246 0, 0, 1, 2, 3, 4, /* 5 */
2625, 7, 9, 11, 13, /* 10 */ 247 5, 7, 9, 11, 13, /* 10 */
26315, 18, 21, 24, 27, /* 15 */ 248 15, 18, 21, 24, 27, /* 15 */
26430, 35, 40, 45, 50 /* 20 */ 249 30, 35, 40, 45, 50 /* 20 */
265}; 250};
266 251
252int
267int get_power_from_ench(int ench) 253get_power_from_ench (int ench)
268{ 254{
269 if (ench < 0) ench = 0; 255 if (ench < 0)
270 if (ench > 20) ench = 20; 256 ench = 0;
257 if (ench > 20)
258 ench = 20;
271 return enc_to_item_power[ench]; 259 return enc_to_item_power[ench];
272} 260}
273 261
274/* This takes an object 'op' and figures out what its item_power 262/* This takes an object 'op' and figures out what its item_power
275 * rating should be. This should only really be used by the treasure 263 * rating should be. This should only really be used by the treasure
276 * generation code, and when loading legacy objects. It returns 264 * generation code, and when loading legacy objects. It returns
277 * the item_power it calculates. 265 * the item_power it calculates.
278 * If flag is 1, we return the number of enchantment, and not the 266 * If flag is 1, we return the number of enchantment, and not the
279 * the power. This is used in the treasure code. 267 * the power. This is used in the treasure code.
280 */ 268 */
269int
281int calc_item_power(const object *op, int flag) 270calc_item_power (const object *op, int flag)
282{ 271{
283 int i, tmp, enc; 272 int i, tmp, enc;
284 273
285 enc = 0; 274 enc = 0;
286 for (i=0; i<NUM_STATS; i++) 275 for (i = 0; i < NUM_STATS; i++)
287 enc += get_attr_value(&op->stats, i); 276 enc += get_attr_value (&op->stats, i);
288 277
289 /* This protection logic is pretty flawed. 20% fire resistance 278 /* This protection logic is pretty flawed. 20% fire resistance
290 * is much more valuable than 20% confusion, or 20% slow, or 279 * is much more valuable than 20% confusion, or 20% slow, or
291 * several others. Start at 1 - ignore physical - all that normal 280 * several others. Start at 1 - ignore physical - all that normal
292 * armour shouldn't be counted against 281 * armour shouldn't be counted against
293 */ 282 */
294 tmp = 0; 283 tmp = 0;
295 for (i=1; i<NROFATTACKS; i++) 284 for (i = 1; i < NROFATTACKS; i++)
296 tmp += op->resist[i]; 285 tmp += op->resist[i];
297 286
298 /* Add/substract 10 so that the rounding works out right */ 287 /* Add/substract 10 so that the rounding works out right */
299 if (tmp>0) enc += (tmp+10)/20; 288 if (tmp > 0)
300 else if (tmp<0) enc += (tmp - 10) / 20; 289 enc += (tmp + 10) / 20;
290 else if (tmp < 0)
291 enc += (tmp - 10) / 20;
301 292
302 enc += op->magic; 293 enc += op->magic;
303 294
304 /* For each attacktype a weapon has, one more encantment. Start at 1 - 295 /* For each attacktype a weapon has, one more encantment. Start at 1 -
305 * physical doesn't count against total. 296 * physical doesn't count against total.
306 */ 297 */
307 if (op->type == WEAPON) { 298 if (op->type == WEAPON)
299 {
308 for (i=1; i<NROFATTACKS; i++) 300 for (i = 1; i < NROFATTACKS; i++)
309 if (op->attacktype & (1 << i)) enc++; 301 if (op->attacktype & (1 << i))
302 enc++;
303 if (op->slaying)
310 if (op->slaying) enc += 2; /* What it slays is probably more relevent */ 304 enc += 2; /* What it slays is probably more relevent */
311 } 305 }
312 /* Items the player can equip */ 306 /* Items the player can equip */
313 if ((op->type == WEAPON) || (op->type == ARMOUR) || (op->type == HELMET) || 307 if ((op->type == WEAPON) || (op->type == ARMOUR) || (op->type == HELMET) ||
314 (op->type == SHIELD) || (op->type == RING) || 308 (op->type == SHIELD) || (op->type == RING) ||
315 (op->type == BOOTS) || (op->type == GLOVES) || 309 (op->type == BOOTS) || (op->type == GLOVES) ||
316 (op->type == AMULET ) || (op->type == GIRDLE) || 310 (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK))
317 (op->type == BRACERS ) || (op->type == CLOAK)) { 311 {
318 enc += op->stats.food; /* sustenance */ 312 enc += op->stats.food; /* sustenance */
319 enc += op->stats.hp; /* hp regen */ 313 enc += op->stats.hp; /* hp regen */
320 enc += op->stats.sp; /* mana regen */ 314 enc += op->stats.sp; /* mana regen */
321 enc += op->stats.grace; /* grace regen */ 315 enc += op->stats.grace; /* grace regen */
322 enc += op->stats.exp; /* speed bonus */ 316 enc += op->stats.exp; /* speed bonus */
323 } 317 }
324 enc += op->stats.luck; 318 enc += op->stats.luck;
325 319
326 /* Do spell paths now */ 320 /* Do spell paths now */
327 for (i=1; i<NRSPELLPATHS; i++) { 321 for (i = 1; i < NRSPELLPATHS; i++)
322 {
328 if (op->path_attuned& (1 << i)) enc++; 323 if (op->path_attuned & (1 << i))
324 enc++;
329 else if (op->path_denied & (1 << i)) enc-=2; 325 else if (op->path_denied & (1 << i))
326 enc -= 2;
330 else if (op->path_repelled & (1 << i)) enc--; 327 else if (op->path_repelled & (1 << i))
328 enc--;
331 } 329 }
332 330
333 if(QUERY_FLAG(op,FLAG_LIFESAVE)) enc += 5; 331 if (QUERY_FLAG (op, FLAG_LIFESAVE))
332 enc += 5;
334 if(QUERY_FLAG(op,FLAG_REFL_SPELL)) enc += 3; 333 if (QUERY_FLAG (op, FLAG_REFL_SPELL))
334 enc += 3;
335 if(QUERY_FLAG(op,FLAG_REFL_MISSILE)) enc += 2; 335 if (QUERY_FLAG (op, FLAG_REFL_MISSILE))
336 enc += 2;
336 if(QUERY_FLAG(op,FLAG_STEALTH)) enc += 1; 337 if (QUERY_FLAG (op, FLAG_STEALTH))
338 enc += 1;
337 if(QUERY_FLAG(op,FLAG_XRAYS)) enc += 2; 339 if (QUERY_FLAG (op, FLAG_XRAYS))
340 enc += 2;
338 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK)) enc += 1; 341 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
342 enc += 1;
339 if(QUERY_FLAG(op,FLAG_MAKE_INVIS)) enc += 1; 343 if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
344 enc += 1;
340 345
341 return get_power_from_ench(enc); 346 return get_power_from_ench (enc);
342 347
343} 348}
344 349
345/* returns the typedata that has a number equal to itemtype, if there 350/* returns the typedata that has a number equal to itemtype, if there
346 * isn't one, returns NULL */ 351 * isn't one, returns NULL */
347 352
348const typedata *get_typedata(int itemtype) { 353const typedata *
354get_typedata (int itemtype)
355{
349 int i; 356 int i;
357
350 for (i=0;i<item_types_size;i++) 358 for (i = 0; i < item_types_size; i++)
351 if (item_types[i].number==itemtype) return &item_types[i]; 359 if (item_types[i].number == itemtype)
360 return &item_types[i];
352 return NULL; 361 return NULL;
353} 362}
354 363
355/* returns the typedata that has a name equal to itemtype, if there 364/* returns the typedata that has a name equal to itemtype, if there
356 * isn't one, return the plural name that matches, if there still isn't 365 * isn't one, return the plural name that matches, if there still isn't
357 * one return NULL */ 366 * one return NULL */
358 367
368const typedata *
359const typedata *get_typedata_by_name(const char *name) { 369get_typedata_by_name (const char *name)
370{
360 int i; 371 int i;
372
361 for (i=0;i<item_types_size;i++) 373 for (i = 0; i < item_types_size; i++)
362 if (!strcmp(item_types[i].name, name)) return &item_types[i]; 374 if (!strcmp (item_types[i].name, name))
375 return &item_types[i];
363 for (i=0;i<item_types_size;i++) 376 for (i = 0; i < item_types_size; i++)
364 if (!strcmp(item_types[i].name_pl, name)) { 377 if (!strcmp (item_types[i].name_pl, name))
378 {
365 LOG(llevInfo, 379 LOG (llevInfo,
366 "get_typedata_by_name: I have been sent the plural %s, the singular form %s is preffered\n", 380 "get_typedata_by_name: I have been sent the plural %s, the singular form %s is preffered\n", name, item_types[i].name);
367 name, item_types[i].name);
368 return &item_types[i]; 381 return &item_types[i];
369 } 382 }
370 return NULL; 383 return NULL;
371} 384}
385
372/* describe_resistance generates the visible naming for resistances. 386/* describe_resistance generates the visible naming for resistances.
373 * returns a static array of the description. This can return 387 * returns a static array of the description. This can return
374 * a big buffer. 388 * a big buffer.
375 * if newline is true, we don't put parens around the description 389 * if newline is true, we don't put parens around the description
376 * but do put a newline at the end. Useful when dumping to files 390 * but do put a newline at the end. Useful when dumping to files
377 */ 391 */
392char *
378char *describe_resistance(const object *op, int newline) 393describe_resistance (const object *op, int newline)
379{ 394{
380 static char buf[VERY_BIG_BUF]; 395 static char buf[VERY_BIG_BUF];
381 char buf1[VERY_BIG_BUF]; 396 char buf1[VERY_BIG_BUF];
382 int tmpvar; 397 int tmpvar;
383 398
384 buf[0]=0; 399 buf[0] = 0;
385 for (tmpvar=0; tmpvar<NROFATTACKS; tmpvar++) { 400 for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++)
401 {
386 if (op->resist[tmpvar] && (op->type != FLESH || atnr_is_dragon_enabled(tmpvar)==1)) { 402 if (op->resist[tmpvar] && (op->type != FLESH || atnr_is_dragon_enabled (tmpvar) == 1))
403 {
387 if (!newline) 404 if (!newline)
388 sprintf(buf1,"(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]); 405 sprintf (buf1, "(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]);
389 else 406 else
390 sprintf(buf1,"%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]); 407 sprintf (buf1, "%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]);
391 408
392 strcat(buf, buf1); 409 strcat (buf, buf1);
393 } 410 }
394 } 411 }
395 return buf; 412 return buf;
396} 413}
397 414
398 415
399/* 416/*
400 * query_weight(object) returns a character pointer to a static buffer 417 * query_weight(object) returns a character pointer to a static buffer
401 * containing the text-representation of the weight of the given object. 418 * containing the text-representation of the weight of the given object.
402 * The buffer will be overwritten by the next call to query_weight(). 419 * The buffer will be overwritten by the next call to query_weight().
403 */ 420 */
404 421
422char *
405char *query_weight(const object *op) { 423query_weight (const object *op)
424{
406 static char buf[10]; 425 static char buf[10];
407 sint32 i=(op->nrof?op->nrof:1)*op->weight+op->carrying; 426 sint32 i = (op->nrof ? op->nrof : 1) * op->weight + op->carrying;
408 427
409 if(op->weight<0) 428 if (op->weight < 0)
410 return " "; 429 return " ";
411 if(i%1000) 430 if (i % 1000)
412 sprintf(buf,"%6.1f",i/1000.0); 431 sprintf (buf, "%6.1f", i / 1000.0);
413 else 432 else
414 sprintf(buf,"%4d ",i/1000); 433 sprintf (buf, "%4d ", i / 1000);
415 return buf; 434 return buf;
416} 435}
417 436
418/* 437/*
419 * Returns the pointer to a static buffer containing 438 * Returns the pointer to a static buffer containing
420 * the number requested (of the form first, second, third...) 439 * the number requested (of the form first, second, third...)
421 */ 440 */
422 441
442char *
423char *get_levelnumber(int i) { 443get_levelnumber (int i)
444{
424 static char buf[MAX_BUF]; 445 static char buf[MAX_BUF];
446
425 if (i > 99) { 447 if (i > 99)
448 {
426 sprintf(buf, "%d.", i); 449 sprintf (buf, "%d.", i);
427 return buf; 450 return buf;
428 } 451 }
429 if(i < 21) 452 if (i < 21)
430 return levelnumbers[i]; 453 return levelnumbers[i];
431 if(!(i%10)) 454 if (!(i % 10))
432 return levelnumbers_10[i/10]; 455 return levelnumbers_10[i / 10];
433 strcpy(buf, numbers_10[i/10]); 456 strcpy (buf, numbers_10[i / 10]);
434 strcat(buf, levelnumbers[i%10]); 457 strcat (buf, levelnumbers[i % 10]);
435 return buf; 458 return buf;
436} 459}
437 460
438 461
439/* 462/*
… …
441 * in a static buffer. The buffer might be overwritten at the next 464 * in a static buffer. The buffer might be overwritten at the next
442 * call to get_number(). 465 * call to get_number().
443 * It is currently only used by the query_name() function. 466 * It is currently only used by the query_name() function.
444 */ 467 */
445 468
469char *
446char *get_number(int i) { 470get_number (int i)
471{
447 if(i<=20) 472 if (i <= 20)
448 return numbers[i]; 473 return numbers[i];
449 else { 474 else
475 {
450 static char buf[MAX_BUF]; 476 static char buf[MAX_BUF];
477
451 sprintf(buf,"%d",i); 478 sprintf (buf, "%d", i);
452 return buf; 479 return buf;
453 } 480 }
454} 481}
455 482
456/* 483/*
457 * Returns pointer to static buffer containing ring's or amulet's 484 * Returns pointer to static buffer containing ring's or amulet's
458 * abilities 485 * abilities
… …
460 * if describle_item() would be called to get this information and 487 * if describle_item() would be called to get this information and
461 * caller would handle FULL_RING_DESCRIPTION definition. 488 * caller would handle FULL_RING_DESCRIPTION definition.
462 * Or make FULL_RING_DESCRIPTION standard part of a game and let 489 * Or make FULL_RING_DESCRIPTION standard part of a game and let
463 * client handle names. 490 * client handle names.
464 */ 491 */
492
465/* Aug 95 modified this slightly so that Skill tools don't have magic bonus 493/* Aug 95 modified this slightly so that Skill tools don't have magic bonus
466 * from stats.sp - b.t. 494 * from stats.sp - b.t.
467 */ 495 */
496char *
468char *ring_desc (const object *op) 497ring_desc (const object *op)
469{ 498{
470 static char buf[VERY_BIG_BUF]; 499 static char buf[VERY_BIG_BUF];
471 int attr, val,len; 500 int attr, val, len;
472 501
473 buf[0] = 0; 502 buf[0] = 0;
474 503
475 if (! QUERY_FLAG(op, FLAG_IDENTIFIED)) 504 if (!QUERY_FLAG (op, FLAG_IDENTIFIED))
476 return buf;
477
478 for (attr=0; attr<NUM_STATS; attr++) {
479 if ((val=get_attr_value(&(op->stats),attr))!=0) {
480 sprintf (buf+strlen(buf), "(%s%+d)", short_stat_name[attr], val);
481 }
482 }
483 if(op->stats.exp)
484 sprintf(buf+strlen(buf), "(speed %+lld)", op->stats.exp);
485 if(op->stats.wc)
486 sprintf(buf+strlen(buf), "(wc%+d)", op->stats.wc);
487 if(op->stats.dam)
488 sprintf(buf+strlen(buf), "(dam%+d)", op->stats.dam);
489 if(op->stats.ac)
490 sprintf(buf+strlen(buf), "(ac%+d)", op->stats.ac);
491
492 strcat(buf,describe_resistance(op, 0));
493
494 if (op->stats.food != 0)
495 sprintf(buf+strlen(buf), "(sustenance%+d)", op->stats.food);
496 /* else if (op->stats.food < 0)
497 sprintf(buf+strlen(buf), "(hunger%+d)", op->stats.food); */
498 if(op->stats.grace)
499 sprintf(buf+strlen(buf), "(grace%+d)", op->stats.grace);
500 if(op->stats.sp && op->type!=SKILL)
501 sprintf(buf+strlen(buf), "(magic%+d)", op->stats.sp);
502 if(op->stats.hp)
503 sprintf(buf+strlen(buf), "(regeneration%+d)", op->stats.hp);
504 if(op->stats.luck)
505 sprintf(buf+strlen(buf), "(luck%+d)", op->stats.luck);
506 if(QUERY_FLAG(op,FLAG_LIFESAVE))
507 strcat(buf,"(lifesaving)");
508 if(QUERY_FLAG(op,FLAG_REFL_SPELL))
509 strcat(buf,"(reflect spells)");
510 if(QUERY_FLAG(op,FLAG_REFL_MISSILE))
511 strcat(buf,"(reflect missiles)");
512 if(QUERY_FLAG(op,FLAG_STEALTH))
513 strcat(buf,"(stealth)");
514 /* Shorten some of the names, so they appear better in the windows */
515 len=strlen(buf);
516 DESCRIBE_PATH_SAFE(buf, op->path_attuned, "Attuned", &len, VERY_BIG_BUF);
517 DESCRIBE_PATH_SAFE(buf, op->path_repelled, "Repelled", &len, VERY_BIG_BUF);
518 DESCRIBE_PATH_SAFE(buf, op->path_denied, "Denied", &len, VERY_BIG_BUF);
519
520 /* if(op->item_power)
521 sprintf(buf+strlen(buf), "(item_power %+d)",op->item_power);
522 */
523 if(buf[0] == 0 && op->type!=SKILL)
524 strcpy(buf,"of adornment");
525
526
527 return buf; 505 return buf;
506
507 for (attr = 0; attr < NUM_STATS; attr++)
508 {
509 if ((val = get_attr_value (&(op->stats), attr)) != 0)
510 {
511 sprintf (buf + strlen (buf), "(%s%+d)", short_stat_name[attr], val);
512 }
513 }
514 if (op->stats.exp)
515 sprintf (buf + strlen (buf), "(speed %+lld)", (long long) op->stats.exp);
516 if (op->stats.wc)
517 sprintf (buf + strlen (buf), "(wc%+d)", op->stats.wc);
518 if (op->stats.dam)
519 sprintf (buf + strlen (buf), "(dam%+d)", op->stats.dam);
520 if (op->stats.ac)
521 sprintf (buf + strlen (buf), "(ac%+d)", op->stats.ac);
522
523 strcat (buf, describe_resistance (op, 0));
524
525 if (op->stats.food != 0)
526 sprintf (buf + strlen (buf), "(sustenance%+d)", op->stats.food);
527 /* else if (op->stats.food < 0)
528 sprintf(buf+strlen(buf), "(hunger%+d)", op->stats.food); */
529 if (op->stats.grace)
530 sprintf (buf + strlen (buf), "(grace%+d)", op->stats.grace);
531 if (op->stats.sp && op->type != SKILL)
532 sprintf (buf + strlen (buf), "(magic%+d)", op->stats.sp);
533 if (op->stats.hp)
534 sprintf (buf + strlen (buf), "(regeneration%+d)", op->stats.hp);
535 if (op->stats.luck)
536 sprintf (buf + strlen (buf), "(luck%+d)", op->stats.luck);
537 if (QUERY_FLAG (op, FLAG_LIFESAVE))
538 strcat (buf, "(lifesaving)");
539 if (QUERY_FLAG (op, FLAG_REFL_SPELL))
540 strcat (buf, "(reflect spells)");
541 if (QUERY_FLAG (op, FLAG_REFL_MISSILE))
542 strcat (buf, "(reflect missiles)");
543 if (QUERY_FLAG (op, FLAG_STEALTH))
544 strcat (buf, "(stealth)");
545 /* Shorten some of the names, so they appear better in the windows */
546 len = strlen (buf);
547 DESCRIBE_PATH_SAFE (buf, op->path_attuned, "Attuned", &len, VERY_BIG_BUF);
548 DESCRIBE_PATH_SAFE (buf, op->path_repelled, "Repelled", &len, VERY_BIG_BUF);
549 DESCRIBE_PATH_SAFE (buf, op->path_denied, "Denied", &len, VERY_BIG_BUF);
550
551 /* if(op->item_power)
552 sprintf(buf+strlen(buf), "(item_power %+d)",op->item_power);
553 */
554 if (buf[0] == 0 && op->type != SKILL)
555 strcpy (buf, "of adornment");
556
557
558 return buf;
528} 559}
529 560
530/* 561/*
531 * query_short_name(object) is similar to query_name, but doesn't 562 * query_short_name(object) is similar to query_name, but doesn't
532 * contain any information about object status (worn/cursed/etc.) 563 * contain any information about object status (worn/cursed/etc.)
533 */ 564 */
565const char *
534const char *query_short_name(const object *op) 566query_short_name (const object *op)
535{ 567{
536 static char buf[HUGE_BUF]; 568 static char buf[HUGE_BUF];
537 char buf2[HUGE_BUF]; 569 char buf2[HUGE_BUF];
538 int len=0; 570 int len = 0;
539 571
540 if(op->name == NULL) 572 if (op->name == NULL)
541 return "(null)"; 573 return "(null)";
574
542 if(!op->nrof && !op->weight && !op->title && !is_magical(op)) 575 if (!op->nrof && !op->weight && !op->title && !is_magical (op))
543 return op->name; /* To speed things up (or make things slower?) */ 576 return op->name; /* To speed things up (or make things slower?) */
544 577
545 if (op->nrof <= 1) 578 if (op->nrof <= 1)
546 safe_strcat(buf,op->name, &len, HUGE_BUF); 579 safe_strcat (buf, op->name, &len, HUGE_BUF);
547 else 580 else
548 safe_strcat(buf,op->name_pl, &len, HUGE_BUF); 581 safe_strcat (buf, op->name_pl, &len, HUGE_BUF);
549 582
550 if (op->title && QUERY_FLAG(op,FLAG_IDENTIFIED)) { 583 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED))
584 {
551 safe_strcat(buf, " ", &len, HUGE_BUF); 585 safe_strcat (buf, " ", &len, HUGE_BUF);
552 safe_strcat(buf, op->title, &len, HUGE_BUF); 586 safe_strcat (buf, op->title, &len, HUGE_BUF);
553 } 587 }
554 588
555 switch(op->type) { 589 switch (op->type)
590 {
556 case SPELLBOOK: 591 case SPELLBOOK:
557 case SCROLL: 592 case SCROLL:
558 case WAND: 593 case WAND:
559 case ROD: 594 case ROD:
560 if (QUERY_FLAG(op,FLAG_IDENTIFIED)||QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { 595 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED))
596 {
561 if(!op->title) { 597 if (!op->title)
598 {
562 safe_strcat(buf," of ", &len, HUGE_BUF); 599 safe_strcat (buf, " of ", &len, HUGE_BUF);
563 if (op->inv) 600 if (op->inv)
564 safe_strcat(buf,op->inv->name, &len, HUGE_BUF); 601 safe_strcat (buf, op->inv->name, &len, HUGE_BUF);
565 else 602 else
566 LOG(llevError,"Spellbook %s lacks inventory\n", op->name); 603 LOG (llevError, "Spellbook %s lacks inventory\n", &op->name);
567 } 604 }
568 if(op->type != SPELLBOOK) { 605 if (op->type != SPELLBOOK)
606 {
569 sprintf(buf2, " (lvl %d)", op->level); 607 sprintf (buf2, " (lvl %d)", op->level);
570 safe_strcat(buf, buf2, &len, HUGE_BUF); 608 safe_strcat (buf, buf2, &len, HUGE_BUF);
571 } 609 }
572 } 610 }
573 break; 611 break;
574 612
575 case SKILL: 613 case SKILL:
576 case AMULET: 614 case AMULET:
577 case RING: 615 case RING:
578 if (!op->title) { 616 if (!op->title)
617 {
579 /* If ring has a title, full description isn't so useful */ 618 /* If ring has a title, full description isn't so useful */
580 char *s = ring_desc(op); 619 char *s = ring_desc (op);
620
581 if (s[0]) { 621 if (s[0])
622 {
582 safe_strcat (buf, " ", &len, HUGE_BUF); 623 safe_strcat (buf, " ", &len, HUGE_BUF);
583 safe_strcat(buf, s, &len, HUGE_BUF); 624 safe_strcat (buf, s, &len, HUGE_BUF);
625 }
584 } 626 }
585 }
586 break; 627 break;
587 default: 628 default:
588 if(op->magic && ((QUERY_FLAG(op,FLAG_BEEN_APPLIED) && 629 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED)))
589 need_identify(op)) || QUERY_FLAG(op,FLAG_IDENTIFIED))) { 630 {
590 sprintf(buf2, " %+d", op->magic); 631 sprintf (buf2, " %+d", op->magic);
591 safe_strcat(buf, buf2, &len, HUGE_BUF); 632 safe_strcat (buf, buf2, &len, HUGE_BUF);
592 } 633 }
593 } 634 }
594 return buf; 635 return buf;
595} 636}
596 637
597/* 638/*
598 * query_name(object) returns a character pointer pointing to a static 639 * query_name(object) returns a character pointer pointing to a static
599 * buffer which contains a verbose textual representation of the name 640 * buffer which contains a verbose textual representation of the name
… …
603 * overwritten. This may be a bad thing (it may be easier to assume the value 644 * overwritten. This may be a bad thing (it may be easier to assume the value
604 * returned is good forever.) However, it makes printing statements that 645 * returned is good forever.) However, it makes printing statements that
605 * use several names much easier (don't need to store them to temp variables.) 646 * use several names much easier (don't need to store them to temp variables.)
606 * 647 *
607 */ 648 */
649char *
608char *query_name(const object *op) { 650query_name (const object *op)
651{
609 static char buf[5][HUGE_BUF]; 652 static char buf[5][HUGE_BUF];
610 static int use_buf=0; 653 static int use_buf = 0;
611 int len=0; 654 int len = 0;
655
612#ifdef NEW_MATERIAL_CODE 656#ifdef NEW_MATERIAL_CODE
613 materialtype_t *mt; 657 materialtype_t *mt;
614#endif 658#endif
615 659
616 use_buf++; 660 use_buf++;
617 use_buf %=5; 661 use_buf %= 5;
618 662
619#ifdef NEW_MATERIAL_CODE 663#ifdef NEW_MATERIAL_CODE
620 if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname) { 664 if ((op->is_armor () || op->is_weapon ()) && op->materialname)
665 {
621 mt = name_to_material(op->materialname); 666 mt = name_to_material (op->materialname);
622 if (mt) { 667 if (mt)
668 {
623 safe_strcat(buf[use_buf], mt->description, &len, HUGE_BUF); 669 safe_strcat (buf[use_buf], mt->description, &len, HUGE_BUF);
624 safe_strcat(buf[use_buf], " ", &len, HUGE_BUF); 670 safe_strcat (buf[use_buf], " ", &len, HUGE_BUF);
625 } 671 }
626 } 672 }
627#endif 673#endif
628 674
629 safe_strcat(buf[use_buf], query_short_name(op), &len, HUGE_BUF); 675 safe_strcat (buf[use_buf], query_short_name (op), &len, HUGE_BUF);
630 676
631 if (QUERY_FLAG(op,FLAG_INV_LOCKED)) 677 if (QUERY_FLAG (op, FLAG_INV_LOCKED))
632 safe_strcat(buf[use_buf], " *", &len, HUGE_BUF); 678 safe_strcat (buf[use_buf], " *", &len, HUGE_BUF);
633 if (op->type == CONTAINER && ((op->env && op->env->container == op) || 679 if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED))))
634 (!op->env && QUERY_FLAG(op,FLAG_APPLIED))))
635 safe_strcat(buf[use_buf]," (open)", &len, HUGE_BUF); 680 safe_strcat (buf[use_buf], " (open)", &len, HUGE_BUF);
636 681
637 if (QUERY_FLAG(op,FLAG_KNOWN_CURSED)) { 682 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))
683 {
638 if(QUERY_FLAG(op,FLAG_DAMNED)) 684 if (QUERY_FLAG (op, FLAG_DAMNED))
639 safe_strcat(buf[use_buf], " (damned)", &len, HUGE_BUF); 685 safe_strcat (buf[use_buf], " (damned)", &len, HUGE_BUF);
640 else if(QUERY_FLAG(op,FLAG_CURSED)) 686 else if (QUERY_FLAG (op, FLAG_CURSED))
641 safe_strcat(buf[use_buf], " (cursed)", &len, HUGE_BUF); 687 safe_strcat (buf[use_buf], " (cursed)", &len, HUGE_BUF);
642 } 688 }
643 /* Basically, if the object is known magical (detect magic spell on it), 689 /* Basically, if the object is known magical (detect magic spell on it),
644 * and it isn't identified, print out the fact that 690 * and it isn't identified, print out the fact that
645 * it is magical. Assume that the detect magical spell will only set 691 * it is magical. Assume that the detect magical spell will only set
646 * KNOWN_MAGICAL if the item actually is magical. 692 * KNOWN_MAGICAL if the item actually is magical.
647 * 693 *
648 * Changed in V 0.91.4 - still print that the object is magical even 694 * Changed in V 0.91.4 - still print that the object is magical even
649 * if it has been applied. Equipping an item does not tell full 695 * if it has been applied. Equipping an item does not tell full
650 * abilities, especially for artifact items. 696 * abilities, especially for artifact items.
651 */ 697 */
652 if (QUERY_FLAG(op,FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op,FLAG_IDENTIFIED)) 698 if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED))
653 safe_strcat(buf[use_buf], " (magic)", &len, HUGE_BUF); 699 safe_strcat (buf[use_buf], " (magic)", &len, HUGE_BUF);
654 700
655#if 0 701#if 0
656 /* item_power will be returned in desribe_item - it shouldn't really 702 /* item_power will be returned in desribe_item - it shouldn't really
657 * be returned in the name. 703 * be returned in the name.
658 */ 704 */
659 if(op->item_power) 705 if (op->item_power)
660 sprintf(buf[use_buf]+strlen(buf[use_buf]), "(item_power %+d)", 706 sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power);
661 op->item_power);
662 707
663#endif 708#endif
664 709
665 if (QUERY_FLAG(op,FLAG_APPLIED)) { 710 if (QUERY_FLAG (op, FLAG_APPLIED))
711 {
666 switch(op->type) { 712 switch (op->type)
713 {
667 case BOW: 714 case BOW:
668 case WAND: 715 case WAND:
669 case ROD: 716 case ROD:
670 case HORN: 717 case HORN:
671 safe_strcat(buf[use_buf]," (readied)", &len, HUGE_BUF); 718 safe_strcat (buf[use_buf], " (readied)", &len, HUGE_BUF);
672 break; 719 break;
673 case WEAPON: 720 case WEAPON:
674 safe_strcat(buf[use_buf]," (wielded)", &len, HUGE_BUF); 721 safe_strcat (buf[use_buf], " (wielded)", &len, HUGE_BUF);
675 break; 722 break;
676 case ARMOUR: 723 case ARMOUR:
677 case HELMET: 724 case HELMET:
678 case SHIELD: 725 case SHIELD:
679 case RING: 726 case RING:
680 case BOOTS: 727 case BOOTS:
681 case GLOVES: 728 case GLOVES:
682 case AMULET: 729 case AMULET:
683 case GIRDLE: 730 case GIRDLE:
684 case BRACERS: 731 case BRACERS:
685 case CLOAK: 732 case CLOAK:
686 safe_strcat(buf[use_buf]," (worn)", &len, HUGE_BUF); 733 safe_strcat (buf[use_buf], " (worn)", &len, HUGE_BUF);
687 break; 734 break;
688 case CONTAINER: 735 case CONTAINER:
689 safe_strcat(buf[use_buf]," (active)", &len, HUGE_BUF); 736 safe_strcat (buf[use_buf], " (active)", &len, HUGE_BUF);
690 break; 737 break;
691 case SKILL: 738 case SKILL:
692 default: 739 default:
693 safe_strcat(buf[use_buf]," (applied)", &len, HUGE_BUF); 740 safe_strcat (buf[use_buf], " (applied)", &len, HUGE_BUF);
694 } 741 }
695 } 742 }
696 if(QUERY_FLAG(op, FLAG_UNPAID)) 743 if (QUERY_FLAG (op, FLAG_UNPAID))
697 safe_strcat(buf[use_buf]," (unpaid)", &len, HUGE_BUF); 744 safe_strcat (buf[use_buf], " (unpaid)", &len, HUGE_BUF);
698 745
699 return buf[use_buf]; 746 return buf[use_buf];
700} 747}
701 748
702/* 749/*
703 * query_base_name(object) returns a character pointer pointing to a static 750 * query_base_name(object) returns a character pointer pointing to a static
704 * buffer which contains a verbose textual representation of the name 751 * buffer which contains a verbose textual representation of the name
… …
706 * call to query_base_name(). This is a lot like query_name, but we 753 * call to query_base_name(). This is a lot like query_name, but we
707 * don't include the item count or item status. Used for inventory sorting 754 * don't include the item count or item status. Used for inventory sorting
708 * and sending to client. 755 * and sending to client.
709 * If plural is set, we generate the plural name of this. 756 * If plural is set, we generate the plural name of this.
710 */ 757 */
758const char *
711const char *query_base_name(const object *op, int plural) { 759query_base_name (const object *op, int plural)
760{
712 static char buf[MAX_BUF], buf2[MAX_BUF]; 761 static char buf[MAX_BUF], buf2[MAX_BUF];
713 int len; 762 int len;
714 materialtype_t *mt; 763 materialtype_t *mt;
715 764
716 if((!plural && !op->name) || (plural && !op->name_pl)) 765 if ((!plural && !op->name) || (plural && !op->name_pl))
717 return "(null)"; 766 return "(null)";
718 767
719 if(!op->nrof && !op->weight && !op->title && !is_magical(op)) 768 if (!op->nrof && !op->weight && !op->title && !is_magical (op))
720 return op->name; /* To speed things up (or make things slower?) */ 769 return op->name; /* To speed things up (or make things slower?) */
721 770
722 if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname) 771 if ((op->is_armor () || op->is_weapon ()) && op->materialname)
723 mt = name_to_material(op->materialname); 772 mt = name_to_material (op->materialname);
724 773
725#ifdef NEW_MATERIAL_CODE 774#ifdef NEW_MATERIAL_CODE
726 if ((IS_ARMOR(op) || IS_WEAPON(op)) && op->materialname && mt && 775 if ((op->is_armor () || op->is_weapon ()) && op->materialname && mt &&
727 op->arch->clone.materialname != mt->name && 776 op->arch->clone.materialname != mt->name && !(op->material & M_SPECIAL))
728 !(op->material & M_SPECIAL)) { 777 {
729 strcpy(buf, mt->description); 778 strcpy (buf, mt->description);
730 len=strlen(buf); 779 len = strlen (buf);
731 safe_strcat(buf, " ", &len, MAX_BUF); 780 safe_strcat (buf, " ", &len, MAX_BUF);
732 if (!plural) 781 if (!plural)
733 safe_strcat(buf, op->name, &len, MAX_BUF); 782 safe_strcat (buf, op->name, &len, MAX_BUF);
734 else 783 else
735 safe_strcat(buf, op->name_pl, &len, MAX_BUF); 784 safe_strcat (buf, op->name_pl, &len, MAX_BUF);
736 } else { 785 }
786 else
787 {
737#endif 788#endif
738 if (!plural) 789 if (!plural)
739 strcpy(buf, op->name); 790 strcpy (buf, op->name);
740 else 791 else
741 strcpy(buf, op->name_pl); 792 strcpy (buf, op->name_pl);
742 len=strlen(buf); 793 len = strlen (buf);
743#ifdef NEW_MATERIAL_CODE 794#ifdef NEW_MATERIAL_CODE
744 } 795 }
745#endif 796#endif
746 797
747 if (op->title && QUERY_FLAG(op,FLAG_IDENTIFIED)) { 798 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED))
799 {
748 safe_strcat(buf, " ", &len, MAX_BUF); 800 safe_strcat (buf, " ", &len, MAX_BUF);
749 safe_strcat(buf, op->title, &len, MAX_BUF); 801 safe_strcat (buf, op->title, &len, MAX_BUF);
750 } 802 }
751 803
752 switch(op->type) { 804 switch (op->type)
805 {
753 case SPELLBOOK: 806 case SPELLBOOK:
754 case SCROLL: 807 case SCROLL:
755 case WAND: 808 case WAND:
756 case ROD: 809 case ROD:
757 if (QUERY_FLAG(op,FLAG_IDENTIFIED)||QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { 810 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED))
811 {
758 if(!op->title) { 812 if (!op->title)
813 {
759 safe_strcat(buf," of ", &len, MAX_BUF); 814 safe_strcat (buf, " of ", &len, MAX_BUF);
760 if (op->inv) 815 if (op->inv)
761 safe_strcat(buf,op->inv->name, &len, MAX_BUF); 816 safe_strcat (buf, op->inv->name, &len, MAX_BUF);
762 else 817 else
763 LOG(llevError,"Spellbook %s lacks inventory\n", op->name); 818 LOG (llevError, "Spellbook %s lacks inventory\n", &op->name);
764 } 819 }
765 if(op->type != SPELLBOOK) { 820 if (op->type != SPELLBOOK)
821 {
766 sprintf(buf2, " (lvl %d)", op->level); 822 sprintf (buf2, " (lvl %d)", op->level);
767 safe_strcat(buf, buf2, &len, MAX_BUF); 823 safe_strcat (buf, buf2, &len, MAX_BUF);
768 } 824 }
769 } 825 }
770 break; 826 break;
771 827
772 828
773 case SKILL: 829 case SKILL:
774 case AMULET: 830 case AMULET:
775 case RING: 831 case RING:
776 if (!op->title) { 832 if (!op->title)
833 {
777 /* If ring has a title, full description isn't so useful */ 834 /* If ring has a title, full description isn't so useful */
778 char *s = ring_desc(op); 835 char *s = ring_desc (op);
836
779 if (s[0]) { 837 if (s[0])
838 {
780 safe_strcat (buf, " ", &len, MAX_BUF); 839 safe_strcat (buf, " ", &len, MAX_BUF);
781 safe_strcat (buf, s, &len, MAX_BUF); 840 safe_strcat (buf, s, &len, MAX_BUF);
841 }
782 } 842 }
783 }
784 break; 843 break;
785 default: 844 default:
786 if(op->magic && ((QUERY_FLAG(op,FLAG_BEEN_APPLIED) && 845 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED)))
787 need_identify(op)) || QUERY_FLAG(op,FLAG_IDENTIFIED))) { 846 {
788 sprintf(buf + strlen(buf), " %+d", op->magic); 847 sprintf (buf + strlen (buf), " %+d", op->magic);
789 } 848 }
790 } 849 }
791 return buf; 850 return buf;
792} 851}
793 852
794/* Break this off from describe_item - that function was way 853/* Break this off from describe_item - that function was way
795 * too long, making it difficult to read. This function deals 854 * too long, making it difficult to read. This function deals
796 * with describing the monsters & players abilities. It should only 855 * with describing the monsters & players abilities. It should only
797 * be called with monster & player objects. Returns a description 856 * be called with monster & player objects. Returns a description
798 * in a static buffer. 857 * in a static buffer.
799 */ 858 */
800 859
860static char *
801static char *describe_monster(const object *op) { 861describe_monster (const object *op)
862{
802 char buf[MAX_BUF]; 863 char buf[MAX_BUF];
803 static char retbuf[VERY_BIG_BUF]; 864 static char retbuf[VERY_BIG_BUF];
804 int i; 865 int i;
805 866
806 retbuf[0]='\0'; 867 retbuf[0] = '\0';
807 868
808 /* Note that the resolution this provides for players really isn't 869 /* Note that the resolution this provides for players really isn't
809 * very good. Any player with a speed greater than .67 will 870 * very good. Any player with a speed greater than .67 will
810 * fall into the 'lightning fast movement' category. 871 * fall into the 'lightning fast movement' category.
811 */ 872 */
812 if(FABS(op->speed)>MIN_ACTIVE_SPEED) { 873 if (op->has_active_speed ())
874 {
813 switch((int)((FABS(op->speed))*15)) { 875 switch ((int) ((FABS (op->speed)) * 15))
876 {
814 case 0: 877 case 0:
815 strcat(retbuf,"(very slow movement)"); 878 strcat (retbuf, "(very slow movement)");
816 break; 879 break;
817 case 1: 880 case 1:
818 strcat(retbuf,"(slow movement)"); 881 strcat (retbuf, "(slow movement)");
819 break; 882 break;
820 case 2: 883 case 2:
821 strcat(retbuf,"(normal movement)"); 884 strcat (retbuf, "(normal movement)");
822 break; 885 break;
823 case 3: 886 case 3:
824 case 4: 887 case 4:
825 strcat(retbuf,"(fast movement)"); 888 strcat (retbuf, "(fast movement)");
826 break; 889 break;
827 case 5: 890 case 5:
828 case 6: 891 case 6:
829 strcat(retbuf,"(very fast movement)"); 892 strcat (retbuf, "(very fast movement)");
830 break; 893 break;
831 case 7: 894 case 7:
832 case 8: 895 case 8:
833 case 9: 896 case 9:
834 case 10: 897 case 10:
835 strcat(retbuf,"(extremely fast movement)"); 898 strcat (retbuf, "(extremely fast movement)");
836 break; 899 break;
837 default: 900 default:
838 strcat(retbuf,"(lightning fast movement)"); 901 strcat (retbuf, "(lightning fast movement)");
839 break; 902 break;
840 } 903 }
841 } 904 }
842 if(QUERY_FLAG(op,FLAG_UNDEAD)) 905 if (QUERY_FLAG (op, FLAG_UNDEAD))
843 strcat(retbuf,"(undead)"); 906 strcat (retbuf, "(undead)");
844 if(QUERY_FLAG(op,FLAG_SEE_INVISIBLE)) 907 if (QUERY_FLAG (op, FLAG_SEE_INVISIBLE))
845 strcat(retbuf,"(see invisible)"); 908 strcat (retbuf, "(see invisible)");
846 if(QUERY_FLAG(op,FLAG_USE_WEAPON)) 909 if (QUERY_FLAG (op, FLAG_USE_WEAPON))
847 strcat(retbuf,"(wield weapon)"); 910 strcat (retbuf, "(wield weapon)");
848 if(QUERY_FLAG(op,FLAG_USE_BOW)) 911 if (QUERY_FLAG (op, FLAG_USE_BOW))
849 strcat(retbuf,"(archer)"); 912 strcat (retbuf, "(archer)");
850 if(QUERY_FLAG(op,FLAG_USE_ARMOUR)) 913 if (QUERY_FLAG (op, FLAG_USE_ARMOUR))
851 strcat(retbuf,"(wear armour)"); 914 strcat (retbuf, "(wear armour)");
852 if(QUERY_FLAG(op,FLAG_USE_RING)) 915 if (QUERY_FLAG (op, FLAG_USE_RING))
853 strcat(retbuf,"(wear ring)"); 916 strcat (retbuf, "(wear ring)");
854 if(QUERY_FLAG(op,FLAG_USE_SCROLL)) 917 if (QUERY_FLAG (op, FLAG_USE_SCROLL))
855 strcat(retbuf,"(read scroll)"); 918 strcat (retbuf, "(read scroll)");
856 if(QUERY_FLAG(op,FLAG_USE_RANGE)) 919 if (QUERY_FLAG (op, FLAG_USE_RANGE))
857 strcat(retbuf,"(fires wand/rod/horn)"); 920 strcat (retbuf, "(fires wand/rod/horn)");
858 if(QUERY_FLAG(op,FLAG_CAN_USE_SKILL)) 921 if (QUERY_FLAG (op, FLAG_CAN_USE_SKILL))
859 strcat(retbuf,"(skill user)"); 922 strcat (retbuf, "(skill user)");
860 if(QUERY_FLAG(op,FLAG_CAST_SPELL)) 923 if (QUERY_FLAG (op, FLAG_CAST_SPELL))
861 strcat(retbuf,"(spellcaster)"); 924 strcat (retbuf, "(spellcaster)");
862 if(QUERY_FLAG(op,FLAG_FRIENDLY)) 925 if (QUERY_FLAG (op, FLAG_FRIENDLY))
863 strcat(retbuf,"(friendly)"); 926 strcat (retbuf, "(friendly)");
864 if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE)) 927 if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE))
865 strcat(retbuf,"(unaggressive)"); 928 strcat (retbuf, "(unaggressive)");
866 if(QUERY_FLAG(op,FLAG_HITBACK)) 929 if (QUERY_FLAG (op, FLAG_HITBACK))
867 strcat(retbuf,"(hitback)"); 930 strcat (retbuf, "(hitback)");
868 if(QUERY_FLAG(op,FLAG_STEALTH)) 931 if (QUERY_FLAG (op, FLAG_STEALTH))
869 strcat(retbuf,"(stealthy)"); 932 strcat (retbuf, "(stealthy)");
870 if(op->randomitems != NULL) { 933 if (op->randomitems != NULL)
934 {
871 treasure *t; 935 treasure *t;
872 int first = 1; 936 int first = 1;
937
873 for(t=op->randomitems->items; t != NULL; t=t->next) 938 for (t = op->randomitems->items; t != NULL; t = t->next)
874 if(t->item && (t->item->clone.type == SPELL)) { 939 if (t->item && t->item->clone.type == SPELL)
940 {
875 if(first) { 941 if (first)
942 {
876 first = 0; 943 first = 0;
877 strcat(retbuf,"(Spell abilities:)"); 944 strcat (retbuf, "(Spell abilities:)");
878 } 945 }
879 strcat(retbuf,"("); 946 strcat (retbuf, "(");
880 strcat(retbuf,t->item->clone.name); 947 strcat (retbuf, t->item->clone.name);
881 strcat(retbuf,")"); 948 strcat (retbuf, ")");
882 } 949 }
883 } 950 }
884 if (op->type == PLAYER) { 951 if (op->type == PLAYER)
952 {
885 if(op->contr->digestion) { 953 if (op->contr->digestion)
954 {
886 if(op->contr->digestion!=0) 955 if (op->contr->digestion != 0)
887 sprintf(buf,"(sustenance%+d)",op->contr->digestion); 956 sprintf (buf, "(sustenance%+d)", op->contr->digestion);
888 strcat(retbuf,buf); 957 strcat (retbuf, buf);
889 } 958 }
890 if(op->contr->gen_grace) { 959 if (op->contr->gen_grace)
960 {
891 sprintf(buf,"(grace%+d)",op->contr->gen_grace); 961 sprintf (buf, "(grace%+d)", op->contr->gen_grace);
892 strcat(retbuf,buf); 962 strcat (retbuf, buf);
893 } 963 }
894 if(op->contr->gen_sp) { 964 if (op->contr->gen_sp)
965 {
895 sprintf(buf,"(magic%+d)",op->contr->gen_sp); 966 sprintf (buf, "(magic%+d)", op->contr->gen_sp);
896 strcat(retbuf,buf); 967 strcat (retbuf, buf);
897 } 968 }
898 if(op->contr->gen_hp) { 969 if (op->contr->gen_hp)
970 {
899 sprintf(buf,"(regeneration%+d)",op->contr->gen_hp); 971 sprintf (buf, "(regeneration%+d)", op->contr->gen_hp);
900 strcat(retbuf,buf); 972 strcat (retbuf, buf);
901 } 973 }
902 if(op->stats.luck) { 974 if (op->stats.luck)
975 {
903 sprintf(buf,"(luck%+d)",op->stats.luck); 976 sprintf (buf, "(luck%+d)", op->stats.luck);
904 strcat(retbuf,buf); 977 strcat (retbuf, buf);
905 } 978 }
906 } 979 }
907 980
908 /* describe attacktypes */ 981 /* describe attacktypes */
909 if (is_dragon_pl(op)) { 982 if (is_dragon_pl (op))
983 {
910 /* for dragon players display the attacktypes from clawing skill 984 /* for dragon players display the attacktypes from clawing skill
911 * Break apart the for loop - move the comparison checking down - 985 * Break apart the for loop - move the comparison checking down -
912 * this makes it more readable. 986 * this makes it more readable.
913 */ 987 */
914 object *tmp; 988 object *tmp;
989
990 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
991 if (tmp->type == SKILL && !strcmp (tmp->name, "clawing"))
992 break;
993
994 if (tmp && tmp->attacktype != 0)
915 995 {
916 for (tmp=op->inv; tmp!=NULL; tmp=tmp->below)
917 if (tmp->type == SKILL && !strcmp(tmp->name, "clawing")) break;
918
919 if (tmp && tmp->attacktype!=0) {
920 DESCRIBE_ABILITY(retbuf, tmp->attacktype, "Claws"); 996 DESCRIBE_ABILITY (retbuf, tmp->attacktype, "Claws");
997 }
998 else
921 } 999 {
922 else {
923 DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks");
924 }
925 } else {
926 DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks"); 1000 DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks");
1001 }
1002 }
1003 else
927 } 1004 {
1005 DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks");
1006 }
928 DESCRIBE_PATH(retbuf, op->path_attuned, "Attuned"); 1007 DESCRIBE_PATH (retbuf, op->path_attuned, "Attuned");
929 DESCRIBE_PATH(retbuf, op->path_repelled, "Repelled"); 1008 DESCRIBE_PATH (retbuf, op->path_repelled, "Repelled");
930 DESCRIBE_PATH(retbuf, op->path_denied, "Denied"); 1009 DESCRIBE_PATH (retbuf, op->path_denied, "Denied");
931 for (i=0; i < NROFATTACKS; i++) { 1010 for (i = 0; i < NROFATTACKS; i++)
1011 {
932 if (op->resist[i]) { 1012 if (op->resist[i])
1013 {
933 sprintf(buf, "(%s %+d)", resist_plus[i], op->resist[i]); 1014 sprintf (buf, "(%s %+d)", resist_plus[i], op->resist[i]);
934 strcat(retbuf, buf); 1015 strcat (retbuf, buf);
935 } 1016 }
936 } 1017 }
937 return retbuf; 1018 return retbuf;
938} 1019}
939 1020
940 1021
941/* 1022/*
942 * Returns a pointer to a static buffer which contains a 1023 * Returns a pointer to a static buffer which contains a
… …
963 * Add 'owner' who is the person examining this object. 1044 * Add 'owner' who is the person examining this object.
964 * owner can be null if no one is being associated with this 1045 * owner can be null if no one is being associated with this
965 * item (eg, debug dump or the like) 1046 * item (eg, debug dump or the like)
966 */ 1047 */
967 1048
1049char *
968char *describe_item(const object *op, object *owner) { 1050describe_item (const object *op, object *owner)
1051{
969 char buf[MAX_BUF]; 1052 char buf[MAX_BUF];
970 static char retbuf[VERY_BIG_BUF]; 1053 static char retbuf[VERY_BIG_BUF];
971 int identified,i; 1054 int identified, i;
972 1055
973 retbuf[0]='\0'; 1056 retbuf[0] = '\0';
974 if(QUERY_FLAG(op,FLAG_MONSTER) || op->type==PLAYER) { 1057 if (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER)
1058 {
975 return describe_monster(op); 1059 return describe_monster (op);
976 } 1060 }
977 /* figure this out once, instead of making multiple calls to need_identify. 1061 /* figure this out once, instead of making multiple calls to need_identify.
978 * also makes the code easier to read. 1062 * also makes the code easier to read.
979 */ 1063 */
980 if (!need_identify(op) || QUERY_FLAG(op, FLAG_IDENTIFIED)) identified = 1; 1064 if (!need_identify (op) || QUERY_FLAG (op, FLAG_IDENTIFIED))
1065 identified = 1;
981 else { 1066 else
1067 {
982 strcpy(retbuf,"(unidentified)"); 1068 strcpy (retbuf, "(unidentified)");
983 identified = 0; 1069 identified = 0;
984 } 1070 }
985 switch(op->type) { 1071 switch (op->type)
1072 {
986 case BOW: 1073 case BOW:
987 case ARROW: 1074 case ARROW:
988 case WAND: 1075 case WAND:
989 case ROD: 1076 case ROD:
990 case HORN: 1077 case HORN:
… …
996 case GLOVES: 1083 case GLOVES:
997 case GIRDLE: 1084 case GIRDLE:
998 case BRACERS: 1085 case BRACERS:
999 case CLOAK: 1086 case CLOAK:
1000 case SKILL_TOOL: 1087 case SKILL_TOOL:
1001 break; /* We have more information to do below this switch */ 1088 break; /* We have more information to do below this switch */
1002 1089
1003 case POWER_CRYSTAL: 1090 case POWER_CRYSTAL:
1004 if (op->stats.maxsp>1000){ /*higher capacity crystals*/ 1091 if (op->stats.maxsp > 1000)
1092 { /*higher capacity crystals */
1005 i = (op->stats.maxsp%100)/10; 1093 i = (op->stats.maxsp % 100) / 10;
1006 if (i) 1094 if (i)
1007 snprintf(buf,MAX_BUF,"(capacity %d.%dk). It is ",op->stats.maxsp/100,i); 1095 snprintf (buf, MAX_BUF, "(capacity %d.%dk). It is ", op->stats.maxsp / 100, i);
1008 else 1096 else
1009 snprintf(buf,MAX_BUF,"(capacity %dk). It is ",op->stats.maxsp/100); 1097 snprintf (buf, MAX_BUF, "(capacity %dk). It is ", op->stats.maxsp / 100);
1098 }
1010 }else 1099 else
1011 snprintf(buf,MAX_BUF,"(capacity %d). It is ",op->stats.maxsp); 1100 snprintf (buf, MAX_BUF, "(capacity %d). It is ", op->stats.maxsp);
1012 strcat(retbuf,buf); 1101 strcat (retbuf, buf);
1013 i = (op->stats.sp*10)/op->stats.maxsp; 1102 i = (op->stats.sp * 10) / op->stats.maxsp;
1014 if (op->stats.sp==0) 1103 if (op->stats.sp == 0)
1015 strcat(retbuf,"empty."); 1104 strcat (retbuf, "empty.");
1016 else if (i==0) 1105 else if (i == 0)
1017 strcat(retbuf,"almost empty."); 1106 strcat (retbuf, "almost empty.");
1018 else if (i<3) 1107 else if (i < 3)
1019 strcat(retbuf,"partially filled."); 1108 strcat (retbuf, "partially filled.");
1020 else if (i<6) 1109 else if (i < 6)
1021 strcat(retbuf,"half full."); 1110 strcat (retbuf, "half full.");
1022 else if (i<9) 1111 else if (i < 9)
1023 strcat(retbuf,"well charged."); 1112 strcat (retbuf, "well charged.");
1024 else if (op->stats.sp == op->stats.maxsp) 1113 else if (op->stats.sp == op->stats.maxsp)
1025 strcat(retbuf,"fully charged."); 1114 strcat (retbuf, "fully charged.");
1026 else 1115 else
1027 strcat(retbuf,"almost full."); 1116 strcat (retbuf, "almost full.");
1028 break; 1117 break;
1029 case FOOD: 1118 case FOOD:
1030 case FLESH: 1119 case FLESH:
1031 case DRINK: 1120 case DRINK:
1032 if(identified || QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { 1121 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED))
1122 {
1033 sprintf(buf,"(food+%d)", op->stats.food); 1123 sprintf (buf, "(food+%d)", op->stats.food);
1034 strcat(retbuf, buf); 1124 strcat (retbuf, buf);
1035 1125
1036 if (op->type == FLESH && op->last_eat>0 && atnr_is_dragon_enabled(op->last_eat)) { 1126 if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled (op->last_eat))
1127 {
1037 sprintf(buf, "(%s metabolism)", change_resist_msg[op->last_eat]); 1128 sprintf (buf, "(%s metabolism)", change_resist_msg[op->last_eat]);
1038 strcat(retbuf, buf); 1129 strcat (retbuf, buf);
1039 } 1130 }
1040 1131
1041 if (!QUERY_FLAG(op,FLAG_CURSED)) { 1132 if (!QUERY_FLAG (op, FLAG_CURSED))
1133 {
1042 if (op->stats.hp) 1134 if (op->stats.hp)
1043 strcat(retbuf,"(heals)"); 1135 strcat (retbuf, "(heals)");
1044 if (op->stats.sp) 1136 if (op->stats.sp)
1045 strcat(retbuf,"(spellpoint regen)"); 1137 strcat (retbuf, "(spellpoint regen)");
1046 } 1138 }
1047 else { 1139 else
1140 {
1048 if (op->stats.hp) 1141 if (op->stats.hp)
1049 strcat(retbuf,"(damages)"); 1142 strcat (retbuf, "(damages)");
1050 if (op->stats.sp) 1143 if (op->stats.sp)
1051 strcat(retbuf,"(spellpoint depletion)"); 1144 strcat (retbuf, "(spellpoint depletion)");
1052 } 1145 }
1053 } 1146 }
1054 break; 1147 break;
1055 1148
1056 1149
1057 case SKILL: 1150 case SKILL:
1058 case RING: 1151 case RING:
1059 case AMULET: 1152 case AMULET:
1060 if(op->item_power) { 1153 if (op->item_power)
1154 {
1061 sprintf(buf,"(item_power %+d)",op->item_power); 1155 sprintf (buf, "(item_power %+d)", op->item_power);
1062 strcat(retbuf,buf); 1156 strcat (retbuf, buf);
1063 } 1157 }
1064 if (op->title) 1158 if (op->title)
1065 strcat (retbuf, ring_desc(op)); 1159 strcat (retbuf, ring_desc (op));
1066 return retbuf; 1160 return retbuf;
1067 1161
1068 default: 1162 default:
1069 return retbuf; 1163 return retbuf;
1070 } 1164 }
1071 1165
1072 /* Down here, we more further describe equipment type items. 1166 /* Down here, we more further describe equipment type items.
1073 * only describe them if they have been identified or the like. 1167 * only describe them if they have been identified or the like.
1074 */ 1168 */
1075 if (identified || QUERY_FLAG(op,FLAG_BEEN_APPLIED)) { 1169 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED))
1170 {
1076 int attr,val; 1171 int attr, val;
1077 1172
1078 for (attr=0; attr<NUM_STATS; attr++) { 1173 for (attr = 0; attr < NUM_STATS; attr++)
1174 {
1079 if ((val=get_attr_value(&(op->stats),attr))!=0) { 1175 if ((val = get_attr_value (&(op->stats), attr)) != 0)
1176 {
1080 sprintf(buf, "(%s%+d)", short_stat_name[attr], val); 1177 sprintf (buf, "(%s%+d)", short_stat_name[attr], val);
1081 strcat(retbuf,buf); 1178 strcat (retbuf, buf);
1082 } 1179 }
1083 } 1180 }
1084 1181
1085 if(op->stats.exp) { 1182 if (op->stats.exp)
1183 {
1086 sprintf(buf,"(speed %+lld)",op->stats.exp); 1184 sprintf (buf, "(speed %+lld)", (long long) op->stats.exp);
1087 strcat(retbuf,buf); 1185 strcat (retbuf, buf);
1088 } 1186 }
1089 1187
1090 1188
1091 switch(op->type) { 1189 switch (op->type)
1190 {
1092 case BOW: 1191 case BOW:
1093 case ARROW: 1192 case ARROW:
1094 case GIRDLE: 1193 case GIRDLE:
1095 case HELMET: 1194 case HELMET:
1096 case SHIELD: 1195 case SHIELD:
… …
1102 case AMULET: 1201 case AMULET:
1103 case ARMOUR: 1202 case ARMOUR:
1104 case BRACERS: 1203 case BRACERS:
1105 case FORCE: 1204 case FORCE:
1106 case CLOAK: 1205 case CLOAK:
1107 if(op->stats.wc) { 1206 if (op->stats.wc)
1207 {
1108 sprintf(buf,"(wc%+d)",op->stats.wc); 1208 sprintf (buf, "(wc%+d)", op->stats.wc);
1109 strcat(retbuf,buf); 1209 strcat (retbuf, buf);
1110 } 1210 }
1111 if(op->stats.dam) { 1211 if (op->stats.dam)
1212 {
1112 sprintf(buf,"(dam%+d)",op->stats.dam); 1213 sprintf (buf, "(dam%+d)", op->stats.dam);
1113 strcat(retbuf,buf); 1214 strcat (retbuf, buf);
1114 } 1215 }
1115 if(op->stats.ac) { 1216 if (op->stats.ac)
1217 {
1116 sprintf(buf,"(ac%+d)",op->stats.ac); 1218 sprintf (buf, "(ac%+d)", op->stats.ac);
1117 strcat(retbuf,buf); 1219 strcat (retbuf, buf);
1118 } 1220 }
1119 if ((op->type==WEAPON || op->type == BOW) && op->level>0) { 1221 if ((op->type == WEAPON || op->type == BOW) && op->level > 0)
1222 {
1120 sprintf(buf,"(improved %d/%d)",op->last_eat,op->level); 1223 sprintf (buf, "(improved %d/%d)", op->last_eat, op->level);
1121 strcat(retbuf,buf); 1224 strcat (retbuf, buf);
1122 } 1225 }
1123 break; 1226 break;
1124 1227
1125 default: 1228 default:
1126 break; 1229 break;
1127 } 1230 }
1128 if(QUERY_FLAG(op,FLAG_XRAYS)) 1231 if (QUERY_FLAG (op, FLAG_XRAYS))
1129 strcat(retbuf,"(xray-vision)"); 1232 strcat (retbuf, "(xray-vision)");
1130 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK)) 1233 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
1131 strcat(retbuf,"(infravision)"); 1234 strcat (retbuf, "(infravision)");
1132 1235
1133 /* levitate was what is was before, so we'll keep it */ 1236 /* levitate was what is was before, so we'll keep it */
1134 if (op->move_type & MOVE_FLY_LOW) 1237 if (op->move_type & MOVE_FLY_LOW)
1135 strcat(retbuf,"(levitate)"); 1238 strcat (retbuf, "(levitate)");
1136 1239
1137 if (op->move_type & MOVE_FLY_HIGH) 1240 if (op->move_type & MOVE_FLY_HIGH)
1138 strcat(retbuf,"(fly)"); 1241 strcat (retbuf, "(fly)");
1139 1242
1140 if (op->move_type & MOVE_SWIM) 1243 if (op->move_type & MOVE_SWIM)
1141 strcat(retbuf,"(swim)"); 1244 strcat (retbuf, "(swim)");
1142 1245
1143 /* walking is presumed as 'normal', so doesn't need mentioning */ 1246 /* walking is presumed as 'normal', so doesn't need mentioning */
1144 1247
1145 if(op->item_power) { 1248 if (op->item_power)
1249 {
1146 sprintf(buf,"(item_power %+d)",op->item_power); 1250 sprintf (buf, "(item_power %+d)", op->item_power);
1147 strcat(retbuf,buf); 1251 strcat (retbuf, buf);
1148 } 1252 }
1149 } /* End if identified or applied */ 1253 } /* End if identified or applied */
1150 1254
1151 /* This blocks only deals with fully identified object. 1255 /* This blocks only deals with fully identified object.
1152 * it is intentional that this is not an 'else' from a above - 1256 * it is intentional that this is not an 'else' from a above -
1153 * in this way, information is added. 1257 * in this way, information is added.
1154 */ 1258 */
1155 if(identified) { 1259 if (identified)
1260 {
1156 int more_info = 0; 1261 int more_info = 0;
1157 1262
1158 switch(op->type) { 1263 switch (op->type)
1264 {
1159 case ROD: /* These use stats.sp for spell selection and stats.food */ 1265 case ROD: /* These use stats.sp for spell selection and stats.food */
1160 case HORN: /* and stats.hp for spell-point regeneration... */ 1266 case HORN: /* and stats.hp for spell-point regeneration... */
1161 case BOW: 1267 case BOW:
1162 case ARROW: 1268 case ARROW:
1163 case WAND: 1269 case WAND:
1164 case FOOD: 1270 case FOOD:
1165 case FLESH: 1271 case FLESH:
1166 case DRINK: 1272 case DRINK:
1167 more_info = 0; 1273 more_info = 0;
1168 break; 1274 break;
1169 1275
1170 /* Armor type objects */ 1276 /* Armor type objects */
1171 case ARMOUR: 1277 case ARMOUR:
1172 case HELMET: 1278 case HELMET:
1173 case SHIELD: 1279 case SHIELD:
1174 case BOOTS: 1280 case BOOTS:
1175 case GLOVES: 1281 case GLOVES:
1176 case GIRDLE: 1282 case GIRDLE:
1177 case BRACERS: 1283 case BRACERS:
1178 case CLOAK: 1284 case CLOAK:
1179 if (ARMOUR_SPEED(op)) { 1285 if (ARMOUR_SPEED (op))
1286 {
1180 sprintf(buf,"(Max speed %1.2f)", ARMOUR_SPEED(op) / 10.0); 1287 sprintf (buf, "(Max speed %1.2f)", ARMOUR_SPEED (op) / 10.0);
1181 strcat(retbuf, buf); 1288 strcat (retbuf, buf);
1182 } 1289 }
1183 if (ARMOUR_SPELLS(op)) { 1290 if (ARMOUR_SPELLS (op))
1291 {
1184 sprintf(buf,"(Spell regen penalty %d)", ARMOUR_SPELLS(op)); 1292 sprintf (buf, "(Spell regen penalty %d)", ARMOUR_SPELLS (op));
1185 strcat(retbuf, buf); 1293 strcat (retbuf, buf);
1186 } 1294 }
1187 more_info=1; 1295 more_info = 1;
1188 break; 1296 break;
1189 1297
1190 case WEAPON: 1298 case WEAPON:
1191 /* Calculate it the same way fix_player does so the results 1299 /* Calculate it the same way fix_player does so the results
1192 * make sense. 1300 * make sense.
1193 */ 1301 */
1194 i = (WEAPON_SPEED(op)*2-op->magic)/2; 1302 i = (WEAPON_SPEED (op) * 2 - op->magic) / 2;
1195 if (i<0) i=0; 1303 if (i < 0)
1304 i = 0;
1196 1305
1197 sprintf(buf,"(weapon speed %d)", i); 1306 sprintf (buf, "(weapon speed %d)", i);
1198 strcat(retbuf, buf); 1307 strcat (retbuf, buf);
1199 more_info=1; 1308 more_info = 1;
1200 break; 1309 break;
1201 1310
1202 } 1311 }
1203 if (more_info) { 1312 if (more_info)
1313 {
1204 if(op->stats.food) { 1314 if (op->stats.food)
1315 {
1205 if(op->stats.food!=0) 1316 if (op->stats.food != 0)
1206 sprintf(buf,"(sustenance%+d)",op->stats.food); 1317 sprintf (buf, "(sustenance%+d)", op->stats.food);
1207 strcat(retbuf,buf); 1318 strcat (retbuf, buf);
1208 } 1319 }
1209 if(op->stats.grace) { 1320 if (op->stats.grace)
1321 {
1210 sprintf(buf,"(grace%+d)",op->stats.grace); 1322 sprintf (buf, "(grace%+d)", op->stats.grace);
1211 strcat(retbuf,buf); 1323 strcat (retbuf, buf);
1212 } 1324 }
1213 if(op->stats.sp) { 1325 if (op->stats.sp)
1326 {
1214 sprintf(buf,"(magic%+d)",op->stats.sp); 1327 sprintf (buf, "(magic%+d)", op->stats.sp);
1215 strcat(retbuf,buf); 1328 strcat (retbuf, buf);
1216 } 1329 }
1217 if(op->stats.hp) { 1330 if (op->stats.hp)
1331 {
1218 sprintf(buf,"(regeneration%+d)",op->stats.hp); 1332 sprintf (buf, "(regeneration%+d)", op->stats.hp);
1219 strcat(retbuf,buf); 1333 strcat (retbuf, buf);
1220 } 1334 }
1221 } 1335 }
1222 1336
1223 if(op->stats.luck) { 1337 if (op->stats.luck)
1338 {
1224 sprintf(buf,"(luck%+d)",op->stats.luck); 1339 sprintf (buf, "(luck%+d)", op->stats.luck);
1225 strcat(retbuf,buf); 1340 strcat (retbuf, buf);
1226 } 1341 }
1227 if(QUERY_FLAG(op,FLAG_LIFESAVE)) 1342 if (QUERY_FLAG (op, FLAG_LIFESAVE))
1228 strcat(retbuf,"(lifesaving)"); 1343 strcat (retbuf, "(lifesaving)");
1229 if(QUERY_FLAG(op,FLAG_REFL_SPELL)) 1344 if (QUERY_FLAG (op, FLAG_REFL_SPELL))
1230 strcat(retbuf,"(reflect spells)"); 1345 strcat (retbuf, "(reflect spells)");
1231 if(QUERY_FLAG(op,FLAG_REFL_MISSILE)) 1346 if (QUERY_FLAG (op, FLAG_REFL_MISSILE))
1232 strcat(retbuf,"(reflect missiles)"); 1347 strcat (retbuf, "(reflect missiles)");
1233 if(QUERY_FLAG(op,FLAG_STEALTH)) 1348 if (QUERY_FLAG (op, FLAG_STEALTH))
1234 strcat(retbuf,"(stealth)"); 1349 strcat (retbuf, "(stealth)");
1235 if(op->slaying!=NULL && op->type != FOOD) { 1350 if (op->slaying != NULL && op->type != FOOD)
1351 {
1236 sprintf(buf,"(slay %s)",op->slaying); 1352 sprintf (buf, "(slay %s)", &op->slaying);
1237 strcat(retbuf,buf); 1353 strcat (retbuf, buf);
1238 } 1354 }
1239 DESCRIBE_ABILITY(retbuf, op->attacktype, "Attacks"); 1355 DESCRIBE_ABILITY (retbuf, op->attacktype, "Attacks");
1240 /* resistance on flesh is only visible for quetzals. If 1356 /* resistance on flesh is only visible for quetzals. If
1241 * non flesh, everyone can see its resistances 1357 * non flesh, everyone can see its resistances
1242 */ 1358 */
1243 if (op->type != FLESH || (owner && is_dragon_pl(owner))) 1359 if (op->type != FLESH || (owner && is_dragon_pl (owner)))
1244 strcat(retbuf,describe_resistance(op, 0)); 1360 strcat (retbuf, describe_resistance (op, 0));
1245 DESCRIBE_PATH(retbuf, op->path_attuned, "Attuned"); 1361 DESCRIBE_PATH (retbuf, op->path_attuned, "Attuned");
1246 DESCRIBE_PATH(retbuf, op->path_repelled, "Repelled"); 1362 DESCRIBE_PATH (retbuf, op->path_repelled, "Repelled");
1247 DESCRIBE_PATH(retbuf, op->path_denied, "Denied"); 1363 DESCRIBE_PATH (retbuf, op->path_denied, "Denied");
1248 } 1364 }
1249 1365
1250 return retbuf; 1366 return retbuf;
1251} 1367}
1252 1368
1253/* Return true if the item is magical. A magical item is one that 1369/* Return true if the item is magical. A magical item is one that
1254 * increases/decreases any abilities, provides a resistance, 1370 * increases/decreases any abilities, provides a resistance,
1255 * has a generic magical bonus, or is an artifact. 1371 * has a generic magical bonus, or is an artifact.
1256 * This function is used by detect_magic to determine if an item 1372 * This function is used by detect_magic to determine if an item
1257 * should be marked as magical. 1373 * should be marked as magical.
1258 */ 1374 */
1259 1375
1376int
1260int is_magical(const object *op) { 1377is_magical (const object *op)
1378{
1261 int i; 1379 int i;
1262 1380
1263 /* living creatures are considered non magical */ 1381 /* living creatures are considered non magical */
1264 if (QUERY_FLAG(op, FLAG_ALIVE)) return 0; 1382 if (QUERY_FLAG (op, FLAG_ALIVE))
1265
1266 /* This is a test for it being an artifact, as artifacts have titles */
1267 if (op->title!=NULL) return 1;
1268
1269 /* Handle rings and amulets specially. If they change any of these
1270 * values, it means they are magical.
1271 */
1272 if ((op->type==AMULET || op->type==RING) &&
1273 (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam ||
1274 op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck))
1275 return 1;
1276
1277 /* Check for stealty, speed, flying, or just plain magic in the boots */
1278 /* Presume any boots that hvae a move_type are special. */
1279 if (op->type== BOOTS &&
1280 ((QUERY_FLAG(op, FLAG_STEALTH) || op->move_type || op->stats.exp)))
1281 return 1;
1282
1283 /* Take care of amulet/shield that reflects spells/missiles */
1284 if ((op->type==AMULET || op->type==SHIELD) &&
1285 (QUERY_FLAG(op, FLAG_REFL_SPELL) || QUERY_FLAG(op, FLAG_REFL_MISSILE)))
1286 return 1;
1287
1288 /* Take care of helmet of xrays */
1289 if (op->type==HELMET && QUERY_FLAG(op,FLAG_XRAYS)) return 1;
1290
1291 /* Potions & rods are always magical. Wands/staves are also magical,
1292 * assuming they still have any charges left.
1293 */
1294 if (op->type==POTION || op->type==ROD ||
1295 (op->type==WAND && op->stats.food))
1296 return 1;
1297
1298 /* if something gives a protection, either positive or negative, its magical */
1299 /* This is really a pretty bad hack - as of now, ATNR_PHYSICAL is 0,
1300 * so this always works out fine.
1301 */
1302 for (i=ATNR_PHYSICAL+1; i<NROFATTACKS; i++)
1303 if (op->resist[i]) return 1;
1304
1305 /* Physical protection is expected on some item types, so they should
1306 * not be considered magical.
1307 */
1308 if (op->resist[ATNR_PHYSICAL] && op->type != HELMET && op->type != SHIELD &&
1309 op->type != BOOTS && op->type != GLOVES && op->type != ARMOUR) return 1;
1310
1311 /* power crystal, spellbooks, and scrolls are always magical. */
1312 if (op->magic || op->type==POWER_CRYSTAL || op->type==SPELLBOOK ||
1313 op->type==SCROLL || op->type==GIRDLE)
1314 return 1;
1315
1316 /* Check to see if it increases/decreases any stats */
1317 for (i=0; i<NUM_STATS; i++)
1318 if (get_attr_value(&(op->stats),i)!=0) return 1;
1319
1320 /* If it doesn't fall into any of the above categories, must
1321 * be non magical.
1322 */
1323 return 0; 1383 return 0;
1384
1385 /* This is a test for it being an artifact, as artifacts have titles */
1386 if (op->title != NULL)
1387 return 1;
1388
1389 /* Handle rings and amulets specially. If they change any of these
1390 * values, it means they are magical.
1391 */
1392 if ((op->type == AMULET || op->type == RING) &&
1393 (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck))
1394 return 1;
1395
1396 /* Check for stealty, speed, flying, or just plain magic in the boots */
1397 /* Presume any boots that hvae a move_type are special. */
1398 if (op->type == BOOTS && ((QUERY_FLAG (op, FLAG_STEALTH) || op->move_type || op->stats.exp)))
1399 return 1;
1400
1401 /* Take care of amulet/shield that reflects spells/missiles */
1402 if ((op->type == AMULET || op->type == SHIELD) && (QUERY_FLAG (op, FLAG_REFL_SPELL) || QUERY_FLAG (op, FLAG_REFL_MISSILE)))
1403 return 1;
1404
1405 /* Take care of helmet of xrays */
1406 if (op->type == HELMET && QUERY_FLAG (op, FLAG_XRAYS))
1407 return 1;
1408
1409 /* Potions & rods are always magical. Wands/staves are also magical,
1410 * assuming they still have any charges left.
1411 */
1412 if (op->type == POTION || op->type == ROD || (op->type == WAND && op->stats.food))
1413 return 1;
1414
1415 /* if something gives a protection, either positive or negative, its magical */
1416 /* This is really a pretty bad hack - as of now, ATNR_PHYSICAL is 0,
1417 * so this always works out fine.
1418 */
1419 for (i = ATNR_PHYSICAL + 1; i < NROFATTACKS; i++)
1420 if (op->resist[i])
1421 return 1;
1422
1423 /* Physical protection is expected on some item types, so they should
1424 * not be considered magical.
1425 */
1426 if (op->resist[ATNR_PHYSICAL] && op->type != HELMET && op->type != SHIELD &&
1427 op->type != BOOTS && op->type != GLOVES && op->type != ARMOUR)
1428 return 1;
1429
1430 /* power crystal, spellbooks, and scrolls are always magical. */
1431 if (op->magic || op->type == POWER_CRYSTAL || op->type == SPELLBOOK || op->type == SCROLL || op->type == GIRDLE)
1432 return 1;
1433
1434 /* Check to see if it increases/decreases any stats */
1435 for (i = 0; i < NUM_STATS; i++)
1436 if (get_attr_value (&(op->stats), i) != 0)
1437 return 1;
1438
1439 /* If it doesn't fall into any of the above categories, must
1440 * be non magical.
1441 */
1442 return 0;
1324} 1443}
1325 1444
1326/* need_identify returns true if the item should be identified. This 1445/* need_identify returns true if the item should be identified. This
1327 * function really should not exist - by default, any item not identified 1446 * function really should not exist - by default, any item not identified
1328 * should need it. 1447 * should need it.
1329 */ 1448 */
1330 1449
1450int
1331int need_identify(const object *op) { 1451need_identify (const object *op)
1452{
1332 switch(op->type) { 1453 switch (op->type)
1454 {
1333 case RING: 1455 case RING:
1334 case WAND: 1456 case WAND:
1335 case ROD: 1457 case ROD:
1336 case HORN: 1458 case HORN:
1337 case SCROLL: 1459 case SCROLL:
… …
1360 case GEM: 1482 case GEM:
1361 case POWER_CRYSTAL: 1483 case POWER_CRYSTAL:
1362 case POISON: 1484 case POISON:
1363 case BOOK: 1485 case BOOK:
1364 case SKILL_TOOL: 1486 case SKILL_TOOL:
1365 return 1; 1487 return 1;
1366 } 1488 }
1367 /* Try to track down some stuff that may show up here. Thus, the 1489 /* Try to track down some stuff that may show up here. Thus, the
1368 * archetype file can be updated, and this function removed. 1490 * archetype file can be updated, and this function removed.
1369 */ 1491 */
1370#if 0 1492#if 0
1371 LOG(llevDebug,"need_identify: %s does not need to be id'd\n", op->name); 1493 LOG (llevDebug, "need_identify: %s does not need to be id'd\n", op->name);
1372#endif 1494#endif
1373 return 0; 1495 return 0;
1374} 1496}
1375
1376 1497
1377/* 1498/*
1378 * Supposed to fix face-values as well here, but later. 1499 * Supposed to fix face-values as well here, but later.
1379 */ 1500 */
1380 1501void
1381void identify(object *op) { 1502identify (object *op)
1503{
1382 object *pl; 1504 object *pl;
1383 1505
1384 SET_FLAG(op,FLAG_IDENTIFIED); 1506 SET_FLAG (op, FLAG_IDENTIFIED);
1385 CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL); 1507 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
1386 CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT); 1508 CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT);
1387 1509
1388 /* 1510 /*
1389 * We want autojoining of equal objects: 1511 * We want autojoining of equal objects:
1390 */ 1512 */
1391 if (QUERY_FLAG(op,FLAG_CURSED) || QUERY_FLAG(op,FLAG_DAMNED)) 1513 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
1392 SET_FLAG(op,FLAG_KNOWN_CURSED); 1514 SET_FLAG (op, FLAG_KNOWN_CURSED);
1393 1515
1394 if (op->type == POTION) { 1516 if (op->type == POTION)
1517 {
1395 if (op->inv && op->randomitems) { 1518 if (op->inv && op->randomitems)
1396 if (op->title) free_string(op->title);
1397 op->title = add_refcount(op->inv->name); 1519 op->title = op->inv->name;
1398 } else if (op->arch) { 1520 else if (op->arch)
1399 free_string(op->name);
1400 op->name = add_refcount(op->arch->clone.name);
1401 free_string(op->name_pl);
1402 op->name_pl = add_refcount(op->arch->clone.name_pl);
1403 } 1521 {
1522 op->name = op->arch->clone.name;
1523 op->name_pl = op->arch->clone.name_pl;
1524 }
1404 } 1525 }
1405 1526
1406 /* If the object is on a map, make sure we update its face */ 1527 /* If the object is on a map, make sure we update its face */
1407 if (op->map) 1528 if (op->map)
1408 update_object(op,UP_OBJ_FACE); 1529 update_object (op, UP_OBJ_FACE);
1409 else { 1530 else
1410 pl = is_player_inv(op->env); 1531 {
1532 pl = op->in_player ();
1411 if (pl) 1533 if (pl)
1412 /* A lot of the values can change from an update - might as well send 1534 /* A lot of the values can change from an update - might as well send
1413 * it all. 1535 * it all.
1414 */ 1536 */
1415 esrv_send_item(pl, op); 1537 esrv_send_item (pl, op);
1416 } 1538 }
1417} 1539}
1540

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines