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

Diff Legend

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