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.3 by root, Sun Sep 3 00:18:40 2006 UTC vs.
Revision 1.8 by root, Mon Dec 18 03:00:02 2006 UTC

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

Diff Legend

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