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

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.11 by root, Sun Aug 27 15:24:22 2006 UTC vs.
Revision 1.38 by root, Tue Dec 12 22:37:05 2006 UTC

1/*
2 * static char *rcsid_apply_c =
3 * "$Id: apply.C,v 1.11 2006/08/27 15:24:22 root Exp $";
4 */
5/* 1/*
6 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
7 3
8 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
9 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
20 16
21 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
22 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 20
25 The authors can be reached via e-mail to crossfire-devel@real-time.com 21 The authors can be reached via e-mail to <crossfire@schmorp.de>
26*/ 22*/
27 23
28#include <global.h> 24#include <global.h>
29#include <living.h> 25#include <living.h>
30#include <spells.h> 26#include <spells.h>
31#include <skills.h> 27#include <skills.h>
32#include <tod.h> 28#include <tod.h>
33 29
34#ifndef __CEXTRACT__ 30#ifndef __CEXTRACT__
35#include <sproto.h> 31# include <sproto.h>
36#endif 32#endif
37 33
38/* Want this regardless of rplay. */ 34/* Want this regardless of rplay. */
39#include <sounds.h> 35#include <sounds.h>
40 36
41/* need math lib for double-precision and pow() in dragon_eat_flesh() */ 37/* need math lib for double-precision and pow() in dragon_eat_flesh() */
42#include <math.h> 38#include <math.h>
43
44/* Can transport hold object op?
45 * This is a pretty trivial function,
46 * but in the future, possible transport may have more restrictions
47 * or weight reduction like containers
48 */
49int transport_can_hold(const object *transport, const object *op, int nrof)
50{
51 if ((op->weight *nrof + transport->carrying) > transport->weight_limit)
52 return 0;
53 else
54 return 1;
55}
56
57
58/*
59 * Player is trying to use a transport. This returns same values as
60 * manual_apply() does. This function basically checks to see if
61 * the player can use the transport, and if so, sets up the appropriate
62 * pointers.
63 */
64int apply_transport(object *pl, object *transport, int aflag) {
65
66 /* Only players can use transports right now */
67 if (pl->type != PLAYER) return 0;
68
69 // due to brokenness of transports disable them until a working alternative
70 // has been found... :(
71 // - elmex
72 new_draw_info (NDI_UNIQUE, 0, pl, "This transport is out of order!");
73 return 1;
74
75 /* If player is currently on a transport but not this transport, they need
76 * to exit first. Perhaps transport to transport transfers should be
77 * allowed.
78 */
79 if (pl->contr->transport && pl->contr->transport != transport) {
80 new_draw_info_format(NDI_UNIQUE, 0, pl,
81 "You must exit %s before you can board %s.",
82 query_name(pl->contr->transport),
83 query_name(transport));
84 return 1;
85 }
86
87 /* player is currently on a transport. This must mean he
88 * wants to exit.
89 */
90 if (pl->contr->transport) {
91 object *old_transport = pl->contr->transport, *inv;
92
93 /* Should we print a message if the player only wants to
94 * apply?
95 */
96 if (aflag & AP_APPLY) return 1;
97 new_draw_info_format(NDI_UNIQUE, 0, pl,
98 "You disembark from %s.",
99 query_name(old_transport));
100 remove_ob(pl);
101 pl->map = old_transport->map;
102 pl->x = old_transport->x;
103 pl->y = old_transport->y;
104 if (pl->contr == old_transport->contr)
105 old_transport->contr = NULL;
106
107 pl->contr->transport = NULL;
108 insert_ob_in_map(pl, pl->map, pl, 0);
109 sum_weight(old_transport);
110
111 /* Possible for more than one player to be using a transport.
112 * if that is the case, we don't want to reset the face, as the
113 * transport is still occupied.
114 */
115 for (inv=old_transport->inv; inv; inv=inv->below)
116 if (inv->type == PLAYER) break;
117 if (!inv) {
118 old_transport->face = old_transport->arch->clone.face;
119 old_transport->animation_id = old_transport->arch->clone.animation_id;
120 }
121 return 1;
122 }
123 else {
124 /* player is trying to board a transport */
125 int pc=0, p_limit;
126 object *inv;
127 const char *kv;
128
129 if (aflag & AP_UNAPPLY) return 1;
130
131 /* Can this transport hold the weight of this player? */
132 if (!transport_can_hold(transport, pl, 1)) {
133 new_draw_info_format(NDI_UNIQUE, 0, pl,
134 "The %s is unable to hold your weight!",
135 query_name(transport));
136 return 1;
137 }
138
139 /* Does this transport have space for more players? */
140 for (inv=transport->inv; inv; inv=inv->below) {
141 if (inv->type == PLAYER) pc++;
142 }
143 kv = get_ob_key_value(transport, "passenger_limit");
144 if (!kv) p_limit=1;
145 else p_limit = atoi(kv);
146 if (pc >= p_limit) {
147 new_draw_info_format(NDI_UNIQUE, 0, pl,
148 "The %s does not have space for any more people",
149 query_name(transport));
150 return 1;
151 }
152
153 /* Everything checks out OK - player can get on the transport */
154 pl->contr->transport = transport;
155 if (!transport->contr) transport->contr = pl->contr;
156 remove_ob(pl);
157 insert_ob_in_ob(pl, transport);
158 sum_weight(transport);
159 pl->map = transport->map;
160 pl->x = transport->x;
161 pl->y = transport->y;
162
163 /* Might need to update face, animation info */
164 if (!pc) {
165 const char *str;
166
167 str = get_ob_key_value(transport, "face_full");
168 if (str)
169 transport->face = &new_faces[FindFace(str,
170 transport->face->number)];
171 str = get_ob_key_value(transport, "anim_full");
172 if (str)
173 transport->animation_id = find_animation(str);
174 }
175
176 /* Does speed of this object change based on weight? */
177 kv = get_ob_key_value(transport, "weight_speed_ratio");
178 if (kv) {
179 int wsr = atoi(kv);
180 float base_speed;
181
182 kv = get_ob_key_value(transport, "base_speed");
183 if (kv) base_speed = atof(kv);
184 else base_speed = transport->arch->clone.speed;
185
186 transport->speed = base_speed - (base_speed * transport->carrying *
187 wsr) / (transport->weight_limit * 100);
188
189 /* Put some limits on min/max speeds */
190 if (transport->speed < 0.10) transport->speed = 0.10;
191 if (transport->speed > 1.0) transport->speed = 1.0;
192 }
193 } /* else if player is boarding the transport */
194
195 return 1;
196}
197
198
199 39
200/** 40/**
201 * Check if op should abort moving victim because of it's race or slaying. 41 * Check if op should abort moving victim because of it's race or slaying.
202 * Returns 1 if it should abort, returns 0 if it should continue. 42 * Returns 1 if it should abort, returns 0 if it should continue.
203 */ 43 */
44int
204int should_director_abort(object *op, object *victim) 45should_director_abort (object *op, object *victim)
205{ 46{
206 int arch_flag, name_flag, race_flag; 47 int arch_flag, name_flag, race_flag;
48
207 /* Get flags to determine what of arch, name, and race should be checked. 49 /* Get flags to determine what of arch, name, and race should be checked.
208 * This is stored in subtype, and is a bitmask, the LSB is the arch flag, 50 * This is stored in subtype, and is a bitmask, the LSB is the arch flag,
209 * the next is the name flag, and the last is the race flag. Also note, 51 * the next is the name flag, and the last is the race flag. Also note,
210 * if subtype is set to zero, that also goes to defaults of all affecting 52 * if subtype is set to zero, that also goes to defaults of all affecting
211 * it. Examples: 53 * it. Examples:
212 * subtype 1: only arch 54 * subtype 1: only arch
213 * subtype 3: arch or name 55 * subtype 3: arch or name
214 * subtype 5: arch or race 56 * subtype 5: arch or race
215 * subtype 7: all three 57 * subtype 7: all three
216 */ 58 */
217 if (op->subtype) 59 if (op->subtype)
218 { 60 {
219 arch_flag = (op->subtype & 1); 61 arch_flag = (op->subtype & 1);
220 name_flag = (op->subtype & 2); 62 name_flag = (op->subtype & 2);
221 race_flag = (op->subtype & 4); 63 race_flag = (op->subtype & 4);
222 } else { 64 }
65 else
66 {
223 arch_flag = 1; 67 arch_flag = 1;
224 name_flag = 1; 68 name_flag = 1;
225 race_flag = 1; 69 race_flag = 1;
226 } 70 }
227 /* If the director has race set, only affect objects with a arch, 71 /* If the director has race set, only affect objects with a arch,
228 * name or race that matches. 72 * name or race that matches.
229 */ 73 */
230 if ( (op->race) && 74 if ((op->race) &&
231 ((!(victim->arch && arch_flag && victim->arch->name) || strcmp(op->race, victim->arch->name))) && 75 ((!(victim->arch && arch_flag && victim->arch->name) || strcmp (op->race, victim->arch->name))) &&
232 ((!(victim->name && name_flag) || strcmp(op->race, victim->name))) && 76 ((!(victim->name && name_flag) || strcmp (op->race, victim->name))) &&
233 ((!(victim->race && race_flag) || strcmp(op->race, victim->race))) ) { 77 ((!(victim->race && race_flag) || strcmp (op->race, victim->race))))
78 {
234 return 1; 79 return 1;
235 } 80 }
236 /* If the director has slaying set, only affect objects where none 81 /* If the director has slaying set, only affect objects where none
237 * of arch, name, or race match. 82 * of arch, name, or race match.
238 */ 83 */
239 if ( (op->slaying) && (
240 ((victim->arch && arch_flag && victim->arch->name && !strcmp(op->slaying, victim->arch->name))) || 84 if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->name && !strcmp (op->slaying, victim->arch->name))) ||
241 ((victim->name && name_flag && !strcmp(op->slaying, victim->name))) || 85 ((victim->name && name_flag && !strcmp (op->slaying, victim->name))) ||
242 ((victim->race && race_flag && !strcmp(op->slaying, victim->race)))) ) { 86 ((victim->race && race_flag && !strcmp (op->slaying, victim->race)))))
87 {
243 return 1; 88 return 1;
244 } 89 }
245 return 0; 90 return 0;
246} 91}
247 92
248/** 93/**
249 * This handles a player dropping money on an altar to identify stuff. 94 * This handles a player dropping money on an altar to identify stuff.
250 * It'll identify marked item, if none all items up to dropped money. 95 * It'll identify marked item, if none all items up to dropped money.
251 * Return value: 1 if money was destroyed, 0 if not. 96 * Return value: 1 if money was destroyed, 0 if not.
252 */ 97 */
98static int
253static int apply_id_altar (object *money, object *altar, object *pl) 99apply_id_altar (object *money, object *altar, object *pl)
254{ 100{
255 object *id, *marked; 101 object *id, *marked;
256 int success=0; 102 int success = 0;
257 103
258 if (pl == NULL || pl->type != PLAYER) 104 if (pl == NULL || pl->type != PLAYER)
259 return 0; 105 return 0;
260 106
261 /* Check for MONEY type is a special hack - it prevents 'nothing needs 107 /* Check for MONEY type is a special hack - it prevents 'nothing needs
262 * identifying' from being printed out more than it needs to be. 108 * identifying' from being printed out more than it needs to be.
263 */ 109 */
264 if ( ! check_altar_sacrifice (altar, money) || money->type != MONEY) 110 if (!check_altar_sacrifice (altar, money) || money->type != MONEY)
265 return 0; 111 return 0;
266 112
267 marked = find_marked_object (pl); 113 marked = find_marked_object (pl);
268 /* if the player has a marked item, identify that if it needs to be 114 /* if the player has a marked item, identify that if it needs to be
269 * identified. IF it doesn't, then go through the player inventory. 115 * identified. IF it doesn't, then go through the player inventory.
270 */ 116 */
271 if (marked && ! QUERY_FLAG (marked, FLAG_IDENTIFIED) 117 if (marked && !QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
272 && need_identify (marked))
273 { 118 {
274 if (operate_altar (altar, &money)) { 119 if (operate_altar (altar, &money))
120 {
275 identify (marked); 121 identify (marked);
276 new_draw_info_format(NDI_UNIQUE, 0, pl, 122 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have %s.", long_desc (marked, pl));
277 "You have %s.", long_desc(marked, pl));
278 if (marked->msg) { 123 if (marked->msg)
124 {
279 new_draw_info(NDI_UNIQUE, 0,pl, "The item has a story:"); 125 new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");
280 new_draw_info(NDI_UNIQUE, 0,pl, marked->msg); 126 new_draw_info (NDI_UNIQUE, 0, pl, marked->msg);
127 }
128 return money == NULL;
129 }
281 } 130 }
282 return money == NULL;
283 }
284 }
285 131
286 for (id=pl->inv; id; id=id->below) { 132 for (id = pl->inv; id; id = id->below)
133 {
287 if (!QUERY_FLAG(id, FLAG_IDENTIFIED) && !id->invisible && 134 if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
288 need_identify(id)) { 135 {
289 if (operate_altar(altar,&money)) { 136 if (operate_altar (altar, &money))
290 identify(id); 137 {
291 new_draw_info_format(NDI_UNIQUE, 0, pl, 138 identify (id);
292 "You have %s.", long_desc(id, pl)); 139 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have %s.", long_desc (id, pl));
293 if (id->msg) { 140 if (id->msg)
141 {
294 new_draw_info(NDI_UNIQUE, 0,pl, "The item has a story:"); 142 new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");
295 new_draw_info(NDI_UNIQUE, 0,pl, id->msg); 143 new_draw_info (NDI_UNIQUE, 0, pl, id->msg);
296 } 144 }
297 success=1; 145 success = 1;
298 /* If no more money, might as well quit now */ 146 /* If no more money, might as well quit now */
299 if (money == NULL || ! check_altar_sacrifice (altar,money)) 147 if (money == NULL || !check_altar_sacrifice (altar, money))
300 break; 148 break;
301 } 149 }
302 else { 150 else
151 {
303 LOG(llevError,"check_id_altar: Couldn't do sacrifice when we should have been able to\n"); 152 LOG (llevError, "check_id_altar: Couldn't do sacrifice when we should have been able to\n");
304 break; 153 break;
305 } 154 }
306 } 155 }
307 } 156 }
157 if (!success)
308 if (!success) new_draw_info(NDI_UNIQUE, 0,pl,"You have nothing that needs identifying"); 158 new_draw_info (NDI_UNIQUE, 0, pl, "You have nothing that needs identifying");
309 return money == NULL; 159 return money == NULL;
310} 160}
311 161
312/** 162/**
313 * This checks whether the object has a "on_use_yield" field, and if so generated and drops 163 * This checks whether the object has a "on_use_yield" field, and if so generated and drops
314 * matching item. 164 * matching item.
315 **/ 165 **/
166static void
316static void handle_apply_yield(object* tmp) 167handle_apply_yield (object *tmp)
317{ 168{
318 const char* yield; 169 const char *yield;
319 170
320 yield = get_ob_key_value(tmp,"on_use_yield"); 171 yield = get_ob_key_value (tmp, "on_use_yield");
321 if (yield != NULL) 172 if (yield != NULL)
322 { 173 {
323 object* drop = get_archetype(yield); 174 object *drop = get_archetype (yield);
175
324 if (tmp->env) 176 if (tmp->env)
325 { 177 {
326 drop = insert_ob_in_ob(drop,tmp->env); 178 drop = insert_ob_in_ob (drop, tmp->env);
327 if (tmp->env->type == PLAYER) 179 if (tmp->env->type == PLAYER)
328 esrv_send_item(tmp->env,drop); 180 esrv_send_item (tmp->env, drop);
329 } 181 }
330 else 182 else
331 { 183 {
332 drop->x = tmp->x; 184 drop->x = tmp->x;
333 drop->y = tmp->y; 185 drop->y = tmp->y;
334 insert_ob_in_map(drop,tmp->map,tmp,INS_BELOW_ORIGINATOR); 186 insert_ob_in_map (drop, tmp->map, tmp, INS_BELOW_ORIGINATOR);
335 } 187 }
336 } 188 }
337} 189}
338 190
339/** 191/**
340 * Handles applying a potion. 192 * Handles applying a potion.
341 */ 193 */
194int
342int apply_potion (object * op, object * tmp) 195apply_potion (object *op, object *tmp)
343{ 196{
344 int got_one = 0, i; 197 int got_one = 0, i;
345 object *force = 0, *floor = 0; 198 object *force = 0, *floor = 0;
346 199
347 floor = get_map_ob (op->map, op->x, op->y); 200 floor = get_map_ob (op->map, op->x, op->y);
348 201
349 if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 202 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
350 { 203 {
351 if (op->type == PLAYER) 204 if (op->type == PLAYER)
352 new_draw_info (NDI_UNIQUE, 0, op,
353 "Gods prevent you from using this here, it's sacred ground!" 205 new_draw_info (NDI_UNIQUE, 0, op, "Gods prevent you from using this here, it's sacred ground!");
354 );
355 CLEAR_FLAG (tmp, FLAG_APPLIED); 206 CLEAR_FLAG (tmp, FLAG_APPLIED);
356 return 0; 207 return 0;
357 } 208 }
358 209
359 if (op->type == PLAYER) 210 if (op->type == PLAYER)
360 {
361 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 211 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
362 identify (tmp); 212 identify (tmp);
363 }
364 213
365 handle_apply_yield (tmp); 214 handle_apply_yield (tmp);
366 215
367 /* Potion of restoration - only for players */ 216 /* Potion of restoration - only for players */
368 if (op->type == PLAYER && (tmp->attacktype & AT_DEPLETE)) 217 if (op->type == PLAYER && (tmp->attacktype & AT_DEPLETE))
… …
375 drain_stat (op); 224 drain_stat (op);
376 fix_player (op); 225 fix_player (op);
377 decrease_ob (tmp); 226 decrease_ob (tmp);
378 return 1; 227 return 1;
379 } 228 }
229
380 if ((at = find_archetype (ARCH_DEPLETION)) == NULL) 230 if ((at = archetype::find (ARCH_DEPLETION)) == NULL)
381 { 231 {
382 LOG (llevError, "Could not find archetype depletion\n"); 232 LOG (llevError, "Could not find archetype depletion\n");
383 return 0; 233 return 0;
384 } 234 }
385 depl = present_arch_in_ob (at, op); 235 depl = present_arch_in_ob (at, op);
236
386 if (depl != NULL) 237 if (depl != NULL)
387 { 238 {
388 for (i = 0; i < NUM_STATS; i++) 239 for (i = 0; i < NUM_STATS; i++)
389 if (get_attr_value (&depl->stats, i)) 240 if (get_attr_value (&depl->stats, i))
390 {
391 new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]); 241 new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);
392 } 242
393 remove_ob (depl); 243 depl->destroy ();
394 free_object (depl);
395 fix_player (op); 244 fix_player (op);
396 } 245 }
397 else 246 else
398 new_draw_info (NDI_UNIQUE, 0, op, "You potion had no effect."); 247 new_draw_info (NDI_UNIQUE, 0, op, "You potion had no effect.");
399 248
… …
402 } 251 }
403 252
404 /* improvement potion - only for players */ 253 /* improvement potion - only for players */
405 if (op->type == PLAYER && tmp->attacktype & AT_GODPOWER) 254 if (op->type == PLAYER && tmp->attacktype & AT_GODPOWER)
406 { 255 {
407
408 for (i = 1; i < MIN (11, op->level); i++) 256 for (i = 1; i < MIN (11, op->level); i++)
409 { 257 {
410 if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) 258 if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
411 { 259 {
412 if (op->contr->levhp[i] != 1) 260 if (op->contr->levhp[i] != 1)
… …
442 op->contr->levgrace[i] = 3; 290 op->contr->levgrace[i] = 3;
443 break; 291 break;
444 } 292 }
445 } 293 }
446 } 294 }
295
447 /* Just makes checking easier */ 296 /* Just makes checking easier */
448 if (i < MIN (11, op->level)) 297 if (i < MIN (11, op->level))
449 got_one = 1; 298 got_one = 1;
299
450 if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)) 300 if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
451 { 301 {
452 if (got_one) 302 if (got_one)
453 { 303 {
454 fix_player (op); 304 fix_player (op);
455 new_draw_info (NDI_UNIQUE, 0, op, 305 new_draw_info (NDI_UNIQUE, 0, op, "The Gods smile upon you and remake you");
456 "The Gods smile upon you and remake you"); 306 new_draw_info (NDI_UNIQUE, 0, op, "a little more in their image.");
457 new_draw_info (NDI_UNIQUE, 0, op, 307 new_draw_info (NDI_UNIQUE, 0, op, "You feel a little more perfect.");
458 "a little more in their image.");
459 new_draw_info (NDI_UNIQUE, 0, op,
460 "You feel a little more perfect.");
461 } 308 }
462 else 309 else
463 new_draw_info (NDI_UNIQUE, 0, op, 310 new_draw_info (NDI_UNIQUE, 0, op, "The potion had no effect - you are already perfect");
464 "The potion had no effect - you are already perfect");
465 } 311 }
466 else 312 else
467 { /* cursed potion */ 313 { /* cursed potion */
468 if (got_one) 314 if (got_one)
469 { 315 {
470 fix_player (op); 316 fix_player (op);
471 new_draw_info (NDI_UNIQUE, 0, op, 317 new_draw_info (NDI_UNIQUE, 0, op, "The Gods are angry and punish you.");
472 "The Gods are angry and punish you.");
473 } 318 }
474 else 319 else
475 new_draw_info (NDI_UNIQUE, 0, op, 320 new_draw_info (NDI_UNIQUE, 0, op, "You are fortunate that you are so pathetic.");
476 "You are fortunate that you are so pathetic.");
477 } 321 }
322
478 decrease_ob (tmp); 323 decrease_ob (tmp);
479 return 1; 324 return 1;
480 } 325 }
481 326
482 327
… …
492 object *fball; 337 object *fball;
493 338
494 new_draw_info (NDI_UNIQUE, 0, op, "Yech! Your lungs are on fire!"); 339 new_draw_info (NDI_UNIQUE, 0, op, "Yech! Your lungs are on fire!");
495 /* Explodes a fireball centered at player */ 340 /* Explodes a fireball centered at player */
496 fball = get_archetype (EXPLODING_FIREBALL); 341 fball = get_archetype (EXPLODING_FIREBALL);
497 fball->dam_modifier =
498 random_roll (1, op->level, op, PREFER_LOW) / 5 + 1; 342 fball->dam_modifier = random_roll (1, op->level, op, PREFER_LOW) / 5 + 1;
499 fball->stats.maxhp =
500 random_roll (1, op->level, op, PREFER_LOW) / 10 + 2; 343 fball->stats.maxhp = random_roll (1, op->level, op, PREFER_LOW) / 10 + 2;
501 fball->x = op->x; 344 fball->x = op->x;
502 fball->y = op->y; 345 fball->y = op->y;
503 insert_ob_in_map (fball, op->map, NULL, 0); 346 insert_ob_in_map (fball, op->map, NULL, 0);
504 } 347 }
505 else 348 else
… …
546 } 389 }
547 390
548 /* Only thing left are the stat potions */ 391 /* Only thing left are the stat potions */
549 if (op->type == PLAYER) 392 if (op->type == PLAYER)
550 { /* only for players */ 393 { /* only for players */
551 if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) 394 if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)
552 && tmp->value != 0)
553 CLEAR_FLAG (tmp, FLAG_APPLIED); 395 CLEAR_FLAG (tmp, FLAG_APPLIED);
554 else 396 else
555 SET_FLAG (tmp, FLAG_APPLIED); 397 SET_FLAG (tmp, FLAG_APPLIED);
556 if (!change_abil (op, tmp)) 398 if (!change_abil (op, tmp))
557 new_draw_info (NDI_UNIQUE, 0, op, "Nothing happened."); 399 new_draw_info (NDI_UNIQUE, 0, op, "Nothing happened.");
… …
573 ****************************************************************************/ 415 ****************************************************************************/
574 416
575/** 417/**
576 * This returns the sum of nrof of item (arch name). 418 * This returns the sum of nrof of item (arch name).
577 */ 419 */
420static int
578static int check_item(object *op, const char *item) 421check_item (object *op, const char *item)
579{ 422{
580 int count=0; 423 int count = 0;
581 424
582 425
583 if (item==NULL) return 0; 426 if (item == NULL)
427 return 0;
584 op=op->below; 428 op = op->below;
585 while(op!=NULL) { 429 while (op != NULL)
430 {
586 if (strcmp(op->arch->name,item)==0){ 431 if (strcmp (op->arch->name, item) == 0)
432 {
587 if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED) 433 if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
588 /* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID) ) 434 /* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))
589 { 435 {
590 if (op->nrof == 0)/* this is necessary for artifact sacrifices --FD-- */ 436 if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
591 count++; 437 count++;
592 else 438 else
593 count += op->nrof; 439 count += op->nrof;
440 }
441 }
442 op = op->below;
594 } 443 }
595 }
596 op=op->below;
597 }
598 return count; 444 return count;
599} 445}
600 446
601/** 447/**
602 * This removes 'nrof' of what item->slaying says to remove. 448 * This removes 'nrof' of what item->slaying says to remove.
603 * op is typically the player, which is only 449 * op is typically the player, which is only
604 * really used to determine what space to look at. 450 * really used to determine what space to look at.
605 * Modified to only eat 'nrof' of objects. 451 * Modified to only eat 'nrof' of objects.
606 */ 452 */
453static void
607static void eat_item(object *op,const char *item, uint32 nrof) 454eat_item (object *op, const char *item, uint32 nrof)
608{ 455{
609 object *prev; 456 object *prev;
610 457
458 prev = op;
459 op = op->below;
460
461 while (op != NULL)
462 {
463 if (strcmp (op->arch->name, item) == 0)
464 {
465 if (op->nrof >= nrof)
466 {
467 decrease_ob_nr (op, nrof);
468 return;
469 }
470 else
471 {
472 decrease_ob_nr (op, op->nrof);
473 nrof -= op->nrof;
474 }
475 op = prev;
476 }
611 prev = op; 477 prev = op;
612 op=op->below; 478 op = op->below;
613
614 while(op!=NULL) {
615 if (strcmp(op->arch->name,item)==0) {
616 if (op->nrof >= nrof) {
617 decrease_ob_nr(op,nrof);
618 return;
619 } else {
620 decrease_ob_nr(op,op->nrof);
621 nrof -= op->nrof;
622 }
623 op=prev;
624 }
625 prev = op;
626 op=op->below;
627 } 479 }
628} 480}
629 481
630/** 482/**
631 * This checks to see of the player (who) is sufficient level to use a weapon 483 * This checks to see of the player (who) is sufficient level to use a weapon
632 * with improvs improvements (typically last_eat). We take an int here 484 * with improvs improvements (typically last_eat). We take an int here
633 * instead of the object so that the improvement code can pass along the 485 * instead of the object so that the improvement code can pass along the
634 * increased value to see if the object is usuable. 486 * increased value to see if the object is usuable.
635 * we return 1 (true) if the player can use the weapon. 487 * we return 1 (true) if the player can use the weapon.
636 */ 488 */
489static int
637static int check_weapon_power(const object *who, int improvs) 490check_weapon_power (const object *who, int improvs)
638{ 491{
492
639/* Old code is below (commented out). Basically, since weapons are the only 493/* Old code is below (commented out). Basically, since weapons are the only
640 * object players really have any control to improve, it's a bit harsh to 494 * object players really have any control to improve, it's a bit harsh to
641 * require high level in some combat skill, so we just use overall level. 495 * require high level in some combat skill, so we just use overall level.
642 */ 496 */
643#if 1 497#if 1
644 if (((who->level/5)+5) >= improvs) return 1; 498 if (((who->level / 5) + 5) >= improvs)
499 return 1;
500 else
645 else return 0; 501 return 0;
646 502
647#else 503#else
648 int level=0; 504 int level = 0;
649 505
650 /* The skill system hands out wc and dam bonuses to fighters 506 /* The skill system hands out wc and dam bonuses to fighters
651 * more generously than the old system (see fix_player). Thus 507 * more generously than the old system (see fix_player). Thus
652 * we need to curtail the power of player enchanted weapons. 508 * we need to curtail the power of player enchanted weapons.
653 * I changed this to 1 improvement per "fighter" level/5 -b.t. 509 * I changed this to 1 improvement per "fighter" level/5 -b.t.
654 * Note: Nothing should break by allowing this ratio to be different or 510 * Note: Nothing should break by allowing this ratio to be different or
655 * using normal level - it is just a matter of play balance. 511 * using normal level - it is just a matter of play balance.
656 */ 512 */
657 if(who->type==PLAYER) { 513 if (who->type == PLAYER)
514 {
658 object *wc_obj=NULL; 515 object *wc_obj = NULL;
659 516
660 for(wc_obj=who->inv;wc_obj;wc_obj=wc_obj->below) 517 for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
661 if (wc_obj->type == SKILL && IS_COMBAT_SKILL(wc_obj->subtype) && wc_obj->level > level) 518 if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
662 level = wc_obj->level; 519 level = wc_obj->level;
663 520
664 if (!level ) { 521 if (!level)
522 {
665 LOG(llevError,"Error: Player: %s lacks wc experience object\n",who->name); 523 LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
524 level = who->level;
525 }
526 }
527 else
666 level = who->level; 528 level = who->level;
667 }
668 }
669 else
670 level=who->level;
671 529
672 return (improvs <= ((level/5)+5)); 530 return (improvs <= ((level / 5) + 5));
673#endif 531#endif
674} 532}
675 533
676/** 534/**
677 * Returns how many items of type improver->slaying there are under op. 535 * Returns how many items of type improver->slaying there are under op.
678 * Will display a message if none found, and 1 if improver->slaying is NULL. 536 * Will display a message if none found, and 1 if improver->slaying is NULL.
679 */ 537 */
538static int
680static int check_sacrifice(object *op, const object *improver) 539check_sacrifice (object *op, const object *improver)
681{ 540{
682 int count=0; 541 int count = 0;
683 542
684 if (improver->slaying!=NULL) { 543 if (improver->slaying != NULL)
544 {
685 count = check_item(op,improver->slaying); 545 count = check_item (op, improver->slaying);
686 if (count<1) { 546 if (count < 1)
547 {
687 char buf[200]; 548 char buf[200];
549
688 sprintf(buf,"The gods want more %ss",improver->slaying); 550 sprintf (buf, "The gods want more %ss", &improver->slaying);
689 new_draw_info(NDI_UNIQUE,0,op,buf); 551 new_draw_info (NDI_UNIQUE, 0, op, buf);
690 return 0; 552 return 0;
691 } 553 }
692 } 554 }
693 else 555 else
694 count=1; 556 count = 1;
695 557
696 return count; 558 return count;
697} 559}
698 560
699/** 561/**
700 * Actually improves the weapon, and tells user. 562 * Actually improves the weapon, and tells user.
701 */ 563 */
702int improve_weapon_stat(object *op,object *improver,object *weapon, 564int
703 signed char *stat,int sacrifice_count,const char *statname) 565improve_weapon_stat (object *op, object *improver, object *weapon, signed char *stat, int sacrifice_count, const char *statname)
704{ 566{
705 567
706 new_draw_info(NDI_UNIQUE,0,op,"Your sacrifice was accepted."); 568 new_draw_info (NDI_UNIQUE, 0, op, "Your sacrifice was accepted.");
707 *stat += sacrifice_count; 569 *stat += sacrifice_count;
708 weapon->last_eat++; 570 weapon->last_eat++;
709 new_draw_info_format(NDI_UNIQUE,0,op, 571 new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon's bonus to %s improved by %d", statname, sacrifice_count);
710 "Weapon's bonus to %s improved by %d",statname,sacrifice_count);
711 decrease_ob(improver); 572 decrease_ob (improver);
712 573
713 /* So it updates the players stats and the window */ 574 /* So it updates the players stats and the window */
714 fix_player(op); 575 fix_player (op);
715 return 1; 576 return 1;
716} 577}
717 578
718/* Types of improvements, hidden in the sp field. */ 579/* Types of improvements, hidden in the sp field. */
719#define IMPROVE_PREPARE 1 580#define IMPROVE_PREPARE 1
… …
732/** 593/**
733 * This does the prepare weapon scroll. 594 * This does the prepare weapon scroll.
734 * Checks for sacrifice, and so on. 595 * Checks for sacrifice, and so on.
735 */ 596 */
736 597
598int
737int prepare_weapon(object *op, object *improver, object *weapon) 599prepare_weapon (object *op, object *improver, object *weapon)
738{ 600{
739 int sacrifice_count,i; 601 int sacrifice_count, i;
740 char buf[MAX_BUF]; 602 char buf[MAX_BUF];
741 603
742 if (weapon->level!=0) { 604 if (weapon->level != 0)
605 {
743 new_draw_info(NDI_UNIQUE,0,op,"Weapon already prepared."); 606 new_draw_info (NDI_UNIQUE, 0, op, "Weapon already prepared.");
744 return 0; 607 return 0;
745 } 608 }
746 for (i=0; i<NROFATTACKS; i++) 609 for (i = 0; i < NROFATTACKS; i++)
747 if (weapon->resist[i]) break; 610 if (weapon->resist[i])
611 break;
748 612
749 /* If we break out, i will be less than nrofattacks, preventing 613 /* If we break out, i will be less than nrofattacks, preventing
750 * improvement of items that already have protections. 614 * improvement of items that already have protections.
751 */ 615 */
752 if (i<NROFATTACKS || 616 if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */
753 weapon->stats.hp || /* regeneration */
754 (weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */ 617 (weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */
755 weapon->stats.exp || /* speed */ 618 weapon->stats.exp || /* speed */
756 weapon->stats.ac) /* AC - only taifu's I think */ 619 weapon->stats.ac) /* AC - only taifu's I think */
757 { 620 {
758 new_draw_info(NDI_UNIQUE,0,op,"Cannot prepare magic weapons."); 621 new_draw_info (NDI_UNIQUE, 0, op, "Cannot prepare magic weapons.");
759 return 0; 622 return 0;
760 } 623 }
761 sacrifice_count=check_sacrifice(op,improver); 624 sacrifice_count = check_sacrifice (op, improver);
762 if (sacrifice_count<=0) 625 if (sacrifice_count <= 0)
763 return 0; 626 return 0;
764 weapon->level=isqrt(sacrifice_count); 627 weapon->level = isqrt (sacrifice_count);
765 new_draw_info(NDI_UNIQUE,0,op,"Your sacrifice was accepted."); 628 new_draw_info (NDI_UNIQUE, 0, op, "Your sacrifice was accepted.");
766 eat_item(op, improver->slaying, sacrifice_count); 629 eat_item (op, improver->slaying, sacrifice_count);
767 630
768 new_draw_info_format(NDI_UNIQUE, 0, op,"Your *%s may be improved %d times.", 631 new_draw_info_format (NDI_UNIQUE, 0, op, "Your *%s may be improved %d times.", &weapon->name, weapon->level);
769 weapon->name,weapon->level);
770 632
771 sprintf(buf,"%s's %s",op->name,weapon->name); 633 sprintf (buf, "%s's %s", &op->name, &weapon->name);
772 FREE_AND_COPY(weapon->name, buf); 634 weapon->name = weapon->name_pl = buf;
773 FREE_AND_COPY(weapon->name_pl, buf);
774 weapon->nrof=0; /* prevents preparing n weapons in the same 635 weapon->nrof = 0; /* prevents preparing n weapons in the same
775 slot at once! */ 636 slot at once! */
776 decrease_ob(improver); 637 decrease_ob (improver);
777 weapon->last_eat=0; 638 weapon->last_eat = 0;
778 return 1; 639 return 1;
779} 640}
780 641
781 642
782/** 643/**
783 * Does the dirty job for 'improve weapon' scroll, prepare or add something. 644 * Does the dirty job for 'improve weapon' scroll, prepare or add something.
… …
788 * 649 *
789 * We are hiding extra information about the weapon in the level and 650 * We are hiding extra information about the weapon in the level and
790 * last_eat numbers for an object. Hopefully this won't break anything ?? 651 * last_eat numbers for an object. Hopefully this won't break anything ??
791 * level == max improve last_eat == current improve 652 * level == max improve last_eat == current improve
792 */ 653 */
654int
793int improve_weapon(object *op,object *improver,object *weapon) 655improve_weapon (object *op, object *improver, object *weapon)
794{ 656{
795 int sacrifice_count, sacrifice_needed=0; 657 int sacrifice_count, sacrifice_needed = 0;
796 658
797 if(improver->stats.sp==IMPROVE_PREPARE) { 659 if (improver->stats.sp == IMPROVE_PREPARE)
660 {
798 return prepare_weapon(op, improver, weapon); 661 return prepare_weapon (op, improver, weapon);
799 } 662 }
800 if (weapon->level==0) { 663 if (weapon->level == 0)
664 {
801 new_draw_info(NDI_UNIQUE, 0,op,"This weapon has not been prepared."); 665 new_draw_info (NDI_UNIQUE, 0, op, "This weapon has not been prepared.");
802 return 0; 666 return 0;
803 } 667 }
804 if (weapon->level==weapon->last_eat && weapon->item_power >=100) { 668 if (weapon->level == weapon->last_eat && weapon->item_power >= 100)
669 {
805 new_draw_info(NDI_UNIQUE, 0,op,"This weapon cannot be improved any more."); 670 new_draw_info (NDI_UNIQUE, 0, op, "This weapon cannot be improved any more.");
806 return 0; 671 return 0;
807 } 672 }
808 if (QUERY_FLAG(weapon, FLAG_APPLIED) && 673 if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1))
809 !check_weapon_power(op, weapon->last_eat+1)) { 674 {
810 new_draw_info(NDI_UNIQUE, 0,op,"Improving the weapon will make it too"); 675 new_draw_info (NDI_UNIQUE, 0, op, "Improving the weapon will make it too");
811 new_draw_info(NDI_UNIQUE, 0,op,"powerful for you to use. Unready it if you"); 676 new_draw_info (NDI_UNIQUE, 0, op, "powerful for you to use. Unready it if you");
812 new_draw_info(NDI_UNIQUE, 0,op,"really want to improve it."); 677 new_draw_info (NDI_UNIQUE, 0, op, "really want to improve it.");
813 return 0; 678 return 0;
814 } 679 }
815 /* This just increases damage by 5 points, no matter what. No sacrifice 680 /* This just increases damage by 5 points, no matter what. No sacrifice
816 * is needed. Since stats.dam is now a 16 bit value and not 8 bit, 681 * is needed. Since stats.dam is now a 16 bit value and not 8 bit,
817 * don't put any maximum value on damage - the limit is how much the 682 * don't put any maximum value on damage - the limit is how much the
818 * weapon can be improved. 683 * weapon can be improved.
819 */ 684 */
820 if (improver->stats.sp==IMPROVE_DAMAGE) { 685 if (improver->stats.sp == IMPROVE_DAMAGE)
686 {
821 weapon->stats.dam += 5; 687 weapon->stats.dam += 5;
822 weapon->weight += 5000; /* 5 KG's */ 688 weapon->weight += 5000; /* 5 KG's */
823 new_draw_info_format(NDI_UNIQUE, 0, op, 689 new_draw_info_format (NDI_UNIQUE, 0, op, "Damage has been increased by 5 to %d", weapon->stats.dam);
824 "Damage has been increased by 5 to %d", weapon->stats.dam);
825 weapon->last_eat++; 690 weapon->last_eat++;
826 691
827 weapon->item_power++; 692 weapon->item_power++;
828 decrease_ob(improver); 693 decrease_ob (improver);
829 return 1; 694 return 1;
830 } 695 }
831 if (improver->stats.sp == IMPROVE_WEIGHT) { 696 if (improver->stats.sp == IMPROVE_WEIGHT)
697 {
832 /* Reduce weight by 20% */ 698 /* Reduce weight by 20% */
833 weapon->weight = (weapon->weight * 8)/10; 699 weapon->weight = (weapon->weight * 8) / 10;
834 if (weapon->weight < 1) weapon->weight = 1; 700 if (weapon->weight < 1)
835 new_draw_info_format(NDI_UNIQUE, 0, op, 701 weapon->weight = 1;
836 "Weapon weight reduced to %6.1f kg", 702 new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon weight reduced to %6.1f kg", (float) weapon->weight / 1000.0);
837 (float)weapon->weight/1000.0);
838 weapon->last_eat++; 703 weapon->last_eat++;
839 weapon->item_power++; 704 weapon->item_power++;
840 decrease_ob(improver); 705 decrease_ob (improver);
841 return 1; 706 return 1;
842 } 707 }
843 if (improver->stats.sp == IMPROVE_ENCHANT) { 708 if (improver->stats.sp == IMPROVE_ENCHANT)
709 {
844 weapon->magic++; 710 weapon->magic++;
845 weapon->last_eat++; 711 weapon->last_eat++;
846 new_draw_info_format(NDI_UNIQUE, 0, op 712 new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon magic increased to %d", weapon->magic);
847 ,"Weapon magic increased to %d",weapon->magic);
848 decrease_ob(improver); 713 decrease_ob (improver);
849 weapon->item_power++; 714 weapon->item_power++;
850 return 1; 715 return 1;
851 } 716 }
852 717
853 sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex+ 718 sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +
854 weapon->stats.Pow + weapon->stats.Con + weapon->stats.Cha + 719 weapon->stats.Pow + weapon->stats.Con + weapon->stats.Cha + weapon->stats.Wis;
855 weapon->stats.Wis;
856 720
857 if (sacrifice_needed<1) 721 if (sacrifice_needed < 1)
858 sacrifice_needed =1; 722 sacrifice_needed = 1;
859 sacrifice_needed *=2; 723 sacrifice_needed *= 2;
860 724
861 sacrifice_count = check_sacrifice(op,improver); 725 sacrifice_count = check_sacrifice (op, improver);
862 if (sacrifice_count < sacrifice_needed) { 726 if (sacrifice_count < sacrifice_needed)
863 new_draw_info_format(NDI_UNIQUE, 0, op, 727 {
864 "You need at least %d %s", sacrifice_needed, improver->slaying); 728 new_draw_info_format (NDI_UNIQUE, 0, op, "You need at least %d %s", sacrifice_needed, &improver->slaying);
865 return 0; 729 return 0;
866 } 730 }
867 eat_item(op,improver->slaying, sacrifice_needed); 731 eat_item (op, improver->slaying, sacrifice_needed);
868 weapon->item_power++; 732 weapon->item_power++;
869 733
870 switch (improver->stats.sp) { 734 switch (improver->stats.sp)
735 {
871 case IMPROVE_STR: 736 case IMPROVE_STR:
872 return improve_weapon_stat(op,improver,weapon, 737 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Str), 1, "strength");
873 (signed char *) &(weapon->stats.Str),
874 1, "strength");
875 case IMPROVE_DEX: 738 case IMPROVE_DEX:
876 return improve_weapon_stat(op,improver,weapon, 739 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Dex), 1, "dexterity");
877 (signed char *) &(weapon->stats.Dex),
878 1, "dexterity");
879 case IMPROVE_CON: 740 case IMPROVE_CON:
880 return improve_weapon_stat(op,improver,weapon, 741 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Con), 1, "constitution");
881 (signed char *) &(weapon->stats.Con),
882 1, "constitution");
883 case IMPROVE_WIS: 742 case IMPROVE_WIS:
884 return improve_weapon_stat(op,improver,weapon, 743 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Wis), 1, "wisdom");
885 (signed char *) &(weapon->stats.Wis),
886 1, "wisdom");
887 case IMPROVE_CHA: 744 case IMPROVE_CHA:
888 return improve_weapon_stat(op,improver,weapon, 745 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Cha), 1, "charisma");
889 (signed char *) &(weapon->stats.Cha),
890 1, "charisma");
891 case IMPROVE_INT: 746 case IMPROVE_INT:
892 return improve_weapon_stat(op,improver,weapon, 747 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Int), 1, "intelligence");
893 (signed char *) &(weapon->stats.Int),
894 1, "intelligence");
895 case IMPROVE_POW: 748 case IMPROVE_POW:
896 return improve_weapon_stat(op,improver,weapon, 749 return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Pow), 1, "power");
897 (signed char *) &(weapon->stats.Pow),
898 1, "power");
899 default: 750 default:
900 new_draw_info(NDI_UNIQUE, 0,op,"Unknown improvement type."); 751 new_draw_info (NDI_UNIQUE, 0, op, "Unknown improvement type.");
901 } 752 }
902 LOG(llevError,"improve_weapon: Got to end of function\n"); 753 LOG (llevError, "improve_weapon: Got to end of function\n");
903 return 0; 754 return 0;
904} 755}
905 756
906/** 757/**
907 * Handles the applying of improve/prepare/enchant weapon scroll. 758 * Handles the applying of improve/prepare/enchant weapon scroll.
908 * Checks a few things (not on a non-magic square, marked weapon, ...), 759 * Checks a few things (not on a non-magic square, marked weapon, ...),
909 * then calls improve_weapon to do the dirty work. 760 * then calls improve_weapon to do the dirty work.
910 */ 761 */
762int
911int check_improve_weapon (object *op, object *tmp) 763check_improve_weapon (object *op, object *tmp)
912{ 764{
913 object *otmp; 765 object *otmp;
914 766
915 if(op->type!=PLAYER) 767 if (op->type != PLAYER)
768 return 0;
769 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
770 {
771 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");
916 return 0; 772 return 0;
917 if (!QUERY_FLAG(op, FLAG_WIZCAST) && (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)) {
918 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of the scroll.");
919 return 0;
920 } 773 }
921 otmp=find_marked_object(op); 774 otmp = find_marked_object (op);
922 if(!otmp) { 775 if (!otmp)
776 {
923 new_draw_info(NDI_UNIQUE, 0, op, "You need to mark a weapon object."); 777 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark a weapon object.");
924 return 0; 778 return 0;
925 } 779 }
926 if (otmp->type != WEAPON && otmp->type != BOW) { 780 if (otmp->type != WEAPON && otmp->type != BOW)
781 {
927 new_draw_info(NDI_UNIQUE, 0,op,"Marked item is not a weapon or bow"); 782 new_draw_info (NDI_UNIQUE, 0, op, "Marked item is not a weapon or bow");
928 return 0; 783 return 0;
929 } 784 }
930 new_draw_info(NDI_UNIQUE, 0,op,"Applied weapon builder."); 785 new_draw_info (NDI_UNIQUE, 0, op, "Applied weapon builder.");
931 improve_weapon(op,tmp,otmp); 786 improve_weapon (op, tmp, otmp);
932 esrv_send_item(op, otmp); 787 esrv_send_item (op, otmp);
933 return 1; 788 return 1;
934} 789}
935 790
936/** 791/**
937 * This code deals with the armour improvment scrolls. 792 * This code deals with the armour improvment scrolls.
938 * Change limits on improvement - let players go up to 793 * Change limits on improvement - let players go up to
… …
953 * the armour value of the piece of equipment exceed either 808 * the armour value of the piece of equipment exceed either
954 * the users level or 90) 809 * the users level or 90)
955 * Modified by MSW for partial resistance. Only support 810 * Modified by MSW for partial resistance. Only support
956 * changing of physical area right now. 811 * changing of physical area right now.
957 */ 812 */
813int
958int improve_armour(object *op, object *improver, object *armour) 814improve_armour (object *op, object *improver, object *armour)
959{ 815{
960 object *tmp; 816 object *tmp;
961 817
962 if (armour->magic >= settings.armor_max_enchant) { 818 if (armour->magic >= settings.armor_max_enchant)
819 {
963 new_draw_info(NDI_UNIQUE, 0,op,"This armour can not be enchanted any further."); 820 new_draw_info (NDI_UNIQUE, 0, op, "This armour can not be enchanted any further.");
964 return 0; 821 return 0;
965 } 822 }
966 /* Dealing with random artifact armor is a lot trickier (in terms of value, weight, 823 /* Dealing with random artifact armor is a lot trickier (in terms of value, weight,
967 * etc), so take the easy way out and don't worry about it. 824 * etc), so take the easy way out and don't worry about it.
968 * Note - maybe add scrolls which make the random artifact versions (eg, armour 825 * Note - maybe add scrolls which make the random artifact versions (eg, armour
969 * of gnarg and what not?) 826 * of gnarg and what not?)
970 */ 827 */
971 if (armour->title) { 828 if (armour->title)
829 {
972 new_draw_info(NDI_UNIQUE, 0, op, "This armour will not accept further enchantment."); 830 new_draw_info (NDI_UNIQUE, 0, op, "This armour will not accept further enchantment.");
973 return 0; 831 return 0;
974 } 832 }
975 833
976 /* Split objects if needed. Can't insert tmp until the 834 /* Split objects if needed. Can't insert tmp until the
977 * end of this function - otherwise it will just re-merge. 835 * end of this function - otherwise it will just re-merge.
978 */ 836 */
979 if(armour->nrof > 1) 837 if (armour->nrof > 1)
980 tmp = get_split_ob(armour,armour->nrof - 1); 838 tmp = get_split_ob (armour, armour->nrof - 1);
981 else 839 else
982 tmp = NULL; 840 tmp = NULL;
983 841
984 armour->magic++; 842 armour->magic++;
985 843
986 if ( !settings.armor_speed_linear ) 844 if (!settings.armor_speed_linear)
987 { 845 {
988 int base = 100; 846 int base = 100;
989 int pow = 0; 847 int pow = 0;
848
990 while ( pow < armour->magic ) 849 while (pow < armour->magic)
991 { 850 {
992 base = base - ( base * settings.armor_speed_improvement ) / 100; 851 base = base - (base * settings.armor_speed_improvement) / 100;
993 pow++; 852 pow++;
994 } 853 }
995 854
996 ARMOUR_SPEED( armour ) = ( ARMOUR_SPEED( &armour->arch->clone ) * base ) / 100; 855 ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * base) / 100;
997 } 856 }
998 else 857 else
999 ARMOUR_SPEED( armour ) = ( ARMOUR_SPEED( &armour->arch->clone ) * ( 100 + armour->magic * settings.armor_speed_improvement ) )/100; 858 ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * (100 + armour->magic * settings.armor_speed_improvement)) / 100;
1000 859
1001 if ( !settings.armor_weight_linear ) 860 if (!settings.armor_weight_linear)
1002 { 861 {
1003 int base = 100; 862 int base = 100;
1004 int pow = 0; 863 int pow = 0;
864
1005 while ( pow < armour->magic ) 865 while (pow < armour->magic)
1006 { 866 {
1007 base = base - ( base * settings.armor_weight_reduction ) / 100; 867 base = base - (base * settings.armor_weight_reduction) / 100;
1008 pow++; 868 pow++;
1009 } 869 }
1010 870
1011 armour->weight = ( armour->arch->clone.weight * base ) / 100; 871 armour->weight = (armour->arch->clone.weight * base) / 100;
1012 } 872 }
1013 else 873 else
1014 armour->weight = ( armour->arch->clone.weight * ( 100 - armour->magic * settings.armor_weight_reduction ) ) / 100; 874 armour->weight = (armour->arch->clone.weight * (100 - armour->magic * settings.armor_weight_reduction)) / 100;
1015 875
1016 if ( armour->weight <= 0 ) 876 if (armour->weight <= 0)
1017 { 877 {
1018 LOG( llevInfo, "Warning: enchanted armours can have negative weight\n." ); 878 LOG (llevInfo, "Warning: enchanted armours can have negative weight\n.");
1019 armour->weight = 1; 879 armour->weight = 1;
1020 } 880 }
1021 881
1022 armour->item_power = get_power_from_ench(armour->arch->clone.item_power + armour->magic); 882 armour->item_power = get_power_from_ench (armour->arch->clone.item_power + armour->magic);
1023 883
1024 if (op->type == PLAYER) { 884 if (op->type == PLAYER)
885 {
1025 esrv_send_item(op, armour); 886 esrv_send_item (op, armour);
1026 if(QUERY_FLAG(armour, FLAG_APPLIED)) 887 if (QUERY_FLAG (armour, FLAG_APPLIED))
1027 fix_player(op); 888 fix_player (op);
1028 } 889 }
1029 decrease_ob(improver); 890 decrease_ob (improver);
1030 if (tmp) { 891 if (tmp)
892 {
1031 insert_ob_in_ob(tmp, op); 893 insert_ob_in_ob (tmp, op);
1032 esrv_send_item(op, tmp); 894 esrv_send_item (op, tmp);
1033 } 895 }
1034 return 1; 896 return 1;
1035} 897}
1036 898
1037 899
1038/* 900/*
1039 * convert_item() returns 1 if anything was converted, 0 if the item was not 901 * convert_item() returns 1 if anything was converted, 0 if the item was not
… …
1047/* Takes one items and makes another. 909/* Takes one items and makes another.
1048 * converter is the object that is doing the conversion. 910 * converter is the object that is doing the conversion.
1049 * item is the object that triggered the converter - if it is not 911 * item is the object that triggered the converter - if it is not
1050 * what the converter wants, this will not do anything. 912 * what the converter wants, this will not do anything.
1051 */ 913 */
914int
1052int convert_item(object *item, object *converter) { 915convert_item (object *item, object *converter)
916{
1053 int nr=0; 917 int nr = 0;
1054 object *tmp;
1055 int is_in_shop;
1056 uint32 price_in; 918 uint32 price_in;
1057 919
1058 for(tmp = get_map_ob(converter->map, converter->x, converter->y);
1059 tmp != NULL;
1060 tmp = tmp->above) {
1061 if(tmp->type == SHOP_FLOOR)
1062 break;
1063 }
1064 is_in_shop = (tmp != NULL);
1065
1066 /* We make some assumptions - we assume if it takes money as it type, 920 /* We make some assumptions - we assume if it takes money as it type,
1067 * it wants some amount. We don't make change (ie, if something costs 921 * it wants some amount. We don't make change (ie, if something costs
1068 * 3 gp and player drops a platinum, tough luck) 922 * 3 gp and player drops a platinum, tough luck)
1069 */ 923 */
1070 if (!strcmp(CONV_FROM(converter),"money")) { 924 if (!strcmp (CONV_FROM (converter), "money"))
1071 int cost; 925 {
926 int cost;
1072 927
1073 if(item->type!=MONEY) 928 if (item->type != MONEY)
1074 return 0; 929 return 0;
1075 930
1076 nr=(item->nrof*item->value)/CONV_NEED(converter); 931 nr = (item->nrof * item->value) / CONV_NEED (converter);
1077 if (!nr) return 0; 932 if (!nr)
933 return 0;
1078 cost=nr*CONV_NEED(converter)/item->value; 934 cost = nr * CONV_NEED (converter) / item->value;
1079 /* take into account rounding errors */ 935 /* take into account rounding errors */
1080 if (nr*CONV_NEED(converter)%item->value) cost++; 936 if (nr * CONV_NEED (converter) % item->value)
937 cost++;
1081 decrease_ob_nr(item, cost); 938 decrease_ob_nr (item, cost);
1082 939
1083 price_in = cost*item->value; 940 price_in = cost * item->value;
941 }
942 else
1084 } 943 {
1085 else {
1086 if(item->type==PLAYER||CONV_FROM(converter)!=item->arch->name|| 944 if (item->type == PLAYER || CONV_FROM (converter) != item->arch->name ||
1087 (CONV_NEED(converter)&&CONV_NEED(converter)>item->nrof)) 945 (CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof))
1088 return 0; 946 return 0;
1089 947
1090 if(CONV_NEED(converter)) { 948 if (CONV_NEED (converter))
949 {
1091 nr=item->nrof/CONV_NEED(converter); 950 nr = item->nrof / CONV_NEED (converter);
1092 decrease_ob_nr(item,nr*CONV_NEED(converter)); 951 decrease_ob_nr (item, nr * CONV_NEED (converter));
1093 price_in = nr*CONV_NEED(converter)*item->value; 952 price_in = nr * CONV_NEED (converter) * item->value;
1094 } else { 953 }
954 else
955 {
1095 price_in = item->value; 956 price_in = item->value;
1096 remove_ob(item); 957 item->destroy ();
1097 free_object(item); 958 }
1098 }
1099 } 959 }
1100 960
1101 if (converter->inv != NULL) { 961 if (converter->inv != NULL)
962 {
1102 object *ob; 963 object *ob;
1103 int i; 964 int i;
1104 object *ob_to_copy; 965 object *ob_to_copy;
1105 966
1106 /* select random object from inventory to copy */ 967 /* select random object from inventory to copy */
1107 ob_to_copy = converter->inv; 968 ob_to_copy = converter->inv;
1108 for (ob = converter->inv->below, i = 1; ob != NULL; ob = ob->below, i++) { 969 for (ob = converter->inv->below, i = 1; ob != NULL; ob = ob->below, i++)
970 {
1109 if (rndm(0, i) == 0) { 971 if (rndm (0, i) == 0)
1110 ob_to_copy = ob; 972 {
973 ob_to_copy = ob;
974 }
975 }
976 item = object_create_clone (ob_to_copy);
977 CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);
978 unflag_inv (item, FLAG_IS_A_TEMPLATE);
1111 } 979 }
1112 } 980 else
1113 item = object_create_clone(ob_to_copy); 981 {
1114 CLEAR_FLAG(item, FLAG_IS_A_TEMPLATE);
1115 unflag_inv(item, FLAG_IS_A_TEMPLATE);
1116 } else {
1117 if (converter->other_arch == NULL) { 982 if (converter->other_arch == NULL)
1118 LOG(llevError,"move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n", converter->name ? converter->name : "(null)", converter->map->path, converter->x, converter->y); 983 {
984 LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n",
985 &converter->name, converter->map->path, converter->x, converter->y);
1119 return -1; 986 return -1;
1120 } 987 }
1121 988
1122 item = object_create_arch(converter->other_arch); 989 item = object_create_arch (converter->other_arch);
1123 fix_generated_item(item, converter, 0, 0, GT_MINIMAL); 990 fix_generated_item (item, converter, 0, 0, GT_MINIMAL);
1124 } 991 }
1125 992
1126 if(CONV_NR(converter)) 993 if (CONV_NR (converter))
1127 item->nrof=CONV_NR(converter); 994 item->nrof = CONV_NR (converter);
1128 if(nr) 995 if (nr)
1129 item->nrof*=nr; 996 item->nrof *= nr;
1130 if(is_in_shop) 997 if (is_in_shop (converter))
1131 SET_FLAG(item,FLAG_UNPAID); 998 SET_FLAG (item, FLAG_UNPAID);
1132 else if(price_in < item->nrof*item->value) { 999 else if (price_in < item->nrof * item->value)
1000 {
1133 LOG(llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n", 1001 LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
1134 converter->name, converter->map->path, converter->x, converter->y, price_in, 1002 &converter->name, converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
1135 item->nrof*item->value, item->name); 1003
1136 /** 1004 /**
1137 * elmex: we are going to let the game continue, as the mapcreator 1005 * elmex: we are going to let the game continue, as the mapcreator
1138 * propably had something in mind when doing this 1006 * propably had something in mind when doing this
1139 */ 1007 */
1140 } 1008 }
1141 insert_ob_in_map_at(item, converter->map, converter, 0, converter->x, converter->y); 1009 insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);
1142 return 1; 1010 return 1;
1143} 1011}
1144 1012
1145/** 1013/**
1146 * Handle apply on containers. 1014 * Handle apply on containers.
1147 * By Eneq(@csd.uu.se). 1015 * By Eneq(@csd.uu.se).
1148 * Moved to own function and added many features [Tero.Haatanen@lut.fi] 1016 * Moved to own function and added many features [Tero.Haatanen@lut.fi]
1149 * added the alchemical cauldron to the code -b.t. 1017 * added the alchemical cauldron to the code -b.t.
1150 */ 1018 */
1151 1019
1020int
1152int apply_container (object *op, object *sack) 1021apply_container (object *op, object *sack)
1153{ 1022{
1154 char buf[MAX_BUF]; 1023 char buf[MAX_BUF];
1155 object *tmp; 1024 object *tmp;
1156 1025
1157 if(op->type!=PLAYER) 1026 if (op->type != PLAYER)
1158 return 0; /* This might change */ 1027 return 0; /* This might change */
1159 1028
1160 if (sack==NULL || sack->type != CONTAINER) { 1029 if (sack == NULL || sack->type != CONTAINER)
1030 {
1161 LOG (llevError, "apply_container: %s is not container!\n",sack?sack->name:"NULL"); 1031 LOG (llevError, "apply_container: %s is not container!\n", sack ? &sack->name : "[nullobject]");
1162 return 0; 1032 return 0;
1163 } 1033 }
1164 op->contr->last_used = NULL; 1034 op->contr->last_used = NULL;
1165 op->contr->last_used_id = 0; 1035 op->contr->last_used_id = 0;
1166 1036
1167 if (sack->env!=op) { 1037 if (sack->env != op)
1038 {
1168 if (sack->other_arch == NULL || sack->env != NULL) { 1039 if (sack->other_arch == NULL || sack->env != NULL)
1040 {
1169 new_draw_info(NDI_UNIQUE, 0,op,"You must get it first."); 1041 new_draw_info (NDI_UNIQUE, 0, op, "You must get it first.");
1170 return 1; 1042 return 1;
1171 } 1043 }
1172 /* It's on the ground, the problems begin */ 1044 /* It's on the ground, the problems begin */
1173 if (op->container != sack) { 1045 if (op->container != sack)
1046 {
1174 /* it's closed OR some player has opened it */ 1047 /* it's closed OR some player has opened it */
1175 if (QUERY_FLAG(sack, FLAG_APPLIED)) { 1048 if (QUERY_FLAG (sack, FLAG_APPLIED))
1176 for(tmp=get_map_ob(sack->map, sack->x, sack->y); 1049 {
1177 tmp && tmp->container != sack; tmp=tmp->above); 1050 for (tmp = get_map_ob (sack->map, sack->x, sack->y); tmp && tmp->container != sack; tmp = tmp->above);
1178 if (tmp) { 1051 if (tmp)
1052 {
1179 /* some other player have opened it */ 1053 /* some other player have opened it */
1180 new_draw_info_format(NDI_UNIQUE, 0, op, 1054 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already occupied.", query_name (sack));
1181 "%s is already occupied.", query_name(sack)); 1055 return 1;
1182 return 1; 1056 }
1183 } 1057 }
1184 } 1058 }
1185 }
1186 if ( QUERY_FLAG(sack, FLAG_APPLIED)) {
1187 if (op->container == NULL) {
1188 tmp = arch_to_object (sack->other_arch);
1189 /* not good, but insert_ob_in_ob() is too smart */
1190 CLEAR_FLAG (tmp, FLAG_REMOVED);
1191 tmp->x= tmp->y = tmp->ox = tmp->oy = 0;
1192 tmp->map = NULL;
1193 tmp->env = sack;
1194 if (sack->inv)
1195 sack->inv->above = tmp;
1196 tmp->below = sack->inv;
1197 tmp->above = NULL;
1198 sack->inv = tmp;
1199 sack->move_off = MOVE_ALL; /* trying force closing it */
1200 } else {
1201 sack->move_off = 0;
1202 tmp = sack->inv;
1203 if (tmp && tmp->type == CLOSE_CON) {
1204 remove_ob(tmp);
1205 free_object (tmp);
1206 }
1207 }
1208 }
1209 }
1210
1211 if (QUERY_FLAG (sack, FLAG_APPLIED)) { 1059 if (QUERY_FLAG (sack, FLAG_APPLIED))
1212 if (op->container) { 1060 {
1213 if (op->container != sack) { 1061 if (op->container == NULL)
1214 tmp = op->container; 1062 {
1215 apply_container (op, tmp); 1063 tmp = arch_to_object (sack->other_arch);
1216 sprintf (buf, "You close %s and open ", query_name(tmp)); 1064 /* not good, but insert_ob_in_ob() is too smart */
1217 op->container = sack; 1065 CLEAR_FLAG (tmp, FLAG_REMOVED);
1218 strcat (buf, query_name(sack)); 1066 tmp->x = tmp->y = 0;
1219 strcat (buf, "."); 1067 tmp->map = NULL;
1220 } else { 1068 tmp->env = sack;
1221 CLEAR_FLAG (sack, FLAG_APPLIED); 1069 if (sack->inv)
1222 op->container = NULL; 1070 sack->inv->above = tmp;
1223 sprintf (buf, "You close %s.", query_name(sack)); 1071 tmp->below = sack->inv;
1072 tmp->above = NULL;
1073 sack->inv = tmp;
1074 sack->move_off = MOVE_ALL; /* trying force closing it */
1075 }
1076 else
1077 {
1078 sack->move_off = 0;
1079 tmp = sack->inv;
1080
1081 if (tmp && tmp->type == CLOSE_CON)
1082 tmp->destroy ();
1083 }
1084 }
1224 } 1085 }
1225 } else { 1086
1087 if (QUERY_FLAG (sack, FLAG_APPLIED))
1088 {
1089 if (op->container)
1090 {
1091 if (op->container != sack)
1092 {
1093 tmp = op->container;
1094 apply_container (op, tmp);
1095 sprintf (buf, "You close %s and open ", query_name (tmp));
1096 op->container = sack;
1097 strcat (buf, query_name (sack));
1098 strcat (buf, ".");
1099 }
1100 else
1101 {
1102 CLEAR_FLAG (sack, FLAG_APPLIED);
1103 op->container = NULL;
1104 sprintf (buf, "You close %s.", query_name (sack));
1105 }
1106 }
1107 else
1108 {
1226 CLEAR_FLAG (sack, FLAG_APPLIED); 1109 CLEAR_FLAG (sack, FLAG_APPLIED);
1227 sprintf (buf, "You open %s.", query_name(sack)); 1110 sprintf (buf, "You open %s.", query_name (sack));
1228 SET_FLAG (sack, FLAG_APPLIED); 1111 SET_FLAG (sack, FLAG_APPLIED);
1229 op->container = sack; 1112 op->container = sack;
1230 } 1113 }
1231 } else { /* not applied */ 1114 }
1232 if (sack->slaying) { /* it's locked */ 1115 else
1116 { /* not applied */
1117 if (sack->slaying)
1118 { /* it's locked */
1233 tmp = find_key(op, op, sack); 1119 tmp = find_key (op, op, sack);
1234 if (tmp) { 1120 if (tmp)
1121 {
1235 sprintf (buf, "You unlock %s with %s.", query_name(sack), query_name(tmp)); 1122 sprintf (buf, "You unlock %s with %s.", query_name (sack), query_name (tmp));
1236 SET_FLAG (sack, FLAG_APPLIED); 1123 SET_FLAG (sack, FLAG_APPLIED);
1237 if (sack->env == NULL) { /* if it's on ground,open it also */ 1124 if (sack->env == NULL)
1125 { /* if it's on ground,open it also */
1238 new_draw_info (NDI_UNIQUE,0,op, buf); 1126 new_draw_info (NDI_UNIQUE, 0, op, buf);
1239 apply_container (op, sack); 1127 apply_container (op, sack);
1240 return 1; 1128 return 1;
1241 } 1129 }
1242 } else { 1130 }
1131 else
1132 {
1243 sprintf (buf, "You don't have the key to unlock %s.", 1133 sprintf (buf, "You don't have the key to unlock %s.", query_name (sack));
1244 query_name(sack)); 1134 }
1245 } 1135 }
1246 } else { 1136 else
1137 {
1247 sprintf (buf, "You readied %s.", query_name(sack)); 1138 sprintf (buf, "You readied %s.", query_name (sack));
1248 SET_FLAG (sack, FLAG_APPLIED); 1139 SET_FLAG (sack, FLAG_APPLIED);
1249 if (sack->env == NULL) { /* if it's on ground,open it also */ 1140 if (sack->env == NULL)
1141 { /* if it's on ground,open it also */
1250 new_draw_info (NDI_UNIQUE, 0, op, buf); 1142 new_draw_info (NDI_UNIQUE, 0, op, buf);
1251 apply_container (op, sack); 1143 apply_container (op, sack);
1252 return 1; 1144 return 1;
1145 }
1146 }
1253 } 1147 }
1254 }
1255 }
1256 new_draw_info (NDI_UNIQUE, 0, op, buf); 1148 new_draw_info (NDI_UNIQUE, 0, op, buf);
1149 if (op->contr)
1257 if (op->contr) op->contr->socket.update_look=1; 1150 op->contr->socket.update_look = 1;
1258 return 1; 1151 return 1;
1259} 1152}
1260 1153
1261/** 1154/**
1262 * Eneq(@csd.uu.se): Handle apply on containers. This is for containers 1155 * Eneq(@csd.uu.se): Handle apply on containers. This is for containers
1263 * the player has in their inventory, eg, sacks, luggages, etc. 1156 * the player has in their inventory, eg, sacks, luggages, etc.
… …
1270 * Reminder - there are three states for any container - closed (non applied), 1163 * Reminder - there are three states for any container - closed (non applied),
1271 * applied (not open, but objects that match get tossed into it), and open 1164 * applied (not open, but objects that match get tossed into it), and open
1272 * (applied flag set, and op->container points to the open container) 1165 * (applied flag set, and op->container points to the open container)
1273 */ 1166 */
1274 1167
1168int
1275int esrv_apply_container (object *op, object *sack) 1169esrv_apply_container (object *op, object *sack)
1276{ 1170{
1277 object *tmp=op->container; 1171 object *tmp = op->container;
1172
1278 if(op->type!=PLAYER) 1173 if (op->type != PLAYER)
1279 return 0; /* This might change */ 1174 return 0; /* This might change */
1280 1175
1281 if (sack==NULL || sack->type != CONTAINER) { 1176 if (sack == NULL || sack->type != CONTAINER)
1282 LOG (llevError,
1283 "esrv_apply_container: %s is not container!\n",sack?sack->name:"NULL");
1284 return 0;
1285 } 1177 {
1178 LOG (llevError, "esrv_apply_container: %s is not container!\n", sack ? &sack->name : "[nullobject]");
1179 return 0;
1180 }
1286 1181
1287 /* If we have a currently open container, then it needs to be closed in all cases 1182 /* If we have a currently open container, then it needs to be closed in all cases
1288 * if we are opening this one up. We then fall through if appropriate for 1183 * if we are opening this one up. We then fall through if appropriate for
1289 * openening the new container. 1184 * openening the new container.
1290 */ 1185 */
1291 1186
1292 if (op->container && QUERY_FLAG(sack, FLAG_APPLIED)) { 1187 if (op->container && QUERY_FLAG (sack, FLAG_APPLIED))
1293 if (op->container->env != op) { /* if container is on the ground */ 1188 {
1189 if (op->container->env != op)
1190 { /* if container is on the ground */
1294 op->container->move_off = 0; 1191 op->container->move_off = 0;
1295 } 1192 }
1296 1193
1297 if (INVOKE_OBJECT (CLOSE, op)) 1194 if (INVOKE_OBJECT (CLOSE, tmp, ARG_OBJECT (op)))
1298 return 1; 1195 return 1;
1299 1196
1300 new_draw_info_format(NDI_UNIQUE, 0, op, "You close %s.", 1197 new_draw_info_format (NDI_UNIQUE, 0, op, "You close %s.", query_name (op->container));
1301 query_name(op->container));
1302 CLEAR_FLAG(op->container, FLAG_APPLIED); 1198 CLEAR_FLAG (op->container, FLAG_APPLIED);
1303 op->container=NULL; 1199 op->container = NULL;
1304 esrv_update_item (UPD_FLAGS, op, tmp); 1200 esrv_update_item (UPD_FLAGS, op, tmp);
1305 if (tmp == sack) return 1; 1201 if (tmp == sack)
1202 return 1;
1306 } 1203 }
1307 1204
1308 1205
1309 /* If the player is trying to open it (which he must be doing if we got here), 1206 /* If the player is trying to open it (which he must be doing if we got here),
1310 * and it is locked, check to see if player has the equipment to open it. 1207 * and it is locked, check to see if player has the equipment to open it.
1311 */ 1208 */
1312 1209
1313 if (sack->slaying) { /* it's locked */ 1210 if (sack->slaying)
1211 { /* it's locked */
1314 tmp=find_key(op, op, sack); 1212 tmp = find_key (op, op, sack);
1315 if (tmp) { 1213 if (tmp)
1214 {
1316 new_draw_info_format(NDI_UNIQUE, 0, op, "You unlock %s with %s.", query_name(sack), query_name(tmp)); 1215 new_draw_info_format (NDI_UNIQUE, 0, op, "You unlock %s with %s.", query_name (sack), query_name (tmp));
1317 } else {
1318 new_draw_info_format(NDI_UNIQUE, 0, op, "You don't have the key to unlock %s.",
1319 query_name(sack));
1320 return 0;
1321 } 1216 }
1217 else
1218 {
1219 new_draw_info_format (NDI_UNIQUE, 0, op, "You don't have the key to unlock %s.", query_name (sack));
1220 return 0;
1221 }
1322 } 1222 }
1323 1223
1324 /* By the time we get here, we have made sure any other container has been closed and 1224 /* By the time we get here, we have made sure any other container has been closed and
1325 * if this is a locked container, the player they key to open it. 1225 * if this is a locked container, the player they key to open it.
1326 */ 1226 */
1327 1227
1328 /* There are really two cases - the sack is either on the ground, or the sack is 1228 /* There are really two cases - the sack is either on the ground, or the sack is
1329 * part of the players inventory. If on the ground, we assume that the player is 1229 * part of the players inventory. If on the ground, we assume that the player is
1330 * opening it, since if it was being closed, that would have been taken care of above. 1230 * opening it, since if it was being closed, that would have been taken care of above.
1331 */ 1231 */
1332 1232
1333 1233
1334 if (sack->env != op) { 1234 if (sack->env != op)
1235 {
1335 /* Hypothetical case - the player is trying to open a sack that belong to someone 1236 /* Hypothetical case - the player is trying to open a sack that belong to someone
1336 * else. This normally should not happen, but a misbehaving client/player could 1237 * else. This normally should not happen, but a misbehaving client/player could
1337 * try to do it, so lets handle it gracefully. 1238 * try to do it, so lets handle it gracefully.
1338 */ 1239 */
1339 if (sack->env) { 1240 if (sack->env)
1241 {
1340 new_draw_info_format(NDI_UNIQUE, 0, op, "You can't open %s", 1242 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't open %s", query_name (sack));
1341 query_name(sack));
1342 return 0; 1243 return 0;
1343 } 1244 }
1344 /* set these so when the player walks off, we can unapply the sack */ 1245 /* set these so when the player walks off, we can unapply the sack */
1345 sack->move_off = MOVE_ALL; /* trying force closing it */ 1246 sack->move_off = MOVE_ALL; /* trying force closing it */
1346 1247
1347 CLEAR_FLAG (sack, FLAG_APPLIED);
1348 new_draw_info_format(NDI_UNIQUE, 0, op, "You open %s.", query_name(sack));
1349 SET_FLAG (sack, FLAG_APPLIED);
1350 op->container = sack;
1351 esrv_update_item (UPD_FLAGS, op, sack);
1352 esrv_send_inventory (op, sack);
1353
1354 } else { /* sack is in players inventory */
1355 if (QUERY_FLAG (sack, FLAG_APPLIED)) { /* readied sack becoming open */
1356 CLEAR_FLAG (sack, FLAG_APPLIED); 1248 CLEAR_FLAG (sack, FLAG_APPLIED);
1357 new_draw_info_format(NDI_UNIQUE, 0, op, "You open %s.", query_name(sack)); 1249 new_draw_info_format (NDI_UNIQUE, 0, op, "You open %s.", query_name (sack));
1358 SET_FLAG (sack, FLAG_APPLIED); 1250 SET_FLAG (sack, FLAG_APPLIED);
1359 op->container = sack; 1251 op->container = sack;
1360 esrv_update_item (UPD_FLAGS, op, sack); 1252 esrv_update_item (UPD_FLAGS, op, sack);
1361 esrv_send_inventory (op, sack); 1253 esrv_send_inventory (op, sack);
1362 } 1254
1363 else { 1255 }
1256 else
1257 { /* sack is in players inventory */
1258 if (QUERY_FLAG (sack, FLAG_APPLIED))
1259 { /* readied sack becoming open */
1364 CLEAR_FLAG (sack, FLAG_APPLIED); 1260 CLEAR_FLAG (sack, FLAG_APPLIED);
1261 new_draw_info_format (NDI_UNIQUE, 0, op, "You open %s.", query_name (sack));
1262 SET_FLAG (sack, FLAG_APPLIED);
1263 op->container = sack;
1264 esrv_update_item (UPD_FLAGS, op, sack);
1265 esrv_send_inventory (op, sack);
1266 }
1267 else
1268 {
1269 CLEAR_FLAG (sack, FLAG_APPLIED);
1365 new_draw_info_format(NDI_UNIQUE, 0, op, "You readied %s.", query_name(sack)); 1270 new_draw_info_format (NDI_UNIQUE, 0, op, "You readied %s.", query_name (sack));
1366 SET_FLAG (sack, FLAG_APPLIED); 1271 SET_FLAG (sack, FLAG_APPLIED);
1367 esrv_update_item (UPD_FLAGS, op, sack); 1272 esrv_update_item (UPD_FLAGS, op, sack);
1368 } 1273 }
1369 } 1274 }
1370 return 1; 1275 return 1;
1371} 1276}
1372 1277
1373 1278
1374/** 1279/**
1375 * Handles dropping things on altar. 1280 * Handles dropping things on altar.
1376 * Returns true if sacrifice was accepted. 1281 * Returns true if sacrifice was accepted.
1377 */ 1282 */
1283static int
1378static int apply_altar (object *altar, object *sacrifice, object *originator) 1284apply_altar (object *altar, object *sacrifice, object *originator)
1379{ 1285{
1380 /* Only players can make sacrifices on spell casting altars. */ 1286 /* Only players can make sacrifices on spell casting altars. */
1381 if (altar->inv && ( ! originator || originator->type != PLAYER)) 1287 if (altar->inv && (!originator || originator->type != PLAYER))
1382 return 0; 1288 return 0;
1383 1289
1384 if (operate_altar (altar, &sacrifice)) { 1290 if (operate_altar (altar, &sacrifice))
1291 {
1385 /* Simple check. Unfortunately, it means you can't cast magic bullet 1292 /* Simple check. Unfortunately, it means you can't cast magic bullet
1386 * with an altar. We call it a Potion - altars are stationary - it 1293 * with an altar. We call it a Potion - altars are stationary - it
1387 * is up to map designers to use them properly. 1294 * is up to map designers to use them properly.
1388 */ 1295 */
1389 if (altar->inv && altar->inv->type==SPELL) { 1296 if (altar->inv && altar->inv->type == SPELL)
1297 {
1390 new_draw_info_format (NDI_BLACK, 0, originator, "The altar casts %s.", 1298 new_draw_info_format (NDI_BLACK, 0, originator, "The altar casts %s.", &altar->inv->name);
1391 altar->inv->name);
1392 cast_spell (originator, altar, 0, altar->inv, NULL); 1299 cast_spell (originator, altar, 0, altar->inv, NULL);
1393 /* If it is connected, push the button. Fixes some problems with 1300 /* If it is connected, push the button. Fixes some problems with
1394 * old maps. 1301 * old maps.
1395 */ 1302 */
1303
1396/* push_button (altar);*/ 1304/* push_button (altar);*/
1397 } else { 1305 }
1306 else
1307 {
1398 altar->value = 1; /* works only once */ 1308 altar->value = 1; /* works only once */
1399 push_button (altar); 1309 push_button (altar);
1400 } 1310 }
1401 return sacrifice == NULL; 1311
1402 } else { 1312 return !sacrifice;
1313 }
1314 else
1403 return 0; 1315 return 0;
1404 }
1405} 1316}
1406
1407 1317
1408/** 1318/**
1409 * Handles 'movement' of shop mats. 1319 * Handles 'movement' of shop mats.
1410 * Returns 1 if 'op' was destroyed, 0 if not. 1320 * Returns 1 if 'op' was destroyed, 0 if not.
1411 * Largely re-written to not use nearly as many gotos, plus 1321 * Largely re-written to not use nearly as many gotos, plus
1412 * some of this code just looked plain out of date. 1322 * some of this code just looked plain out of date.
1413 * MSW 2001-08-29 1323 * MSW 2001-08-29
1414 */ 1324 */
1325int
1415int apply_shop_mat (object *shop_mat, object *op) 1326apply_shop_mat (object *shop_mat, object *op)
1416{ 1327{
1417 int rv = 0; 1328 int rv = 0;
1418 double opinion; 1329 double opinion;
1419 object *tmp, *next; 1330 object *tmp, *next;
1420 1331
1421 SET_FLAG (op,FLAG_NO_APPLY); /* prevent loops */ 1332 SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1422 1333
1423 if (op->type != PLAYER) { 1334 if (op->type != PLAYER)
1335 {
1424 /* Remove all the unpaid objects that may be carried here. 1336 /* Remove all the unpaid objects that may be carried here.
1425 * This could be pets or monsters that are somehow in 1337 * This could be pets or monsters that are somehow in
1426 * the shop. 1338 * the shop.
1427 */ 1339 */
1428 for (tmp=op->inv; tmp; tmp=next) { 1340 for (tmp = op->inv; tmp; tmp = next)
1341 {
1429 next = tmp->below; 1342 next = tmp->below;
1343
1430 if (QUERY_FLAG(tmp, FLAG_UNPAID)) { 1344 if (QUERY_FLAG (tmp, FLAG_UNPAID))
1345 {
1431 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9); 1346 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
1432 1347
1433 remove_ob(tmp); 1348 tmp->remove ();
1434 if (i==-1) i=0; 1349
1435 tmp->map = op->map; 1350 if (i == -1)
1351 i = 0;
1352
1353 tmp->map = op->map;
1436 tmp->x = op->x + freearr_x[i]; 1354 tmp->x = op->x + freearr_x[i];
1437 tmp->y = op->y + freearr_y[i]; 1355 tmp->y = op->y + freearr_y[i];
1438 insert_ob_in_map(tmp, op->map, op, 0); 1356 insert_ob_in_map (tmp, op->map, op, 0);
1439 } 1357 }
1440 } 1358 }
1441 1359
1442 /* Don't teleport things like spell effects */ 1360 /* Don't teleport things like spell effects */
1443 if (QUERY_FLAG(op, FLAG_NO_PICK)) return 0; 1361 if (QUERY_FLAG (op, FLAG_NO_PICK))
1362 return 0;
1444 1363
1445 /* unpaid objects, or non living objects, can't transfer by 1364 /* unpaid objects, or non living objects, can't transfer by
1446 * shop mats. Instead, put it on a nearby space. 1365 * shop mats. Instead, put it on a nearby space.
1447 */ 1366 */
1448 if (QUERY_FLAG(op, FLAG_UNPAID) || !QUERY_FLAG(op, FLAG_ALIVE)) { 1367 if (QUERY_FLAG (op, FLAG_UNPAID) || !QUERY_FLAG (op, FLAG_ALIVE))
1368 {
1449 1369
1450 /* Somebody dropped an unpaid item, just move to an adjacent place. */ 1370 /* Somebody dropped an unpaid item, just move to an adjacent place. */
1371 int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
1372
1373 if (i != -1)
1374 rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);
1375
1376 return 0;
1377 }
1378 /* Removed code that checked for multipart objects - it appears that
1379 * the teleport function should be able to handle this just fine.
1380 */
1381 rv = teleport (shop_mat, SHOP_MAT, op);
1382 }
1383 else if (can_pay (op) && get_payment (op))
1384 {
1385 /* this is only used for players */
1386 rv = teleport (shop_mat, SHOP_MAT, op);
1387
1388 if (shop_mat->msg)
1389 new_draw_info (NDI_UNIQUE, 0, op, shop_mat->msg);
1390 /* This check below is a bit simplistic - generally it should be correct,
1391 * but there is never a guarantee that the bottom space on the map is
1392 * actually the shop floor.
1393 */
1394 else if (!rv && !is_in_shop (op))
1395 {
1396 opinion = shopkeeper_approval (op->map, op);
1397
1398 if (opinion > 0.9)
1399 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper gives you a friendly wave.");
1400 else if (opinion > 0.75)
1401 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper waves to you.");
1402 else if (opinion > 0.5)
1403 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper ignores you.");
1404 else
1405 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper glares at you with contempt.");
1406 }
1407 }
1408 else
1409 {
1410 /* if we get here, a player tried to leave a shop but was not able
1411 * to afford the items he has. We try to move the player so that
1412 * they are not on the mat anymore
1413 */
1451 int i = find_free_spot (op, op->map, op->x, op->y, 1, 9); 1414 int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
1415
1452 if (i != -1) { 1416 if (i == -1)
1453 rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, 1417 {
1454 shop_mat);
1455 }
1456 return 0;
1457 }
1458 /* Removed code that checked for multipart objects - it appears that
1459 * the teleport function should be able to handle this just fine.
1460 */
1461 rv = teleport (shop_mat, SHOP_MAT, op);
1462 }
1463 /* immediate block below is only used for players */
1464 else if (can_pay(op)) {
1465 get_payment (op, op->inv);
1466 rv = teleport (shop_mat, SHOP_MAT, op);
1467 if (shop_mat->msg) {
1468 new_draw_info (NDI_UNIQUE, 0, op, shop_mat->msg);
1469 }
1470 /* This check below is a bit simplistic - generally it should be correct,
1471 * but there is never a guarantee that the bottom space on the map is
1472 * actually the shop floor.
1473 */
1474 else if ( ! rv && (tmp = get_map_ob (op->map, op->x, op->y)) != NULL
1475 && tmp->type != SHOP_FLOOR) {
1476 opinion = shopkeeper_approval(op->map, op);
1477 if ( opinion > 0.9)
1478 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper gives you a friendly wave.");
1479 else if ( opinion > 0.75)
1480 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper waves to you.");
1481 else if ( opinion > 0.5)
1482 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper ignores you.");
1483 else
1484 new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper glares at you with contempt.");
1485 }
1486 }
1487 else {
1488 /* if we get here, a player tried to leave a shop but was not able
1489 * to afford the items he has. We try to move the player so that
1490 * they are not on the mat anymore
1491 */
1492
1493 int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
1494 if(i == -1) {
1495 LOG (llevError, "Internal shop-mat problem.\n"); 1418 LOG (llevError, "Internal shop-mat problem.\n");
1496 } else { 1419 }
1497 remove_ob (op); 1420 else
1421 {
1422 op->remove ();
1498 op->x += freearr_x[i]; 1423 op->x += freearr_x[i];
1499 op->y += freearr_y[i]; 1424 op->y += freearr_y[i];
1500 rv = insert_ob_in_map (op, op->map, shop_mat,0) == NULL; 1425 rv = insert_ob_in_map (op, op->map, shop_mat, 0) == NULL;
1501 } 1426 }
1502 } 1427 }
1428
1503 CLEAR_FLAG (op, FLAG_NO_APPLY); 1429 CLEAR_FLAG (op, FLAG_NO_APPLY);
1504 return rv; 1430 return rv;
1505} 1431}
1506 1432
1507/** 1433/**
1508 * Handles applying a sign. 1434 * Handles applying a sign.
1509 */ 1435 */
1436static void
1510static void apply_sign (object *op, object *sign, int autoapply) 1437apply_sign (object *op, object *sign, int autoapply)
1511{ 1438{
1512 readable_message_type* msgType; 1439 readable_message_type *msgType;
1513 char newbuf[HUGE_BUF]; 1440 char newbuf[HUGE_BUF];
1441
1514 if (sign->msg == NULL) { 1442 if (sign->msg == NULL)
1443 {
1515 new_draw_info (NDI_UNIQUE, 0, op, "Nothing is written on it."); 1444 new_draw_info (NDI_UNIQUE, 0, op, "Nothing is written on it.");
1445 return;
1446 }
1447
1448 if (sign->stats.food)
1449 {
1450 if (sign->last_eat >= sign->stats.food)
1451 {
1452 if (!sign->move_on)
1453 new_draw_info (NDI_UNIQUE, 0, op, "You cannot read it anymore.");
1516 return; 1454 return;
1517 } 1455 }
1518 1456
1519 if (sign->stats.food) {
1520 if (sign->last_eat >= sign->stats.food) {
1521 if (!sign->move_on)
1522 new_draw_info (NDI_UNIQUE, 0, op, "You cannot read it anymore.");
1523 return;
1524 }
1525
1526 if (!QUERY_FLAG(op, FLAG_WIZPASS)) 1457 if (!QUERY_FLAG (op, FLAG_WIZPASS))
1527 sign->last_eat++; 1458 sign->last_eat++;
1528 } 1459 }
1529 1460
1530 /* Sign or magic mouth? Do we need to see it, or does it talk to us? 1461 /* Sign or magic mouth? Do we need to see it, or does it talk to us?
1531 * No way to know for sure. The presumption is basically that if 1462 * No way to know for sure. The presumption is basically that if
1532 * move_on is zero, it needs to be manually applied (doesn't talk 1463 * move_on is zero, it needs to be manually applied (doesn't talk
1533 * to us). 1464 * to us).
1534 */ 1465 */
1535 if (QUERY_FLAG (op, FLAG_BLIND) && ! QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on) { 1466 if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)
1536 new_draw_info (NDI_UNIQUE, 0, op, 1467 {
1537 "You are unable to read while blind."); 1468 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
1538 return; 1469 return;
1539 } 1470 }
1540 msgType=get_readable_message_type(sign); 1471 msgType = get_readable_message_type (sign);
1541 snprintf(newbuf,sizeof(newbuf),"%hhu %s", autoapply?1:0,sign->msg); 1472 snprintf (newbuf, sizeof (newbuf), "%hhu %s", autoapply ? 1 : 0, &sign->msg);
1542 draw_ext_info(NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, sign->msg); 1473 draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg);
1543} 1474}
1544
1545 1475
1546/** 1476/**
1547 * 'victim' moves onto 'trap' 1477 * 'victim' moves onto 'trap'
1548 * 'victim' leaves 'trap' 1478 * 'victim' leaves 'trap'
1549 * effect is determined by move_on/move_off of trap and move_type of victime. 1479 * effect is determined by move_on/move_off of trap and move_type of victime.
1550 * 1480 *
1551 * originator: Player, monster or other object that caused 'victim' to move 1481 * originator: Player, monster or other object that caused 'victim' to move
1552 * onto 'trap'. Will receive messages caused by this action. May be NULL. 1482 * onto 'trap'. Will receive messages caused by this action. May be NULL.
1553 * However, some types of traps require an originator to function. 1483 * However, some types of traps require an originator to function.
1554 */ 1484 */
1485void
1555void move_apply (object *trap, object *victim, object *originator) 1486move_apply (object *trap, object *victim, object *originator)
1556{ 1487{
1557 static int recursion_depth = 0; 1488 static int recursion_depth = 0;
1558 1489
1559 /* Only exits affect DMs. */ 1490 /* Only exits affect DMs. */
1560 if (QUERY_FLAG(victim, FLAG_WIZPASS) && trap->type != EXIT && trap->type != SIGN) 1491 if (QUERY_FLAG (victim, FLAG_WIZPASS) && trap->type != EXIT && trap->type != SIGN)
1561 return; 1492 return;
1562 1493
1563 /* move_apply() is the most likely candidate for causing unwanted and 1494 /* move_apply() is the most likely candidate for causing unwanted and
1564 * possibly unlimited recursion. 1495 * possibly unlimited recursion.
1565 */ 1496 */
… …
1567 * maps to fail. 1) it's not an error to recurse: 1498 * maps to fail. 1) it's not an error to recurse:
1568 * rune detonates, summoning monster. monster lands on nearby rune. 1499 * rune detonates, summoning monster. monster lands on nearby rune.
1569 * nearby rune detonates. This sort of recursion is expected and 1500 * nearby rune detonates. This sort of recursion is expected and
1570 * proper. This code was causing needless crashes. 1501 * proper. This code was causing needless crashes.
1571 */ 1502 */
1572 if (recursion_depth >= 500) { 1503 if (recursion_depth >= 500)
1504 {
1573 LOG (llevDebug, "WARNING: move_apply(): aborting recursion " 1505 LOG (llevDebug, "WARNING: move_apply(): aborting recursion "
1574 "[trap arch %s, name %s; victim arch %s, name %s]\n", 1506 "[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->name, &trap->name, &victim->arch->name, &victim->name);
1575 trap->arch->name, trap->name, victim->arch->name, victim->name); 1507 return;
1576 return;
1577 } 1508 }
1578 recursion_depth++; 1509 recursion_depth++;
1579 if (trap->head) trap=trap->head; 1510 if (trap->head)
1511 trap = trap->head;
1580 1512
1581 if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator))) 1513 if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
1514 goto leave;
1515
1516 switch (trap->type)
1517 {
1518 case PLAYERMOVER:
1519 if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
1520 {
1521 if (!trap->stats.maxsp)
1522 trap->stats.maxsp = 2;
1523
1524 /* Is this correct? From the docs, it doesn't look like it
1525 * should be divided by trap->speed
1526 */
1527 victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);
1528
1529 /* Just put in some sanity check. I think there is a bug in the
1530 * above with some objects have zero speed, and thus the player
1531 * getting permanently paralyzed.
1532 */
1533 if (victim->speed_left < -50.0)
1534 victim->speed_left = -50.0;
1535 /* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1536 }
1582 goto leave; 1537 goto leave;
1583 1538
1584 switch (trap->type) {
1585 case PLAYERMOVER:
1586 if (trap->attacktype && (trap->level || victim->type!=PLAYER) &&
1587 !should_director_abort(trap, victim)) {
1588 if (!trap->stats.maxsp) trap->stats.maxsp=2;
1589
1590 /* Is this correct? From the docs, it doesn't look like it
1591 * should be divided by trap->speed
1592 */
1593 victim->speed_left = -FABS(trap->stats.maxsp*victim->speed/trap->speed);
1594
1595 /* Just put in some sanity check. I think there is a bug in the
1596 * above with some objects have zero speed, and thus the player
1597 * getting permanently paralyzed.
1598 */
1599 if (victim->speed_left<-50.0) victim->speed_left=-50.0;
1600 /* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left);*/
1601 }
1602 goto leave;
1603
1604 case SPINNER: 1539 case SPINNER:
1605 if(victim->direction) { 1540 if (victim->direction)
1541 {
1606 victim->direction=absdir(victim->direction-trap->stats.sp); 1542 victim->direction = absdir (victim->direction - trap->stats.sp);
1607 update_turn_face(victim); 1543 update_turn_face (victim);
1608 } 1544 }
1609 goto leave; 1545 goto leave;
1610 1546
1611 case DIRECTOR: 1547 case DIRECTOR:
1612 if(victim->direction && !should_director_abort(trap, victim)) { 1548 if (victim->direction && !should_director_abort (trap, victim))
1549 {
1613 victim->direction=trap->stats.sp; 1550 victim->direction = trap->stats.sp;
1614 update_turn_face(victim); 1551 update_turn_face (victim);
1615 } 1552 }
1616 goto leave; 1553 goto leave;
1617 1554
1618 case BUTTON: 1555 case BUTTON:
1619 case PEDESTAL: 1556 case PEDESTAL:
1620 update_button(trap); 1557 update_button (trap);
1621 goto leave; 1558 goto leave;
1622 1559
1623 case ALTAR: 1560 case ALTAR:
1624 /* sacrifice victim on trap */ 1561 /* sacrifice victim on trap */
1625 apply_altar (trap, victim, originator); 1562 apply_altar (trap, victim, originator);
1626 goto leave; 1563 goto leave;
1627 1564
1628 case THROWN_OBJ: 1565 case THROWN_OBJ:
1629 if (trap->inv == NULL) 1566 if (trap->inv == NULL)
1630 goto leave; 1567 goto leave;
1631 /* fallthrough */ 1568 /* fallthrough */
1632 1569
1633 case ARROW: 1570 case ARROW:
1634
1635 /* bad bug: monster throw a object, make a step forwards, step on object , 1571 /* bad bug: monster throw a object, make a step forwards, step on object ,
1636 * trigger this here and get hit by own missile - and will be own enemy. 1572 * trigger this here and get hit by own missile - and will be own enemy.
1637 * Victim then is his own enemy and will start to kill herself (this is 1573 * Victim then is his own enemy and will start to kill herself (this is
1638 * removed) but we have not synced victim and his missile. To avoid senseless 1574 * removed) but we have not synced victim and his missile. To avoid senseless
1639 * action, we avoid hits here 1575 * action, we avoid hits here
1640 */ 1576 */
1641 if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim) 1577 if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1642 hit_with_arrow (trap, victim); 1578 hit_with_arrow (trap, victim);
1643 goto leave; 1579 goto leave;
1644 1580
1645 case SPELL_EFFECT: 1581 case SPELL_EFFECT:
1646 apply_spell_effect(trap, victim); 1582 apply_spell_effect (trap, victim);
1647 goto leave; 1583 goto leave;
1648 1584
1649 case TRAPDOOR: 1585 case TRAPDOOR:
1650 { 1586 {
1651 int max, sound_was_played; 1587 int max, sound_was_played;
1652 object *ab, *ab_next; 1588 object *ab, *ab_next;
1589
1653 if(!trap->value) { 1590 if (!trap->value)
1654 int tot; 1591 {
1592 int tot;
1593
1655 for(ab=trap->above,tot=0;ab!=NULL;ab=ab->above) 1594 for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above)
1656 if ((ab->move_type && trap->move_on) || ab->move_type==0) 1595 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1657 tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying; 1596 tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying;
1658 1597
1659 if(!(trap->value=(tot>trap->weight)?1:0)) 1598 if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1660 goto leave; 1599 goto leave;
1661 1600
1662 SET_ANIMATION(trap, trap->value); 1601 SET_ANIMATION (trap, trap->value);
1663 update_object(trap,UP_OBJ_FACE); 1602 update_object (trap, UP_OBJ_FACE);
1664 } 1603 }
1665 1604
1666 for (ab = trap->above, max=100, sound_was_played = 0; --max && ab; ab=ab_next) { 1605 for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
1606 {
1667 /* need to set this up, since if we do transfer the object, 1607 /* need to set this up, since if we do transfer the object,
1668 * ab->above would be bogus 1608 * ab->above would be bogus
1669 */ 1609 */
1670 ab_next = ab->above; 1610 ab_next = ab->above;
1671 1611
1672 if ((ab->move_type && trap->move_on) || ab->move_type==0) { 1612 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1673 if ( ! sound_was_played) { 1613 {
1614 if (!sound_was_played)
1615 {
1674 play_sound_map(trap->map, trap->x, trap->y, SOUND_FALL_HOLE); 1616 play_sound_map (trap->map, trap->x, trap->y, SOUND_FALL_HOLE);
1675 sound_was_played = 1; 1617 sound_was_played = 1;
1676 } 1618 }
1677 new_draw_info(NDI_UNIQUE, 0,ab,"You fall into a trapdoor!"); 1619 new_draw_info (NDI_UNIQUE, 0, ab, "You fall into a trapdoor!");
1678 transfer_ob(ab,(int)EXIT_X(trap),(int)EXIT_Y(trap),0,ab); 1620 transfer_ob (ab, (int) EXIT_X (trap), (int) EXIT_Y (trap), 0, ab);
1679 } 1621 }
1680 } 1622 }
1681 goto leave; 1623 goto leave;
1682 } 1624 }
1683 1625
1684 1626
1685 case CONVERTER: 1627 case CONVERTER:
1686 if (convert_item (victim, trap) < 0) { 1628 if (convert_item (victim, trap) < 0)
1687 object *op; 1629 {
1630 object *op;
1688 1631
1689 new_draw_info_format(NDI_UNIQUE, 0, originator, "The %s seems to be broken!", query_name(trap)); 1632 new_draw_info_format (NDI_UNIQUE, 0, originator, "The %s seems to be broken!", query_name (trap));
1690 1633
1691 op = get_archetype("burnout"); 1634 op = get_archetype ("burnout");
1692 if (op != NULL) { 1635 if (op != NULL)
1693 op->x = trap->x; 1636 {
1694 op->y = trap->y; 1637 op->x = trap->x;
1638 op->y = trap->y;
1695 insert_ob_in_map(op, trap->map, trap, 0); 1639 insert_ob_in_map (op, trap->map, trap, 0);
1696 } 1640 }
1697 } 1641 }
1698 goto leave; 1642 goto leave;
1699 1643
1700 case TRIGGER_BUTTON: 1644 case TRIGGER_BUTTON:
1701 case TRIGGER_PEDESTAL: 1645 case TRIGGER_PEDESTAL:
1702 case TRIGGER_ALTAR: 1646 case TRIGGER_ALTAR:
1703 check_trigger (trap, victim); 1647 check_trigger (trap, victim);
1704 goto leave; 1648 goto leave;
1705 1649
1706 case DEEP_SWAMP: 1650 case DEEP_SWAMP:
1707 walk_on_deep_swamp (trap, victim); 1651 walk_on_deep_swamp (trap, victim);
1708 goto leave; 1652 goto leave;
1709 1653
1710 case CHECK_INV: 1654 case CHECK_INV:
1711 check_inv (victim, trap); 1655 check_inv (victim, trap);
1712 goto leave; 1656 goto leave;
1713 1657
1714 case HOLE: 1658 case HOLE:
1715 /* Hole not open? */ 1659 /* Hole not open? */
1716 if(trap->stats.wc > 0) 1660 if (trap->stats.wc > 0)
1717 goto leave; 1661 goto leave;
1718 1662
1719 /* Is this a multipart monster and not the head? If so, return. 1663 /* Is this a multipart monster and not the head? If so, return.
1720 * Processing will happen if the head runs into the pit 1664 * Processing will happen if the head runs into the pit
1721 */ 1665 */
1722 if (victim->head) 1666 if (victim->head)
1723 goto leave; 1667 goto leave;
1724 1668
1725 play_sound_map (victim->map, victim->x, victim->y, SOUND_FALL_HOLE); 1669 play_sound_map (victim->map, victim->x, victim->y, SOUND_FALL_HOLE);
1726 new_draw_info (NDI_UNIQUE, 0, victim, "You fall through the hole!\n"); 1670 new_draw_info (NDI_UNIQUE, 0, victim, "You fall through the hole!\n");
1727 transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim); 1671 transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim);
1728 goto leave; 1672 goto leave;
1729 1673
1730 case EXIT: 1674 case EXIT:
1731 if (victim->type == PLAYER && EXIT_PATH (trap)) { 1675 if (victim->type == PLAYER && EXIT_PATH (trap))
1676 {
1732 /* Basically, don't show exits leading to random maps the 1677 /* Basically, don't show exits leading to random maps the
1733 * players output. 1678 * players output.
1734 */ 1679 */
1735 if (trap->msg && strncmp(EXIT_PATH(trap),"/!",2) && strncmp(EXIT_PATH(trap), "/random/", 8)) 1680 if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2) && strncmp (EXIT_PATH (trap), "/random/", 8))
1736 new_draw_info (NDI_NAVY, 0, victim, trap->msg); 1681 new_draw_info (NDI_NAVY, 0, victim, trap->msg);
1737 enter_exit (victim, trap); 1682 enter_exit (victim, trap);
1738 } 1683 }
1739 goto leave; 1684 goto leave;
1740 1685
1741 case ENCOUNTER: 1686 case ENCOUNTER:
1742 /* may be some leftovers on this */ 1687 /* may be some leftovers on this */
1743 goto leave; 1688 goto leave;
1744 1689
1745 case SHOP_MAT: 1690 case SHOP_MAT:
1746 apply_shop_mat (trap, victim); 1691 apply_shop_mat (trap, victim);
1747 goto leave; 1692 goto leave;
1748 1693
1749 /* Drop a certain amount of gold, and have one item identified */ 1694 /* Drop a certain amount of gold, and have one item identified */
1750 case IDENTIFY_ALTAR: 1695 case IDENTIFY_ALTAR:
1751 apply_id_altar (victim, trap, originator); 1696 apply_id_altar (victim, trap, originator);
1752 goto leave; 1697 goto leave;
1753 1698
1754 case SIGN: 1699 case SIGN:
1755 if (victim->type != PLAYER && trap->stats.food > 0) 1700 if (victim->type != PLAYER && trap->stats.food > 0)
1756 goto leave; /* monsters musn't apply magic_mouths with counters */ 1701 goto leave; /* monsters musn't apply magic_mouths with counters */
1757 1702
1758 apply_sign (victim, trap, 1); 1703 apply_sign (victim, trap, 1);
1759 goto leave; 1704 goto leave;
1760 1705
1761 case CONTAINER: 1706 case CONTAINER:
1762 if (victim->type==PLAYER) 1707 if (victim->type == PLAYER)
1763 (void) esrv_apply_container (victim, trap); 1708 (void) esrv_apply_container (victim, trap);
1764 else 1709 else
1765 (void) apply_container (victim, trap); 1710 (void) apply_container (victim, trap);
1766 goto leave; 1711 goto leave;
1767 1712
1768 case RUNE: 1713 case RUNE:
1769 case TRAP: 1714 case TRAP:
1770 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE)) { 1715 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1716 {
1771 spring_trap(trap, victim); 1717 spring_trap (trap, victim);
1772 } 1718 }
1773 goto leave; 1719 goto leave;
1774 1720
1775 default: 1721 default:
1776 LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not " 1722 LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1777 "handled in move_apply()\n", trap->name, trap->arch->name, 1723 "handled in move_apply()\n", &trap->name, &trap->arch->name, trap->type);
1778 trap->type);
1779 goto leave; 1724 goto leave;
1780 } 1725 }
1781 1726
1782 leave: 1727leave:
1783 recursion_depth--; 1728 recursion_depth--;
1784} 1729}
1785 1730
1786/** 1731/**
1787 * Handles reading a regular (ie not containing a spell) book. 1732 * Handles reading a regular (ie not containing a spell) book.
1788 */ 1733 */
1734static void
1789static void apply_book (object *op, object *tmp) 1735apply_book (object *op, object *tmp)
1790{ 1736{
1791 int lev_diff; 1737 int lev_diff;
1792 object *skill_ob; 1738 object *skill_ob;
1793 1739
1794 if(QUERY_FLAG(op, FLAG_BLIND)&&!QUERY_FLAG(op,FLAG_WIZ)) { 1740 if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1741 {
1795 new_draw_info(NDI_UNIQUE, 0,op,"You are unable to read while blind."); 1742 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
1796 return; 1743 return;
1797 } 1744 }
1798 if(tmp->msg==NULL) { 1745 if (tmp->msg == NULL)
1799 new_draw_info_format(NDI_UNIQUE, 0, op, 1746 {
1800 "You open the %s and find it empty.", tmp->name); 1747 new_draw_info_format (NDI_UNIQUE, 0, op, "You open the %s and find it empty.", &tmp->name);
1801 return; 1748 return;
1802 } 1749 }
1803 1750
1804 /* need a literacy skill to read stuff! */ 1751 /* need a literacy skill to read stuff! */
1805 skill_ob = find_skill_by_name(op, tmp->skill); 1752 skill_ob = find_skill_by_name (op, tmp->skill);
1806 if ( ! skill_ob) { 1753 if (!skill_ob)
1807 new_draw_info(NDI_UNIQUE, 0,op,
1808 "You are unable to decipher the strange symbols.");
1809 return;
1810 } 1754 {
1755 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");
1756 return;
1757 }
1811 lev_diff = tmp->level - (skill_ob->level + 5); 1758 lev_diff = tmp->level - (skill_ob->level + 5);
1812 if ( ! QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0) { 1759 if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
1760 {
1813 if (lev_diff < 2) 1761 if (lev_diff < 2)
1814 new_draw_info(NDI_UNIQUE, 0,op,"This book is just barely beyond your comprehension."); 1762 new_draw_info (NDI_UNIQUE, 0, op, "This book is just barely beyond your comprehension.");
1815 else if (lev_diff < 3) 1763 else if (lev_diff < 3)
1816 new_draw_info(NDI_UNIQUE, 0,op,"This book is slightly beyond your comprehension."); 1764 new_draw_info (NDI_UNIQUE, 0, op, "This book is slightly beyond your comprehension.");
1817 else if (lev_diff < 5) 1765 else if (lev_diff < 5)
1818 new_draw_info(NDI_UNIQUE, 0,op,"This book is beyond your comprehension."); 1766 new_draw_info (NDI_UNIQUE, 0, op, "This book is beyond your comprehension.");
1819 else if (lev_diff < 8) 1767 else if (lev_diff < 8)
1820 new_draw_info(NDI_UNIQUE, 0,op,"This book is quite a bit beyond your comprehension."); 1768 new_draw_info (NDI_UNIQUE, 0, op, "This book is quite a bit beyond your comprehension.");
1821 else if (lev_diff < 15) 1769 else if (lev_diff < 15)
1822 new_draw_info(NDI_UNIQUE, 0,op,"This book is way beyond your comprehension."); 1770 new_draw_info (NDI_UNIQUE, 0, op, "This book is way beyond your comprehension.");
1823 else 1771 else
1824 new_draw_info(NDI_UNIQUE, 0,op,"This book is totally beyond your comprehension."); 1772 new_draw_info (NDI_UNIQUE, 0, op, "This book is totally beyond your comprehension.");
1825 return; 1773 return;
1826 } 1774 }
1827 1775
1828 readable_message_type* msgType = get_readable_message_type(tmp); 1776 readable_message_type *msgType = get_readable_message_type (tmp);
1777
1829 draw_ext_info_format(NDI_UNIQUE | NDI_NAVY, 0, op, 1778 draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1830 msgType->message_type, msgType->message_subtype, 1779 msgType->message_type, msgType->message_subtype,
1831 "You open the %s and start reading.\n%s", 1780 "You open the %s and start reading.\n%s", "%s\n%s", long_desc (tmp, op), &tmp->msg);
1832 "%s\n%s",
1833 long_desc(tmp,op), tmp->msg);
1834 1781
1835 /* gain xp from reading */ 1782 /* gain xp from reading */
1836 if(!QUERY_FLAG(tmp,FLAG_NO_SKILL_IDENT)) { /* only if not read before */ 1783 if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1784 { /* only if not read before */
1837 int exp_gain=calc_skill_exp(op,tmp, skill_ob); 1785 int exp_gain = calc_skill_exp (op, tmp, skill_ob);
1786
1838 if(!QUERY_FLAG(tmp,FLAG_IDENTIFIED)) { 1787 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1788 {
1839 /*exp_gain *= 2; because they just identified it too */ 1789 /*exp_gain *= 2; because they just identified it too */
1840 SET_FLAG(tmp,FLAG_IDENTIFIED); 1790 SET_FLAG (tmp, FLAG_IDENTIFIED);
1841 /* If in a container, update how it looks */ 1791 /* If in a container, update how it looks */
1792 if (tmp->env)
1842 if(tmp->env) esrv_update_item(UPD_FLAGS|UPD_NAME, op,tmp); 1793 esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);
1794 else
1843 else op->contr->socket.update_look=1; 1795 op->contr->socket.update_look = 1;
1844 } 1796 }
1845 change_exp(op,exp_gain, skill_ob->skill, 0); 1797 change_exp (op, exp_gain, skill_ob->skill, 0);
1846 SET_FLAG(tmp,FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */ 1798 SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
1847 } 1799 }
1848} 1800}
1849 1801
1850/** 1802/**
1851 * Handles the applying of a skill scroll, calling learn_skill straight. 1803 * Handles the applying of a skill scroll, calling learn_skill straight.
1852 * op is the person learning the skill, tmp is the skill scroll object 1804 * op is the person learning the skill, tmp is the skill scroll object
1853 */ 1805 */
1806static void
1854static void apply_skillscroll (object *op, object *tmp) 1807apply_skillscroll (object *op, object *tmp)
1855{ 1808{
1856 switch ((int) learn_skill (op, tmp)) { 1809 switch ((int) learn_skill (op, tmp))
1857 case 0: 1810 {
1811 case 0:
1858 new_draw_info(NDI_UNIQUE, 0,op,"You already possess the knowledge "); 1812 new_draw_info (NDI_UNIQUE, 0, op, "You already possess the knowledge ");
1859 new_draw_info_format(NDI_UNIQUE, 0,op,"held within the %s.\n",query_name(tmp)); 1813 new_draw_info_format (NDI_UNIQUE, 0, op, "held within the %s.\n", query_name (tmp));
1860 return; 1814 return;
1861 1815
1862 case 1: 1816 case 1:
1863 new_draw_info_format(NDI_UNIQUE, 0,op,"You succeed in learning %s", 1817 new_draw_info_format (NDI_UNIQUE, 0, op, "You succeed in learning %s", &tmp->skill);
1864 tmp->skill);
1865 new_draw_info_format(NDI_UNIQUE, 0, op,
1866 "Type 'bind ready_skill %s",tmp->skill);
1867 new_draw_info(NDI_UNIQUE, 0,op,"to store the skill in a key.");
1868 decrease_ob(tmp); 1818 decrease_ob (tmp);
1869 return; 1819 return;
1870 1820
1871 default: 1821 default:
1872 new_draw_info_format(NDI_UNIQUE,0,op, 1822 new_draw_info_format (NDI_UNIQUE, 0, op, "You fail to learn the knowledge of the %s.\n", query_name (tmp));
1873 "You fail to learn the knowledge of the %s.\n",query_name(tmp));
1874 decrease_ob(tmp); 1823 decrease_ob (tmp);
1875 return; 1824 return;
1876 } 1825 }
1877} 1826}
1878 1827
1879/** 1828/**
1880 * Actually makes op learn spell. 1829 * Actually makes op learn spell.
1881 * Informs player of what happens. 1830 * Informs player of what happens.
1882 */ 1831 */
1832void
1883void do_learn_spell (object *op, object *spell, int special_prayer) 1833do_learn_spell (object *op, object *spell, int special_prayer)
1884{ 1834{
1885 object *tmp; 1835 object *tmp;
1886 1836
1887 if (op->type != PLAYER) { 1837 if (op->type != PLAYER)
1838 {
1888 LOG (llevError, "BUG: do_learn_spell(): not a player\n"); 1839 LOG (llevError, "BUG: do_learn_spell(): not a player\n");
1889 return; 1840 return;
1890 } 1841 }
1891 1842
1892 /* Upgrade special prayers to normal prayers */ 1843 /* Upgrade special prayers to normal prayers */
1893 if ((tmp=check_spell_known (op, spell->name))!=NULL) { 1844 if ((tmp = check_spell_known (op, spell->name)) != NULL)
1845 {
1894 if (special_prayer && !QUERY_FLAG(tmp, FLAG_STARTEQUIP)) { 1846 if (special_prayer && !QUERY_FLAG (tmp, FLAG_STARTEQUIP))
1847 {
1895 LOG (llevError, "BUG: do_learn_spell(): spell already known, but not marked as startequip\n"); 1848 LOG (llevError, "BUG: do_learn_spell(): spell already known, but not marked as startequip\n");
1896 return; 1849 return;
1897 } 1850 }
1898 return; 1851 return;
1899 } 1852 }
1900 1853
1901 play_sound_player_only (op->contr, SOUND_LEARN_SPELL, 0, 0); 1854 play_sound_player_only (op->contr, SOUND_LEARN_SPELL, 0, 0);
1902 tmp = get_object(); 1855 tmp = object::create ();
1903 copy_object(spell, tmp); 1856 spell->copy_to (tmp);
1904 insert_ob_in_ob(tmp, op); 1857 insert_ob_in_ob (tmp, op);
1905 1858
1906 if (special_prayer) { 1859 if (special_prayer)
1860 {
1907 SET_FLAG(tmp, FLAG_STARTEQUIP); 1861 SET_FLAG (tmp, FLAG_STARTEQUIP);
1908 } 1862 }
1909 1863
1910 new_draw_info_format (NDI_UNIQUE, 0, op,
1911 "Type 'bind cast %s", spell->name);
1912 new_draw_info (NDI_UNIQUE, 0, op, "to store the spell in a key.");
1913 esrv_add_spells(op->contr, tmp); 1864 esrv_add_spells (op->contr, tmp);
1914} 1865}
1915 1866
1916/** 1867/**
1917 * Erases spell from player's inventory. 1868 * Erases spell from player's inventory.
1918 */ 1869 */
1870void
1919void do_forget_spell (object *op, const char *spell) 1871do_forget_spell (object *op, const char *spell)
1920{ 1872{
1921 object *spob; 1873 object *spob;
1922 1874
1923 if (op->type != PLAYER) { 1875 if (op->type != PLAYER)
1876 {
1924 LOG (llevError, "BUG: do_forget_spell(): not a player\n"); 1877 LOG (llevError, "BUG: do_forget_spell(): not a player\n");
1925 return; 1878 return;
1926 } 1879 }
1927 if ( (spob=check_spell_known (op, spell)) == NULL) { 1880 if ((spob = check_spell_known (op, spell)) == NULL)
1881 {
1928 LOG (llevError, "BUG: do_forget_spell(): spell not known\n"); 1882 LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
1929 return; 1883 return;
1930 }
1931 1884 }
1932 new_draw_info_format (NDI_UNIQUE|NDI_NAVY, 0, op, 1885
1933 "You lose knowledge of %s.", spell); 1886 new_draw_info_format (NDI_UNIQUE | NDI_NAVY, 0, op, "You lose knowledge of %s.", spell);
1934 player_unready_range_ob(op->contr, spob); 1887 player_unready_range_ob (op->contr, spob);
1935 esrv_remove_spell(op->contr, spob); 1888 esrv_remove_spell (op->contr, spob);
1936 remove_ob(spob); 1889 spob->destroy ();
1937 free_object(spob);
1938} 1890}
1939 1891
1940/** 1892/**
1941 * Handles player applying a spellbook. 1893 * Handles player applying a spellbook.
1942 * Checks whether player has knowledge of required skill, doesn't already know the spell, 1894 * Checks whether player has knowledge of required skill, doesn't already know the spell,
1943 * stuff like that. Random learning failure too. 1895 * stuff like that. Random learning failure too.
1944 */ 1896 */
1897static void
1945static void apply_spellbook (object *op, object *tmp) 1898apply_spellbook (object *op, object *tmp)
1946{ 1899{
1947 object *skop, *spell, *spell_skill; 1900 object *skop, *spell, *spell_skill;
1948 1901
1949 if(QUERY_FLAG(op, FLAG_BLIND)&&!QUERY_FLAG(op,FLAG_WIZ)) { 1902 if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1903 {
1950 new_draw_info(NDI_UNIQUE, 0,op,"You are unable to read while blind."); 1904 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
1951 return; 1905 return;
1952 } 1906 }
1953 1907
1954 /* artifact_spellbooks have 'slaying' field point to a spell name, 1908 /* artifact_spellbooks have 'slaying' field point to a spell name,
1955 * instead of having their spell stored in stats.sp. These are 1909 * instead of having their spell stored in stats.sp. These are
1956 * legacy spellbooks 1910 * legacy spellbooks
1957 */ 1911 */
1958 1912
1959 if(tmp->slaying != NULL) { 1913 if (tmp->slaying != NULL)
1914 {
1960 spell=arch_to_object(find_archetype_by_object_name(tmp->slaying)); 1915 spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));
1961 if (!spell) { 1916 if (!spell)
1962 new_draw_info_format(NDI_UNIQUE, 0, op, 1917 {
1963 "The book's formula for %s is incomplete", tmp->slaying); 1918 new_draw_info_format (NDI_UNIQUE, 0, op, "The book's formula for %s is incomplete", &tmp->slaying);
1964 return; 1919 return;
1965 } 1920 }
1966 else 1921 else
1967 insert_ob_in_ob(spell, tmp); 1922 insert_ob_in_ob (spell, tmp);
1968 free_string(tmp->slaying);
1969 tmp->slaying=NULL; 1923 tmp->slaying = NULL;
1970 } 1924 }
1971 1925
1972 skop = find_skill_by_name(op, tmp->skill); 1926 skop = find_skill_by_name (op, tmp->skill);
1973 1927
1974 /* need a literacy skill to learn spells. Also, having a literacy level 1928 /* need a literacy skill to learn spells. Also, having a literacy level
1975 * lower than the spell will make learning the spell more difficult */ 1929 * lower than the spell will make learning the spell more difficult */
1976 if ( !skop) { 1930 if (!skop)
1931 {
1977 new_draw_info(NDI_UNIQUE, 0,op,"You can't read! Your attempt fails."); 1932 new_draw_info (NDI_UNIQUE, 0, op, "You can't read! Your attempt fails.");
1978 return; 1933 return;
1979 } 1934 }
1980 1935
1981 spell = tmp->inv; 1936 spell = tmp->inv;
1937
1982 if (!spell) { 1938 if (!spell)
1939 {
1983 LOG(llevError,"apply_spellbook: Book %s has no spell in it!\n", tmp->name); 1940 LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1984 new_draw_info(NDI_UNIQUE, 0,op,"The spellbook symbols make no sense."); 1941 new_draw_info (NDI_UNIQUE, 0, op, "The spellbook symbols make no sense.");
1985 return; 1942 return;
1986 }
1987 if (spell->level > (skop->level+10)) {
1988 new_draw_info(NDI_UNIQUE, 0,op,"You are unable to decipher the strange symbols.");
1989 return;
1990 } 1943 }
1991 1944
1992 new_draw_info_format(NDI_UNIQUE, 0, op, 1945 if (skop->level < int (sqrtf (spell->level) * 1.5f))
1993 "The spellbook contains the %s level spell %s.", 1946 {
1994 get_levelnumber(spell->level), spell->name); 1947 new_draw_info (NDI_UNIQUE, 0, op, "It is too hard to read at your level: You are unable to decipher the strange symbols.");
1948 return;
1949 }
1995 1950
1951 new_draw_info_format (NDI_UNIQUE, 0, op, "The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name);
1952
1996 if (!QUERY_FLAG(tmp, FLAG_IDENTIFIED)) { 1953 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1954 {
1997 identify(tmp); 1955 identify (tmp);
1998 if (tmp->env) 1956 if (tmp->env)
1999 esrv_update_item(UPD_FLAGS|UPD_NAME,op,tmp); 1957 esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);
2000 else 1958 else
2001 op->contr->socket.update_look=1; 1959 op->contr->socket.update_look = 1;
2002 } 1960 }
2003 1961
2004 /* I removed the check for special_prayer_mark here - it didn't make 1962 /* I removed the check for special_prayer_mark here - it didn't make
2005 * a lot of sense - special prayers are not found in spellbooks, and 1963 * a lot of sense - special prayers are not found in spellbooks, and
2006 * if the player doesn't know the spell, doesn't make a lot of sense that 1964 * if the player doesn't know the spell, doesn't make a lot of sense that
2007 * they would have a special prayer mark. 1965 * they would have a special prayer mark.
2008 */ 1966 */
2009 if (check_spell_known (op, spell->name)) { 1967 if (check_spell_known (op, spell->name))
1968 {
2010 new_draw_info(NDI_UNIQUE, 0,op,"You already know that spell.\n"); 1969 new_draw_info (NDI_UNIQUE, 0, op, "You already know that spell.\n");
2011 return; 1970 return;
2012 } 1971 }
2013 1972
2014 if (spell->skill) { 1973 if (spell->skill)
1974 {
2015 spell_skill = find_skill_by_name(op, spell->skill); 1975 spell_skill = find_skill_by_name (op, spell->skill);
1976
2016 if (!spell_skill) { 1977 if (!spell_skill)
2017 new_draw_info_format(NDI_UNIQUE, 0, op, 1978 {
2018 "You lack the skill %s to use this spell", 1979 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use this spell", &spell->skill);
2019 spell->skill);
2020 return; 1980 return;
2021 } 1981 }
1982
2022 if (spell_skill->level < spell->level) { 1983 if (spell_skill->level < spell->level)
2023 new_draw_info_format(NDI_UNIQUE, 0, op, 1984 {
2024 "You need to be level %d in %s to learn this spell.", 1985 new_draw_info_format (NDI_UNIQUE, 0, op, "You need to be level %d in %s to learn this spell.", spell->level, &spell->skill);
2025 spell->level, spell->skill);
2026 return; 1986 return;
2027 } 1987 }
2028 } 1988 }
2029 1989
2030 /* Logic as follows 1990 /* Logic as follows
2031 * 1991 *
2032 * 1- MU spells use Int to learn, Cleric spells use Wisdom 1992 * 1- MU spells use Int to learn, Cleric spells use Wisdom
2033 * 1993 *
2034 * 2- The learner's skill level in literacy adjusts the chance to learn 1994 * 2- The learner's skill level in literacy adjusts the chance to learn
2035 * a spell. 1995 * a spell.
2036 * 1996 *
2037 * 3 -Automatically fail to learn if you read while confused 1997 * 3 -Automatically fail to learn if you read while confused
2038 * 1998 *
2039 * Overall, chances are the same but a player will find having a high 1999 * Overall, chances are the same but a player will find having a high
2040 * literacy rate very useful! -b.t. 2000 * literacy rate very useful! -b.t.
2041 */ 2001 */
2042 if(QUERY_FLAG(op,FLAG_CONFUSED)) { 2002 if (QUERY_FLAG (op, FLAG_CONFUSED))
2003 {
2043 new_draw_info(NDI_UNIQUE,0,op,"In your confused state you flub the wording of the text!"); 2004 new_draw_info (NDI_UNIQUE, 0, op, "In your confused state you flub the wording of the text!");
2044 scroll_failure(op, 0 - random_roll(0, spell->level, op, PREFER_LOW), MAX(spell->stats.sp, spell->stats.grace)); 2005 scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));
2006 }
2045 } else if(QUERY_FLAG(tmp,FLAG_STARTEQUIP) || 2007 else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
2046 (random_roll(0, 100, op, PREFER_LOW)-(5*skop->level)) < 2008 (random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
2047 learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int]) { 2009 {
2048 2010
2049 new_draw_info(NDI_UNIQUE, 0,op,"You succeed in learning the spell!"); 2011 new_draw_info (NDI_UNIQUE, 0, op, "You succeed in learning the spell!");
2050 do_learn_spell (op, spell, 0); 2012 do_learn_spell (op, spell, 0);
2051 2013
2052 /* xp gain to literacy for spell learning */ 2014 /* xp gain to literacy for spell learning */
2053 if ( ! QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 2015 if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))
2054 change_exp(op,calc_skill_exp(op,tmp,skop), skop->skill, 0); 2016 change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);
2055 } else { 2017 }
2018 else
2019 {
2056 play_sound_player_only(op->contr, SOUND_FUMBLE_SPELL,0,0); 2020 play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
2057 new_draw_info(NDI_UNIQUE, 0,op,"You fail to learn the spell.\n"); 2021 new_draw_info (NDI_UNIQUE, 0, op, "You fail to learn the spell.\n");
2058 } 2022 }
2059 decrease_ob(tmp); 2023 decrease_ob (tmp);
2060} 2024}
2061 2025
2062/** 2026/**
2063 * Handles applying a spell scroll. 2027 * Handles applying a spell scroll.
2064 */ 2028 */
2029void
2065void apply_scroll (object *op, object *tmp, int dir) 2030apply_scroll (object *op, object *tmp, int dir)
2066{ 2031{
2067 object *skop; 2032 object *skop;
2068 2033
2069 if(QUERY_FLAG(op, FLAG_BLIND)&&!QUERY_FLAG(op,FLAG_WIZ)) { 2034 if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
2035 {
2070 new_draw_info(NDI_UNIQUE, 0,op, "You are unable to read while blind."); 2036 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
2071 return; 2037 return;
2072 } 2038 }
2073 2039
2074 if (!tmp->inv || tmp->inv->type != SPELL) { 2040 if (!tmp->inv || tmp->inv->type != SPELL)
2075 new_draw_info (NDI_UNIQUE, 0, op, 2041 {
2076 "The scroll just doesn't make sense!"); 2042 new_draw_info (NDI_UNIQUE, 0, op, "The scroll just doesn't make sense!");
2077 return; 2043 return;
2078 } 2044 }
2079 2045
2080 if(op->type==PLAYER) { 2046 if (op->type == PLAYER)
2047 {
2081 /* players need a literacy skill to read stuff! */ 2048 /* players need a literacy skill to read stuff! */
2082 int exp_gain=0; 2049 int exp_gain = 0;
2083 2050
2084 /* hard code literacy - tmp->skill points to where the exp 2051 /* hard code literacy - tmp->skill points to where the exp
2085 * should go for anything killed by the spell. 2052 * should go for anything killed by the spell.
2086 */ 2053 */
2087 skop = find_skill_by_name(op, skill_names[SK_LITERACY]); 2054 skop = find_skill_by_name (op, skill_names[SK_LITERACY]);
2088 2055
2089 if ( ! skop) { 2056 if (!skop)
2090 new_draw_info(NDI_UNIQUE, 0,op, 2057 {
2091 "You are unable to decipher the strange symbols."); 2058 new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");
2092 return; 2059 return;
2093 } 2060 }
2094 2061
2095 if((exp_gain = calc_skill_exp(op,tmp, skop))) 2062 if ((exp_gain = calc_skill_exp (op, tmp, skop)))
2096 change_exp(op,exp_gain, skop->skill, 0); 2063 change_exp (op, exp_gain, skop->skill, 0);
2097 } 2064 }
2098 2065
2099 if (!QUERY_FLAG(tmp, FLAG_IDENTIFIED)) 2066 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
2100 identify(tmp); 2067 identify (tmp);
2101 2068
2102 new_draw_info_format(NDI_BLACK, 0, op, 2069 new_draw_info_format (NDI_BLACK, 0, op, "The scroll of %s turns to dust.", &tmp->inv->name);
2103 "The scroll of %s turns to dust.", tmp->inv->name);
2104 2070
2105 2071
2106 cast_spell(op,tmp,dir,tmp->inv, NULL); 2072 cast_spell (op, tmp, dir, tmp->inv, NULL);
2107 decrease_ob(tmp); 2073 decrease_ob (tmp);
2108} 2074}
2109 2075
2110/** 2076/**
2111 * Applies a treasure object - by default, chest. op 2077 * Applies a treasure object - by default, chest. op
2112 * is the person doing the applying, tmp is the treasure 2078 * is the person doing the applying, tmp is the treasure
2113 * chest. 2079 * chest.
2114 */ 2080 */
2081static void
2115static void apply_treasure (object *op, object *tmp) 2082apply_treasure (object *op, object *tmp)
2116{ 2083{
2117 object *treas; 2084 object *treas;
2118 tag_t tmp_tag = tmp->count, op_tag = op->count;
2119 2085
2120 2086
2121 /* Nice side effect of new treasure creation method is that the treasure 2087 /* Nice side effect of new treasure creation method is that the treasure
2122 * for the chest is done when the chest is created, and put into the chest 2088 * for the chest is done when the chest is created, and put into the chest
2123 * inventory. So that when the chest burns up, the items still exist. Also 2089 * inventory. So that when the chest burns up, the items still exist. Also
2124 * prevents people fromt moving chests to more difficult maps to get better 2090 * prevents people fromt moving chests to more difficult maps to get better
2125 * treasure 2091 * treasure
2126 */ 2092 */
2127 2093
2128 treas = tmp->inv; 2094 treas = tmp->inv;
2129 if(treas==NULL) { 2095 if (treas == NULL)
2096 {
2130 new_draw_info(NDI_UNIQUE, 0,op,"The chest was empty."); 2097 new_draw_info (NDI_UNIQUE, 0, op, "The chest was empty.");
2131 decrease_ob(tmp);
2132 return;
2133 }
2134 while (tmp->inv) {
2135 treas = tmp->inv;
2136
2137 remove_ob(treas);
2138 new_draw_info_format(NDI_UNIQUE, 0, op, "You find %s in the chest.",
2139 query_name(treas));
2140
2141 treas->x=op->x;
2142 treas->y=op->y;
2143 treas = insert_ob_in_map (treas, op->map, op,INS_BELOW_ORIGINATOR);
2144
2145 if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level
2146 && QUERY_FLAG (op, FLAG_ALIVE))
2147 spring_trap (treas, op);
2148 /* If either player or container was destroyed, no need to do
2149 * further processing. I think this should be enclused with
2150 * spring trap above, as I don't think there is otherwise
2151 * any way for the treasure chest or player to get killed
2152 */
2153 if (was_destroyed (op, op_tag) || was_destroyed (tmp, tmp_tag))
2154 break;
2155 }
2156
2157 if ( ! was_destroyed (tmp, tmp_tag) && tmp->inv == NULL)
2158 decrease_ob (tmp); 2098 decrease_ob (tmp);
2099 return;
2100 }
2101 while (tmp->inv)
2102 {
2103 treas = tmp->inv;
2104
2105 treas->remove ();
2106 new_draw_info_format (NDI_UNIQUE, 0, op, "You find %s in the chest.", query_name (treas));
2107
2108 treas->x = op->x;
2109 treas->y = op->y;
2110 treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);
2111
2112 if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))
2113 spring_trap (treas, op);
2114
2115 /* If either player or container was destroyed, no need to do
2116 * further processing. I think this should be enclused with
2117 * spring trap above, as I don't think there is otherwise
2118 * any way for the treasure chest or player to get killed
2119 */
2120 if (op->destroyed () || tmp->destroyed ())
2121 break;
2122 }
2123
2124 if (!tmp->destroyed () && tmp->inv == NULL)
2125 decrease_ob (tmp);
2159 2126
2160} 2127}
2161 2128
2162/** 2129/**
2163 * op eats food. 2130 * op eats food.
2164 * If player, takes care of messages and dragon special food. 2131 * If player, takes care of messages and dragon special food.
2165 */ 2132 */
2133static void
2166static void apply_food (object *op, object *tmp) 2134apply_food (object *op, object *tmp)
2167{ 2135{
2168 int capacity_remaining; 2136 int capacity_remaining;
2169 2137
2170 if(op->type!=PLAYER) 2138 if (op->type != PLAYER)
2171 op->stats.hp=op->stats.maxhp; 2139 op->stats.hp = op->stats.maxhp;
2172 else { 2140 else
2141 {
2173 /* check if this is a dragon (player), eating some flesh */ 2142 /* check if this is a dragon (player), eating some flesh */
2174 if (tmp->type==FLESH && is_dragon_pl(op) && dragon_eat_flesh(op, tmp)) 2143 if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
2175 ; 2144 ;
2176 else { 2145 else
2146 {
2177 /* usual case - no dragon meal: */ 2147 /* usual case - no dragon meal: */
2178 if(op->stats.food+tmp->stats.food>999) { 2148 if (op->stats.food + tmp->stats.food > 999)
2149 {
2179 if(tmp->type==FOOD || tmp->type==FLESH) 2150 if (tmp->type == FOOD || tmp->type == FLESH)
2180 new_draw_info(NDI_UNIQUE, 0,op,"You feel full, but what a waste of food!"); 2151 new_draw_info (NDI_UNIQUE, 0, op, "You feel full, but what a waste of food!");
2181 else 2152 else
2182 new_draw_info(NDI_UNIQUE, 0,op,"Most of the drink goes down your face not your throat!"); 2153 new_draw_info (NDI_UNIQUE, 0, op, "Most of the drink goes down your face not your throat!");
2183 } 2154 }
2184 2155
2185 if(!QUERY_FLAG(tmp, FLAG_CURSED)) { 2156 if (!QUERY_FLAG (tmp, FLAG_CURSED))
2157 {
2186 char buf[MAX_BUF]; 2158 char buf[MAX_BUF];
2187 2159
2188 if (!is_dragon_pl(op)) { 2160 if (!is_dragon_pl (op))
2161 {
2189 /* eating message for normal players*/ 2162 /* eating message for normal players */
2190 if(tmp->type==DRINK) 2163 if (tmp->type == DRINK)
2191 sprintf(buf,"Ahhh...that %s tasted good.",tmp->name); 2164 sprintf (buf, "Ahhh...that %s tasted good.", &tmp->name);
2192 else 2165 else
2193 sprintf(buf,"The %s tasted %s",tmp->name, 2166 sprintf (buf, "The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
2194 tmp->type==FLESH?"terrible!":"good."); 2167 }
2195 } 2168 else
2196 else { 2169 {
2197 /* eating message for dragon players*/ 2170 /* eating message for dragon players */
2198 sprintf(buf,"The %s tasted terrible!",tmp->name); 2171 sprintf (buf, "The %s tasted terrible!", &tmp->name);
2199 } 2172 }
2200 2173
2201 new_draw_info(NDI_UNIQUE, 0,op,buf); 2174 new_draw_info (NDI_UNIQUE, 0, op, buf);
2202 capacity_remaining = 999 - op->stats.food; 2175 capacity_remaining = 999 - op->stats.food;
2203 op->stats.food+=tmp->stats.food; 2176 op->stats.food += tmp->stats.food;
2204 if(capacity_remaining < tmp->stats.food) 2177 if (capacity_remaining < tmp->stats.food)
2205 op->stats.hp += capacity_remaining / 50; 2178 op->stats.hp += capacity_remaining / 50;
2206 else 2179 else
2207 op->stats.hp+=tmp->stats.food/50; 2180 op->stats.hp += tmp->stats.food / 50;
2208 if(op->stats.hp>op->stats.maxhp) 2181 if (op->stats.hp > op->stats.maxhp)
2209 op->stats.hp=op->stats.maxhp; 2182 op->stats.hp = op->stats.maxhp;
2210 if (op->stats.food > 999) 2183 if (op->stats.food > 999)
2211 op->stats.food = 999; 2184 op->stats.food = 999;
2212 } 2185 }
2213 2186
2214 /* special food hack -b.t. */ 2187 /* special food hack -b.t. */
2215 if(tmp->title || QUERY_FLAG(tmp,FLAG_CURSED)) 2188 if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
2216 eat_special_food(op,tmp); 2189 eat_special_food (op, tmp);
2217 } 2190 }
2218 } 2191 }
2219 handle_apply_yield(tmp); 2192 handle_apply_yield (tmp);
2220 decrease_ob(tmp); 2193 decrease_ob (tmp);
2221} 2194}
2222 2195
2223/** 2196/**
2224 * A dragon is eating some flesh. If the flesh contains resistances, 2197 * A dragon is eating some flesh. If the flesh contains resistances,
2225 * there is a chance for the dragon's skin to get improved. 2198 * there is a chance for the dragon's skin to get improved.
… …
2228 * object *op the object (dragon player) eating the flesh 2201 * object *op the object (dragon player) eating the flesh
2229 * object *meal the flesh item, getting chewed in dragon's mouth 2202 * object *meal the flesh item, getting chewed in dragon's mouth
2230 * return: 2203 * return:
2231 * int 1 if eating successful, 0 if it doesn't work 2204 * int 1 if eating successful, 0 if it doesn't work
2232 */ 2205 */
2206int
2233int dragon_eat_flesh(object *op, object *meal) { 2207dragon_eat_flesh (object *op, object *meal)
2208{
2234 object *skin = NULL; /* pointer to dragon skin force*/ 2209 object *skin = NULL; /* pointer to dragon skin force */
2235 object *abil = NULL; /* pointer to dragon ability force*/ 2210 object *abil = NULL; /* pointer to dragon ability force */
2236 object *tmp = NULL; /* tmp. object */ 2211 object *tmp = NULL; /* tmp. object */
2237 2212
2238 char buf[MAX_BUF]; /* tmp. string buffer */ 2213 char buf[MAX_BUF]; /* tmp. string buffer */
2239 double chance; /* improvement-chance of one resistance type */ 2214 double chance; /* improvement-chance of one resistance type */
2240 double totalchance=1; /* total chance of gaining one resistance */ 2215 double totalchance = 1; /* total chance of gaining one resistance */
2241 double bonus=0; /* level bonus (improvement is easier at lowlevel) */ 2216 double bonus = 0; /* level bonus (improvement is easier at lowlevel) */
2242 double mbonus=0; /* monster bonus */ 2217 double mbonus = 0; /* monster bonus */
2243 int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */ 2218 int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
2244 int winners=0; /* number of winners */ 2219 int winners = 0; /* number of winners */
2245 int i; /* index */ 2220 int i; /* index */
2246 2221
2247 /* let's make sure and doublecheck the parameters */ 2222 /* let's make sure and doublecheck the parameters */
2248 if (meal->type!=FLESH || !is_dragon_pl(op)) 2223 if (meal->type != FLESH || !is_dragon_pl (op))
2249 return 0; 2224 return 0;
2250 2225
2251 /* now grab the 'dragon_skin'- and 'dragon_ability'-forces 2226 /* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2252 from the player's inventory */ 2227 from the player's inventory */
2253 for (tmp=op->inv; tmp!=NULL; tmp=tmp->below) { 2228 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2229 {
2254 if (tmp->type == FORCE) { 2230 if (tmp->type == FORCE)
2231 {
2255 if (strcmp(tmp->arch->name, "dragon_skin_force")==0) 2232 if (strcmp (tmp->arch->name, "dragon_skin_force") == 0)
2256 skin = tmp; 2233 skin = tmp;
2257 else if (strcmp(tmp->arch->name, "dragon_ability_force")==0) 2234 else if (strcmp (tmp->arch->name, "dragon_ability_force") == 0)
2258 abil = tmp; 2235 abil = tmp;
2259 } 2236 }
2260 } 2237 }
2261 2238
2262 /* if either skin or ability are missing, this is an old player 2239 /* if either skin or ability are missing, this is an old player
2263 which is not to be considered a dragon -> bail out */ 2240 which is not to be considered a dragon -> bail out */
2264 if (skin == NULL || abil == NULL) return 0; 2241 if (skin == NULL || abil == NULL)
2265 2242 return 0;
2243
2266 /* now start by filling stomache and health, according to food-value */ 2244 /* now start by filling stomache and health, according to food-value */
2267 if((999 - op->stats.food) < meal->stats.food) 2245 if ((999 - op->stats.food) < meal->stats.food)
2268 op->stats.hp += (999 - op->stats.food) / 50; 2246 op->stats.hp += (999 - op->stats.food) / 50;
2269 else 2247 else
2270 op->stats.hp += meal->stats.food/50; 2248 op->stats.hp += meal->stats.food / 50;
2271 if(op->stats.hp>op->stats.maxhp) 2249 if (op->stats.hp > op->stats.maxhp)
2272 op->stats.hp=op->stats.maxhp; 2250 op->stats.hp = op->stats.maxhp;
2273 2251
2274 op->stats.food = MIN(999, op->stats.food + meal->stats.food); 2252 op->stats.food = MIN (999, op->stats.food + meal->stats.food);
2275 2253
2276 /*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level);*/ 2254 /*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2277 2255
2278 /* on to the interesting part: chances for adding resistance */ 2256 /* on to the interesting part: chances for adding resistance */
2279 for (i=0; i<NROFATTACKS; i++) { 2257 for (i = 0; i < NROFATTACKS; i++)
2258 {
2280 if (meal->resist[i] > 0 && atnr_is_dragon_enabled(i)) { 2259 if (meal->resist[i] > 0 && atnr_is_dragon_enabled (i))
2260 {
2281 /* got positive resistance, now calculate improvement chance (0-100) */ 2261 /* got positive resistance, now calculate improvement chance (0-100) */
2282 2262
2283 /* this bonus makes resistance increase easier at lower levels */ 2263 /* this bonus makes resistance increase easier at lower levels */
2284 bonus = (settings.max_level - op->level) * 30. / ((double)settings.max_level); 2264 bonus = (settings.max_level - op->level) * 30. / ((double) settings.max_level);
2285 if (i == abil->stats.exp) 2265 if (i == abil->stats.exp)
2286 bonus += 5; /* additional bonus for resistance of ability-focus */ 2266 bonus += 5; /* additional bonus for resistance of ability-focus */
2287 2267
2288 /* monster bonus increases with level, because high-level 2268 /* monster bonus increases with level, because high-level
2289 flesh is too rare */ 2269 flesh is too rare */
2290 mbonus = op->level * 20. / ((double)settings.max_level); 2270 mbonus = op->level * 20. / ((double) settings.max_level);
2291 2271
2292 chance = (((double)MIN(op->level+bonus, meal->level+bonus+mbonus))*100. / 2272 chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2293 ((double)settings.max_level)) - skin->resist[i]; 2273 ((double) settings.max_level)) - skin->resist[i];
2294 2274
2295 if (chance >= 0.) 2275 if (chance >= 0.)
2296 chance += 1.; 2276 chance += 1.;
2297 else 2277 else
2298 chance = (chance < -12) ? 0. : 1./pow(2., -chance); 2278 chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2299 2279
2300 /* chance is proportional to amount of resistance (max. 50) */ 2280 /* chance is proportional to amount of resistance (max. 50) */
2301 chance *= ((double)(MIN(meal->resist[i], 50)))/50.; 2281 chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;
2302 2282
2303 /* doubled chance for resistance of ability-focus */ 2283 /* doubled chance for resistance of ability-focus */
2304 if (i == abil->stats.exp) 2284 if (i == abil->stats.exp)
2305 chance = MIN(100., chance*2.); 2285 chance = MIN (100., chance * 2.);
2306 2286
2307 /* now make the throw and save all winners (Don't insert luck bonus here!) */ 2287 /* now make the throw and save all winners (Don't insert luck bonus here!) */
2308 if (RANDOM()%10000 < (int)(chance*100)) { 2288 if (RANDOM () % 10000 < (int) (chance * 100))
2289 {
2309 atnr_winner[winners] = i; 2290 atnr_winner[winners] = i;
2310 winners++; 2291 winners++;
2311 } 2292 }
2312 2293
2313 if (chance >= 0.01 ) totalchance *= 1 - chance/100; 2294 if (chance >= 0.01)
2314 2295 totalchance *= 1 - chance / 100;
2296
2315 /*LOG(llevDebug, " %s: bonus %.1f, chance %.1f\n", attacks[i], bonus, chance);*/ 2297 /*LOG(llevDebug, " %s: bonus %.1f, chance %.1f\n", attacks[i], bonus, chance); */
2316 } 2298 }
2317 } 2299 }
2318 2300
2319 /* inverse totalchance as until now we have the failure-chance */ 2301 /* inverse totalchance as until now we have the failure-chance */
2320 totalchance = 100 - totalchance*100; 2302 totalchance = 100 - totalchance * 100;
2321 /* print message according to totalchance */ 2303 /* print message according to totalchance */
2322 if (totalchance > 50.) 2304 if (totalchance > 50.)
2323 sprintf(buf, "Hmm! The %s tasted delicious!", meal->name); 2305 sprintf (buf, "Hmm! The %s tasted delicious!", &meal->name);
2324 else if (totalchance > 10.) 2306 else if (totalchance > 10.)
2325 sprintf(buf, "The %s tasted very good.", meal->name); 2307 sprintf (buf, "The %s tasted very good.", &meal->name);
2326 else if (totalchance > 1.) 2308 else if (totalchance > 1.)
2327 sprintf(buf, "The %s tasted good.", meal->name); 2309 sprintf (buf, "The %s tasted good.", &meal->name);
2328 else if (totalchance > 0.1) 2310 else if (totalchance > 0.1)
2329 sprintf(buf, "The %s tasted bland.", meal->name); 2311 sprintf (buf, "The %s tasted bland.", &meal->name);
2330 else if (totalchance >= 0.01) 2312 else if (totalchance >= 0.01)
2331 sprintf(buf, "The %s had a boring taste.", meal->name); 2313 sprintf (buf, "The %s had a boring taste.", &meal->name);
2332 else if (meal->last_eat > 0 && atnr_is_dragon_enabled(meal->last_eat)) 2314 else if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat))
2333 sprintf(buf, "The %s tasted strange.", meal->name); 2315 sprintf (buf, "The %s tasted strange.", &meal->name);
2334 else 2316 else
2335 sprintf(buf, "The %s had no taste.", meal->name); 2317 sprintf (buf, "The %s had no taste.", &meal->name);
2336 new_draw_info(NDI_UNIQUE, 0, op, buf); 2318 new_draw_info (NDI_UNIQUE, 0, op, buf);
2337 2319
2338 /* now choose a winner if we have any */ 2320 /* now choose a winner if we have any */
2339 i = -1; 2321 i = -1;
2340 if (winners>0) 2322 if (winners > 0)
2341 i = atnr_winner[RANDOM()%winners]; 2323 i = atnr_winner[RANDOM () % winners];
2342 2324
2343 if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95) { 2325 if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2326 {
2344 /* resistance increased! */ 2327 /* resistance increased! */
2345 skin->resist[i]++; 2328 skin->resist[i]++;
2346 fix_player(op); 2329 fix_player (op);
2347 2330
2348 sprintf(buf, "Your skin is now more resistant to %s!", change_resist_msg[i]); 2331 sprintf (buf, "Your skin is now more resistant to %s!", change_resist_msg[i]);
2349 new_draw_info(NDI_UNIQUE|NDI_RED, 0, op, buf); 2332 new_draw_info (NDI_UNIQUE | NDI_RED, 0, op, buf);
2350 } 2333 }
2351 2334
2352 /* if this flesh contains a new ability focus, we mark it 2335 /* if this flesh contains a new ability focus, we mark it
2353 into the ability_force and it will take effect on next level */ 2336 into the ability_force and it will take effect on next level */
2354 if (meal->last_eat > 0 && atnr_is_dragon_enabled(meal->last_eat) 2337 if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat) && meal->last_eat != abil->last_eat)
2355 && meal->last_eat != abil->last_eat) { 2338 {
2356 abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */ 2339 abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */
2357 2340
2358 if (meal->last_eat != abil->stats.exp) { 2341 if (meal->last_eat != abil->stats.exp)
2342 {
2359 sprintf(buf, "Your metabolism prepares to focus on %s!", 2343 sprintf (buf, "Your metabolism prepares to focus on %s!", change_resist_msg[meal->last_eat]);
2360 change_resist_msg[meal->last_eat]);
2361 new_draw_info(NDI_UNIQUE, 0, op, buf); 2344 new_draw_info (NDI_UNIQUE, 0, op, buf);
2362 sprintf(buf, "The change will happen at level %d", abil->level + 1); 2345 sprintf (buf, "The change will happen at level %d", abil->level + 1);
2363 new_draw_info(NDI_UNIQUE, 0, op, buf); 2346 new_draw_info (NDI_UNIQUE, 0, op, buf);
2364 } 2347 }
2365 else { 2348 else
2349 {
2366 sprintf(buf, "Your metabolism will continue to focus on %s.", 2350 sprintf (buf, "Your metabolism will continue to focus on %s.", change_resist_msg[meal->last_eat]);
2367 change_resist_msg[meal->last_eat]);
2368 new_draw_info(NDI_UNIQUE, 0, op, buf); 2351 new_draw_info (NDI_UNIQUE, 0, op, buf);
2369 abil->last_eat = 0; 2352 abil->last_eat = 0;
2370 } 2353 }
2371 } 2354 }
2372 return 1; 2355 return 1;
2373} 2356}
2374 2357
2358static void
2375static void apply_savebed (object *pl) 2359apply_savebed (object *pl)
2376{ 2360{
2377#ifndef COZY_SERVER 2361#ifndef COZY_SERVER
2378 if(!pl->contr->name_changed||!pl->stats.exp) { 2362 if (!pl->contr->name_changed || !pl->stats.exp)
2363 {
2379 new_draw_info(NDI_UNIQUE, 0,pl,"You don't deserve to save your character yet."); 2364 new_draw_info (NDI_UNIQUE, 0, pl, "You don't deserve to save your character yet.");
2380 return; 2365 return;
2381 } 2366 }
2382#endif 2367#endif
2368 INVOKE_PLAYER (LOGOUT, pl->contr);
2383 /* Need to call terminate_all_pets() before we remove the player ob */ 2369 /* Need to call terminate_all_pets() before we remove the player ob */
2384 terminate_all_pets(pl); 2370 terminate_all_pets (pl);
2385 remove_ob(pl); 2371 pl->remove ();
2386 pl->direction=0; 2372 pl->direction = 0;
2387 new_draw_info_format(NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, pl, 2373 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, pl, "%s leaves the game.", &pl->name);
2388 "%s leaves the game.",pl->name); 2374
2389
2390 /* update respawn position */ 2375 /* update respawn position */
2391 strcpy(pl->contr->savebed_map, pl->map->path); 2376 strcpy (pl->contr->savebed_map, pl->map->path);
2392 pl->contr->bed_x = pl->x; 2377 pl->contr->bed_x = pl->x;
2393 pl->contr->bed_y = pl->y; 2378 pl->contr->bed_y = pl->y;
2394 2379
2395 strcpy(pl->contr->killer,"left"); 2380 strcpy (pl->contr->killer, "left");
2396 check_score(pl); /* Always check score */ 2381 check_score (pl); /* Always check score */
2397 (void)save_player(pl,0); 2382 (void) save_player (pl, 0);
2398 pl->map->players--; 2383 pl->map->players--;
2399#if MAP_MAXTIMEOUT 2384#if MAP_MAXTIMEOUT
2400 MAP_SWAP_TIME(pl->map) = MAP_TIMEOUT(pl->map); 2385 MAP_SWAP_TIME (pl->map) = MAP_TIMEOUT (pl->map);
2401#endif 2386#endif
2402 play_again(pl); 2387 play_again (pl);
2403 pl->speed = 0; 2388 pl->speed = 0;
2404 update_ob_speed(pl); 2389 update_ob_speed (pl);
2405} 2390}
2406 2391
2407/** 2392/**
2408 * Handles applying an improve armor scroll. 2393 * Handles applying an improve armor scroll.
2409 * Does some sanity checks, then calls improve_armour. 2394 * Does some sanity checks, then calls improve_armour.
2410 */ 2395 */
2396static void
2411static void apply_armour_improver (object *op, object *tmp) 2397apply_armour_improver (object *op, object *tmp)
2412{ 2398{
2413 object *armor; 2399 object *armor;
2414 2400
2415 if (!QUERY_FLAG(op, FLAG_WIZCAST) && (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)) { 2401 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
2402 {
2416 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of the scroll."); 2403 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");
2417 return;
2418 }
2419 armor=find_marked_object(op);
2420 if ( ! armor) {
2421 new_draw_info(NDI_UNIQUE, 0, op, "You need to mark an armor object.");
2422 return; 2404 return;
2423 } 2405 }
2406 armor = find_marked_object (op);
2407 if (!armor)
2408 {
2409 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark an armor object.");
2410 return;
2411 }
2424 if (armor->type != ARMOUR 2412 if (armor->type != ARMOUR
2425 && armor->type != CLOAK 2413 && armor->type != CLOAK
2426 && armor->type != BOOTS && armor->type != GLOVES 2414 && armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)
2427 && armor->type != BRACERS && armor->type != SHIELD
2428 && armor->type != HELMET)
2429 { 2415 {
2430 new_draw_info(NDI_UNIQUE, 0,op,"Your marked item is not armour!\n"); 2416 new_draw_info (NDI_UNIQUE, 0, op, "Your marked item is not armour!\n");
2431 return; 2417 return;
2432 } 2418 }
2433 2419
2434 new_draw_info(NDI_UNIQUE, 0,op,"Applying armour enchantment."); 2420 new_draw_info (NDI_UNIQUE, 0, op, "Applying armour enchantment.");
2435 improve_armour(op,tmp,armor); 2421 improve_armour (op, tmp, armor);
2436} 2422}
2437 2423
2438 2424
2425extern void
2439extern void apply_poison (object *op, object *tmp) 2426apply_poison (object *op, object *tmp)
2440{ 2427{
2441 if (op->type == PLAYER) { 2428 if (op->type == PLAYER)
2429 {
2442 play_sound_player_only(op->contr, SOUND_DRINK_POISON,0,0); 2430 play_sound_player_only (op->contr, SOUND_DRINK_POISON, 0, 0);
2443 new_draw_info(NDI_UNIQUE, 0,op,"Yech! That tasted poisonous!"); 2431 new_draw_info (NDI_UNIQUE, 0, op, "Yech! That tasted poisonous!");
2444 strcpy(op->contr->killer,"poisonous booze"); 2432 strcpy (op->contr->killer, "poisonous booze");
2445 } 2433 }
2446 if (tmp->stats.hp > 0) { 2434 if (tmp->stats.hp > 0)
2435 {
2447 LOG(llevDebug,"Trying to poison player/monster for %d hp\n", 2436 LOG (llevDebug, "Trying to poison player/monster for %d hp\n", tmp->stats.hp);
2448 tmp->stats.hp);
2449 hit_player(op, tmp->stats.hp, tmp, AT_POISON, 1); 2437 hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1);
2450 } 2438 }
2451 op->stats.food-=op->stats.food/4; 2439 op->stats.food -= op->stats.food / 4;
2452 handle_apply_yield(tmp); 2440 handle_apply_yield (tmp);
2453 decrease_ob(tmp); 2441 decrease_ob (tmp);
2454} 2442}
2455 2443
2456/** 2444/**
2457 * This fonction return true if the exit is not a 2 ways one or it is 2 ways, valid exit. 2445 * This fonction return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2458 * A valid 2 way exit means: 2446 * A valid 2 way exit means:
… …
2463 * 2451 *
2464 * Note: a owner in a 2 way exit is saved as the owner's name 2452 * Note: a owner in a 2 way exit is saved as the owner's name
2465 * in the field exit->name cause the field exit->owner doesn't 2453 * in the field exit->name cause the field exit->owner doesn't
2466 * survive in the swapping (in fact the whole exit doesn't survive). 2454 * survive in the swapping (in fact the whole exit doesn't survive).
2467 */ 2455 */
2456int
2468int is_legal_2ways_exit (object* op, object *exit) 2457is_legal_2ways_exit (object *op, object *exit)
2469 { 2458{
2470 object * tmp; 2459 object *tmp;
2471 object * exit_owner; 2460 object *exit_owner;
2472 player * pp; 2461 player *pp;
2473 mapstruct * exitmap; 2462 maptile *exitmap;
2474 if (exit->stats.exp!=1) return 1; /*This is not a 2 way, so it is legal*/ 2463
2475 if (!has_been_loaded(EXIT_PATH(exit)) && exit->race) return 0; /* This is a reset town portal */ 2464 if (exit->stats.exp != 1)
2465 return 1; /*This is not a 2 way, so it is legal */
2466 if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2467 return 0; /* This is a reset town portal */
2476 /* To know if an exit has a correspondant, we look at 2468 /* To know if an exit has a correspondant, we look at
2477 * all the exits in destination and try to find one with same path as 2469 * all the exits in destination and try to find one with same path as
2478 * the current exit's position */ 2470 * the current exit's position */
2479 if (!strncmp(EXIT_PATH (exit), settings.localdir, strlen(settings.localdir))) 2471 if (!strncmp (EXIT_PATH (exit), settings.localdir, strlen (settings.localdir)))
2480 exitmap = ready_map_name(EXIT_PATH (exit), MAP_PLAYER_UNIQUE); 2472 exitmap = ready_map_name (EXIT_PATH (exit), MAP_PLAYER_UNIQUE);
2473 else
2481 else exitmap = ready_map_name(EXIT_PATH (exit), 0); 2474 exitmap = ready_map_name (EXIT_PATH (exit), 0);
2482 if (exitmap) 2475 if (exitmap)
2483 { 2476 {
2484 tmp=get_map_ob (exitmap,EXIT_X(exit),EXIT_Y(exit)); 2477 tmp = get_map_ob (exitmap, EXIT_X (exit), EXIT_Y (exit));
2485 if (!tmp) return 0; 2478 if (!tmp)
2479 return 0;
2486 for ( (tmp=get_map_ob(exitmap,EXIT_X(exit),EXIT_Y(exit)));tmp;tmp=tmp->above) 2480 for ((tmp = get_map_ob (exitmap, EXIT_X (exit), EXIT_Y (exit))); tmp; tmp = tmp->above)
2487 { 2481 {
2488 if (tmp->type!=EXIT) continue; /*Not an exit*/ 2482 if (tmp->type != EXIT)
2489 if (!EXIT_PATH (tmp)) continue; /*Not a valid exit*/ 2483 continue; /*Not an exit */
2490 if ( (EXIT_X(tmp)!=exit->x) || (EXIT_Y(tmp)!=exit->y)) continue; /*Not in the same place*/ 2484 if (!EXIT_PATH (tmp))
2491 if (strcmp(exit->map->path,EXIT_PATH(tmp))!=0) continue; /*Not in the same map*/ 2485 continue; /*Not a valid exit */
2486 if ((EXIT_X (tmp) != exit->x) || (EXIT_Y (tmp) != exit->y))
2487 continue; /*Not in the same place */
2488 if (strcmp (exit->map->path, EXIT_PATH (tmp)) != 0)
2489 continue; /*Not in the same map */
2492 2490
2493 /* From here we have found the exit is valid. However we do 2491 /* From here we have found the exit is valid. However we do
2494 * here the check of the exit owner. It is important for the 2492 * here the check of the exit owner. It is important for the
2495 * town portals to prevent strangers from visiting your appartments 2493 * town portals to prevent strangers from visiting your appartments
2496 */ 2494 */
2495 if (!exit->race)
2497 if (!exit->race) return 1; /*No owner, free for all!*/ 2496 return 1; /*No owner, free for all! */
2498 exit_owner=NULL; 2497 exit_owner = NULL;
2499 for (pp=first_player;pp;pp=pp->next) 2498 for (pp = first_player; pp; pp = pp->next)
2500 { 2499 {
2501 if (!pp->ob) continue; 2500 if (!pp->ob)
2501 continue;
2502 if (pp->ob->name!=exit->race) continue; 2502 if (pp->ob->name != exit->race)
2503 continue;
2503 exit_owner= pp->ob; /*We found a player which correspond to the player name*/ 2504 exit_owner = pp->ob; /*We found a player which correspond to the player name */
2504 break; 2505 break;
2505 } 2506 }
2506 if (!exit_owner) return 0; /* No more owner*/ 2507 if (!exit_owner)
2507 if (exit_owner->contr==op->contr) return 1; /*It is your exit*/ 2508 return 0; /* No more owner */
2509 if (exit_owner->contr == op->contr)
2510 return 1; /*It is your exit */
2508 if ( exit_owner && /*There is a owner*/ 2511 if (exit_owner && /*There is a owner */
2509 (op->contr) && /*A player tries to pass */ 2512 (op->contr) && /*A player tries to pass */
2510 ( (exit_owner->contr->party==NULL) || /*No pass if controller has no party*/ 2513 ((exit_owner->contr->party == NULL) || /*No pass if controller has no party */
2511 (exit_owner->contr->party!=op->contr->party)) ) /* Or not the same as op*/ 2514 (exit_owner->contr->party != op->contr->party))) /* Or not the same as op */
2512 return 0; 2515 return 0;
2513 return 1; 2516 return 1;
2514 } 2517 }
2515 } 2518 }
2516 return 0; 2519 return 0;
2517 } 2520}
2518 2521
2519 2522
2520/** 2523/**
2521 * Main apply handler. 2524 * Main apply handler.
2522 * 2525 *
… …
2532 * 2535 *
2533 * aflag is special (always apply/unapply) flags. Nothing is done with 2536 * aflag is special (always apply/unapply) flags. Nothing is done with
2534 * them in this function - they are passed to apply_special 2537 * them in this function - they are passed to apply_special
2535 */ 2538 */
2536 2539
2540int
2537int manual_apply (object *op, object *tmp, int aflag) 2541manual_apply (object *op, object *tmp, int aflag)
2538{ 2542{
2539 if (tmp->head) tmp=tmp->head; 2543 if (tmp->head)
2544 tmp = tmp->head;
2540 2545
2541 if (QUERY_FLAG (tmp, FLAG_UNPAID) && ! QUERY_FLAG (tmp, FLAG_APPLIED)) { 2546 if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))
2547 {
2542 if (op->type == PLAYER) { 2548 if (op->type == PLAYER)
2549 {
2543 new_draw_info (NDI_UNIQUE, 0, op, "You should pay for it first."); 2550 new_draw_info (NDI_UNIQUE, 0, op, "You should pay for it first.");
2544 return 1; 2551 return 1;
2545 } else { 2552 }
2553 else
2554 {
2546 return 0; /* monsters just skip unpaid items */ 2555 return 0; /* monsters just skip unpaid items */
2547 } 2556 }
2548 } 2557 }
2549 2558
2550
2551 if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op))) 2559 if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op)))
2552 return RESULT_INT (0); 2560 return RESULT_INT (0);
2553 2561
2554 switch (tmp->type) { 2562 switch (tmp->type)
2563 {
2555 2564
2556 case TRANSPORT:
2557 return apply_transport(op, tmp, aflag);
2558
2559 case CF_HANDLE: 2565 case CF_HANDLE:
2560 new_draw_info(NDI_UNIQUE, 0,op,"You turn the handle."); 2566 new_draw_info (NDI_UNIQUE, 0, op, "You turn the handle.");
2561 play_sound_map(op->map, op->x, op->y, SOUND_TURN_HANDLE); 2567 play_sound_map (op->map, op->x, op->y, SOUND_TURN_HANDLE);
2562 tmp->value=tmp->value?0:1; 2568 tmp->value = tmp->value ? 0 : 1;
2563 SET_ANIMATION(tmp, tmp->value); 2569 SET_ANIMATION (tmp, tmp->value);
2564 update_object(tmp,UP_OBJ_FACE); 2570 update_object (tmp, UP_OBJ_FACE);
2565 push_button(tmp); 2571 push_button (tmp);
2566 return 1; 2572 return 1;
2567 2573
2568 case TRIGGER: 2574 case TRIGGER:
2569 if (check_trigger (tmp, op)) { 2575 if (check_trigger (tmp, op))
2576 {
2570 new_draw_info (NDI_UNIQUE, 0, op, "You turn the handle."); 2577 new_draw_info (NDI_UNIQUE, 0, op, "You turn the handle.");
2571 play_sound_map (tmp->map, tmp->x, tmp->y, SOUND_TURN_HANDLE); 2578 play_sound_map (tmp->map, tmp->x, tmp->y, SOUND_TURN_HANDLE);
2572 } else { 2579 }
2580 else
2581 {
2573 new_draw_info (NDI_UNIQUE, 0, op, "The handle doesn't move."); 2582 new_draw_info (NDI_UNIQUE, 0, op, "The handle doesn't move.");
2574 } 2583 }
2575 return 1; 2584 return 1;
2576 2585
2577 case EXIT: 2586 case EXIT:
2578 if (op->type != PLAYER) 2587 if (op->type != PLAYER)
2579 return 0; 2588 return 0;
2580 if( ! EXIT_PATH (tmp) || !is_legal_2ways_exit(op,tmp)) { 2589 if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))
2590 {
2581 new_draw_info_format(NDI_UNIQUE, 0, op, "The %s is closed.", 2591 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));
2582 query_name(tmp)); 2592 }
2583 } else { 2593 else
2594 {
2584 /* Don't display messages for random maps. */ 2595 /* Don't display messages for random maps. */
2585 if (tmp->msg && strncmp(EXIT_PATH(tmp),"/!",2) && 2596 if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2) && strncmp (EXIT_PATH (tmp), "/random/", 8))
2586 strncmp(EXIT_PATH(tmp), "/random/", 8))
2587 new_draw_info (NDI_NAVY, 0, op, tmp->msg); 2597 new_draw_info (NDI_NAVY, 0, op, tmp->msg);
2588 enter_exit(op,tmp); 2598 enter_exit (op, tmp);
2589 } 2599 }
2590 return 1; 2600 return 1;
2591 2601
2592 case SIGN: 2602 case SIGN:
2593 apply_sign (op, tmp, 0); 2603 apply_sign (op, tmp, 0);
2594 return 1; 2604 return 1;
2595 2605
2596 case BOOK: 2606 case BOOK:
2597 if (op->type == PLAYER) { 2607 if (op->type == PLAYER)
2608 {
2598 apply_book (op, tmp); 2609 apply_book (op, tmp);
2599 return 1; 2610 return 1;
2600 } else { 2611 }
2601 return 0; 2612 else
2602 } 2613 {
2614 return 0;
2615 }
2603 2616
2604 case SKILLSCROLL: 2617 case SKILLSCROLL:
2605 if (op->type == PLAYER) { 2618 if (op->type == PLAYER)
2619 {
2606 apply_skillscroll (op, tmp); 2620 apply_skillscroll (op, tmp);
2607 return 1; 2621 return 1;
2608 } 2622 }
2609 return 0; 2623 return 0;
2610 2624
2611 case SPELLBOOK: 2625 case SPELLBOOK:
2612 if (op->type == PLAYER) { 2626 if (op->type == PLAYER)
2627 {
2613 apply_spellbook (op, tmp); 2628 apply_spellbook (op, tmp);
2614 return 1; 2629 return 1;
2615 } 2630 }
2616 return 0; 2631 return 0;
2617 2632
2618 case SCROLL: 2633 case SCROLL:
2619 apply_scroll (op, tmp, 0); 2634 apply_scroll (op, tmp, 0);
2620 return 1; 2635 return 1;
2621 2636
2622 case POTION: 2637 case POTION:
2623 (void) apply_potion(op, tmp); 2638 (void) apply_potion (op, tmp);
2624 return 1; 2639 return 1;
2625 2640
2626 /* Eneq(@csd.uu.se): Handle apply on containers. */ 2641 /* Eneq(@csd.uu.se): Handle apply on containers. */
2627 case CLOSE_CON: 2642 case CLOSE_CON:
2628 if (op->type==PLAYER)
2629 (void) esrv_apply_container (op, tmp->env);
2630 else
2631 (void) apply_container (op, tmp->env);
2632 return 1;
2633
2634 case CONTAINER:
2635 if (op->type==PLAYER)
2636 (void) esrv_apply_container (op, tmp);
2637 else
2638 (void) apply_container (op, tmp);
2639 return 1;
2640
2641 case TREASURE:
2642 if (op->type == PLAYER) { 2643 if (op->type == PLAYER)
2644 (void) esrv_apply_container (op, tmp->env);
2645 else
2646 (void) apply_container (op, tmp->env);
2647 return 1;
2648
2649 case CONTAINER:
2650 if (op->type == PLAYER)
2651 (void) esrv_apply_container (op, tmp);
2652 else
2653 (void) apply_container (op, tmp);
2654 return 1;
2655
2656 case TREASURE:
2657 if (op->type == PLAYER)
2658 {
2643 apply_treasure (op, tmp); 2659 apply_treasure (op, tmp);
2644 return 1; 2660 return 1;
2645 } else { 2661 }
2646 return 0; 2662 else
2647 } 2663 {
2664 return 0;
2665 }
2648 2666
2649 case WEAPON: 2667 case WEAPON:
2650 case ARMOUR: 2668 case ARMOUR:
2651 case BOOTS: 2669 case BOOTS:
2652 case GLOVES: 2670 case GLOVES:
2653 case AMULET: 2671 case AMULET:
2654 case GIRDLE: 2672 case GIRDLE:
2655 case BRACERS: 2673 case BRACERS:
2656 case SHIELD: 2674 case SHIELD:
2657 case HELMET: 2675 case HELMET:
2658 case RING: 2676 case RING:
2659 case CLOAK: 2677 case CLOAK:
2660 case WAND: 2678 case WAND:
2661 case ROD: 2679 case ROD:
2662 case HORN: 2680 case HORN:
2663 case SKILL: 2681 case SKILL:
2664 case BOW: 2682 case BOW:
2665 case LAMP: 2683 case LAMP:
2666 case BUILDER: 2684 case BUILDER:
2667 case SKILL_TOOL: 2685 case SKILL_TOOL:
2668 if (tmp->env != op) 2686 if (tmp->env != op)
2669 return 2; /* not in inventory */ 2687 return 2; /* not in inventory */
2670 (void) apply_special (op, tmp, aflag); 2688 (void) apply_special (op, tmp, aflag);
2671 return 1; 2689 return 1;
2672 2690
2673 case DRINK: 2691 case DRINK:
2674 case FOOD: 2692 case FOOD:
2675 case FLESH: 2693 case FLESH:
2676 apply_food (op, tmp); 2694 apply_food (op, tmp);
2677 return 1; 2695 return 1;
2678 2696
2679 case POISON: 2697 case POISON:
2680 apply_poison (op, tmp); 2698 apply_poison (op, tmp);
2681 return 1; 2699 return 1;
2682 2700
2683 case SAVEBED: 2701 case SAVEBED:
2684 if (op->type == PLAYER) { 2702 if (op->type == PLAYER)
2685 apply_savebed (op); 2703 {
2686 return 1; 2704 apply_savebed (op);
2687 } else { 2705 return 1;
2688 return 0; 2706 }
2689 } 2707 else
2708 {
2709 return 0;
2710 }
2690 2711
2691 case ARMOUR_IMPROVER: 2712 case ARMOUR_IMPROVER:
2692 if (op->type == PLAYER) { 2713 if (op->type == PLAYER)
2714 {
2693 apply_armour_improver (op, tmp); 2715 apply_armour_improver (op, tmp);
2694 return 1; 2716 return 1;
2695 } else { 2717 }
2696 return 0; 2718 else
2697 } 2719 {
2720 return 0;
2721 }
2698 2722
2699 case WEAPON_IMPROVER: 2723 case WEAPON_IMPROVER:
2700 (void) check_improve_weapon(op, tmp); 2724 (void) check_improve_weapon (op, tmp);
2701 return 1; 2725 return 1;
2702 2726
2703 case CLOCK: 2727 case CLOCK:
2704 if (op->type == PLAYER) { 2728 if (op->type == PLAYER)
2705 char buf[MAX_BUF]; 2729 {
2706 timeofday_t tod; 2730 char buf[MAX_BUF];
2731 timeofday_t tod;
2707 2732
2708 get_tod(&tod); 2733 get_tod (&tod);
2709 sprintf(buf, "It is %d minute%s past %d o'clock %s", 2734 sprintf (buf, "It is %d minute%s past %d o'clock %s",
2710 tod.minute+1, ((tod.minute+1 < 2) ? "" : "s"), 2735 tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2711 ((tod.hour % 14 == 0) ? 14 : ((tod.hour)%14)), 2736 ((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am"));
2712 ((tod.hour >= 14) ? "pm" : "am"));
2713 play_sound_player_only(op->contr, SOUND_CLOCK,0,0); 2737 play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);
2714 new_draw_info(NDI_UNIQUE, 0,op, buf); 2738 new_draw_info (NDI_UNIQUE, 0, op, buf);
2715 return 1; 2739 return 1;
2716 } else { 2740 }
2717 return 0; 2741 else
2718 } 2742 {
2743 return 0;
2744 }
2719 2745
2720 case MENU: 2746 case MENU:
2721 if (op->type == PLAYER) { 2747 if (op->type == PLAYER)
2722 shop_listing (op); 2748 {
2723 return 1; 2749 shop_listing (op);
2724 } else { 2750 return 1;
2725 return 0; 2751 }
2726 } 2752 else
2753 {
2754 return 0;
2755 }
2727 2756
2728 case POWER_CRYSTAL: 2757 case POWER_CRYSTAL:
2729 apply_power_crystal(op,tmp); /* see egoitem.c */ 2758 apply_power_crystal (op, tmp); /* see egoitem.c */
2730 return 1; 2759 return 1;
2731 2760
2732 case LIGHTER: /* for lighting torches/lanterns/etc */ 2761 case LIGHTER: /* for lighting torches/lanterns/etc */
2733 if (op->type == PLAYER) { 2762 if (op->type == PLAYER)
2734 apply_lighter(op,tmp); 2763 {
2735 return 1; 2764 apply_lighter (op, tmp);
2736 } else { 2765 return 1;
2737 return 0; 2766 }
2738 } 2767 else
2768 {
2769 return 0;
2770 }
2739 2771
2740 case ITEM_TRANSFORMER: 2772 case ITEM_TRANSFORMER:
2741 apply_item_transformer( op, tmp ); 2773 apply_item_transformer (op, tmp);
2742 return 1; 2774 return 1;
2743 2775
2744 default: 2776 default:
2745 return 0; 2777 return 0;
2746 } 2778 }
2747} 2779}
2748 2780
2749 2781
2750/* quiet suppresses the "don't know how to apply" and "you must get it first" 2782/* quiet suppresses the "don't know how to apply" and "you must get it first"
2751 * messages as needed by player_apply_below(). But there can still be 2783 * messages as needed by player_apply_below(). But there can still be
2752 * "but you are floating high above the ground" messages. 2784 * "but you are floating high above the ground" messages.
2753 * 2785 *
2754 * Same return value as apply() function. 2786 * Same return value as apply() function.
2755 */ 2787 */
2788int
2756int player_apply (object *pl, object *op, int aflag, int quiet) 2789player_apply (object *pl, object *op, int aflag, int quiet)
2757{ 2790{
2758 int tmp; 2791 int tmp;
2759 2792
2760 if (op->env == NULL && (pl->move_type & MOVE_FLYING)) { 2793 if (op->env == NULL && (pl->move_type & MOVE_FLYING))
2794 {
2761 /* player is flying and applying object not in inventory */ 2795 /* player is flying and applying object not in inventory */
2762 if ( ! QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING)) { 2796 if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
2797 {
2763 new_draw_info (NDI_UNIQUE, 0, pl, "But you are floating high " 2798 new_draw_info (NDI_UNIQUE, 0, pl, "But you are floating high " "above the ground!");
2764 "above the ground!");
2765 return 0; 2799 return 0;
2766 } 2800 }
2767 } 2801 }
2768 2802
2769 /* Check for PLAYER to avoid a DM to disappear in a puff of smoke if 2803 /* Check for PLAYER to avoid a DM to disappear in a puff of smoke if
2770 * applied. 2804 * applied.
2771 */ 2805 */
2772 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_WAS_WIZ) && ! QUERY_FLAG (pl, FLAG_WAS_WIZ)) 2806 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
2773 { 2807 {
2774 play_sound_map (pl->map, pl->x, pl->y, SOUND_OB_EVAPORATE); 2808 play_sound_map (pl->map, pl->x, pl->y, SOUND_OB_EVAPORATE);
2775 new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff " 2809 new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff " "of smoke!");
2776 "of smoke!");
2777 new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion."); 2810 new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
2778 remove_ob (op); 2811 op->destroy ();
2779 free_object (op);
2780 return 1; 2812 return 1;
2781 } 2813 }
2782 2814
2783 pl->contr->last_used = op; 2815 pl->contr->last_used = op;
2784 pl->contr->last_used_id = op->count; 2816 pl->contr->last_used_id = op->count;
2785 2817
2786 tmp = manual_apply (pl, op, aflag); 2818 tmp = manual_apply (pl, op, aflag);
2787 if ( ! quiet) { 2819 if (!quiet)
2820 {
2788 if (tmp == 0) 2821 if (tmp == 0)
2789 new_draw_info_format (NDI_UNIQUE, 0, pl, 2822 new_draw_info_format (NDI_UNIQUE, 0, pl, "I don't know how to apply the %s.", query_name (op));
2790 "I don't know how to apply the %s.",
2791 query_name (op));
2792 else if (tmp == 2) 2823 else if (tmp == 2)
2793 new_draw_info_format (NDI_UNIQUE, 0, pl, 2824 new_draw_info_format (NDI_UNIQUE, 0, pl, "You must get it first!\n");
2794 "You must get it first!\n");
2795 } 2825 }
2796 return tmp; 2826 return tmp;
2797} 2827}
2798 2828
2799/** 2829/**
2800 * player_apply_below attempts to apply the object 'below' the player. 2830 * player_apply_below attempts to apply the object 'below' the player.
2801 * If the player has an open container, we use that for below, otherwise 2831 * If the player has an open container, we use that for below, otherwise
2802 * we use the ground. 2832 * we use the ground.
2803 */ 2833 */
2804 2834
2835void
2805void player_apply_below (object *pl) 2836player_apply_below (object *pl)
2806{ 2837{
2807 object *tmp, *next; 2838 object *tmp, *next;
2808 int floors; 2839 int floors;
2809 2840
2810 if (pl->contr->transport && pl->contr->transport->type == TRANSPORT) {
2811 apply_transport(pl, pl->contr->transport, 0);
2812 return;
2813 }
2814
2815 /* If using a container, set the starting item to be the top 2841 /* If using a container, set the starting item to be the top
2816 * item in the container. Otherwise, use the map. 2842 * item in the container. Otherwise, use the map.
2817 */ 2843 */
2818 tmp = (pl->container != NULL) ? pl->container->inv : pl->below; 2844 tmp = (pl->container != NULL) ? pl->container->inv : pl->below;
2819 2845
2820 /* This is perhaps more complicated. However, I want to make sure that 2846 /* This is perhaps more complicated. However, I want to make sure that
2821 * we don't use a corrupt pointer for the next object, so we get the 2847 * we don't use a corrupt pointer for the next object, so we get the
2822 * next object in the stack before applying. This is can only be a 2848 * next object in the stack before applying. This is can only be a
2823 * problem if player_apply() has a bug in that it uses the object but does 2849 * problem if player_apply() has a bug in that it uses the object but does
2824 * not return a proper value. 2850 * not return a proper value.
2825 */ 2851 */
2826 for (floors = 0; tmp!=NULL; tmp=next) { 2852 for (floors = 0; tmp != NULL; tmp = next)
2853 {
2827 next = tmp->below; 2854 next = tmp->below;
2828 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 2855 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2829 floors++; 2856 floors++;
2830 else if (floors > 0) 2857 else if (floors > 0)
2831 return; /* process only floor objects after first floor object */ 2858 return; /* process only floor objects after first floor object */
2832 2859
2833 /* If it is visible, player can apply it. If it is applied by 2860 /* If it is visible, player can apply it. If it is applied by
2834 * person moving on it, also activate. Added code to make it 2861 * person moving on it, also activate. Added code to make it
2835 * so that at least one of players movement types be that which 2862 * so that at least one of players movement types be that which
2836 * the item needs. 2863 * the item needs.
2837 */ 2864 */
2838 if ( ! tmp->invisible || (tmp->move_on & pl->move_type)) { 2865 if (!tmp->invisible || (tmp->move_on & pl->move_type))
2866 {
2839 if (player_apply (pl, tmp, 0, 1) == 1) 2867 if (player_apply (pl, tmp, 0, 1) == 1)
2840 return; 2868 return;
2841 } 2869 }
2842 if (floors >= 2) 2870 if (floors >= 2)
2843 return; /* process at most two floor objects */ 2871 return; /* process at most two floor objects */
2844 } 2872 }
2845} 2873}
2846 2874
2847/** 2875/**
2848 * Unapplies specified item. 2876 * Unapplies specified item.
2849 * No check done on cursed/damned. 2877 * No check done on cursed/damned.
2850 * Break this out of apply_special - this is just done 2878 * Break this out of apply_special - this is just done
2851 * to keep the size of apply_special to a more managable size. 2879 * to keep the size of apply_special to a more managable size.
2852 */ 2880 */
2881static int
2853static int unapply_special (object *who, object *op, int aflags) 2882unapply_special (object *who, object *op, int aflags)
2854{ 2883{
2884 if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags)) || INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2885 return RESULT_INT (0);
2886
2855 object *tmp2; 2887 object *tmp2;
2856 2888
2857 CLEAR_FLAG(op, FLAG_APPLIED); 2889 CLEAR_FLAG (op, FLAG_APPLIED);
2858 switch(op->type) { 2890 switch (op->type)
2891 {
2859 case WEAPON: 2892 case WEAPON:
2860 new_draw_info_format(NDI_UNIQUE, 0, who, "You unwield %s.",query_name(op)); 2893 new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));
2861 2894
2862 (void) change_abil (who,op);
2863 if(QUERY_FLAG(who,FLAG_READY_WEAPON))
2864 CLEAR_FLAG(who,FLAG_READY_WEAPON);
2865 /* GROS: update the current_weapon_script field (used with script_attack for weapons) */
2866 who->current_weapon_script = NULL;
2867 who->current_weapon = NULL;
2868 clear_skill(who);
2869 break;
2870
2871 case SKILL: /* allows objects to impart skills */
2872 case SKILL_TOOL:
2873 if (op != who->chosen_skill) {
2874 LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
2875 }
2876 if (who->type==PLAYER) {
2877 if (who->contr->shoottype == range_skill)
2878 who->contr->shoottype = range_none;
2879 if ( ! op->invisible) {
2880 new_draw_info_format (NDI_UNIQUE, 0, who,
2881 "You stop using the %s.", query_name(op));
2882 } else {
2883 new_draw_info_format (NDI_UNIQUE, 0, who,
2884 "You can no longer use the skill: %s.",
2885 op->skill);
2886 }
2887 }
2888 (void) change_abil (who, op); 2895 (void) change_abil (who, op);
2896 if (QUERY_FLAG (who, FLAG_READY_WEAPON))
2897 CLEAR_FLAG (who, FLAG_READY_WEAPON);
2898 clear_skill (who);
2899 break;
2900
2901 case SKILL: /* allows objects to impart skills */
2902 case SKILL_TOOL:
2903 if (op != who->chosen_skill)
2904 {
2905 LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
2906 }
2907 if (who->type == PLAYER)
2908 {
2909 if (who->contr->shoottype == range_skill)
2910 who->contr->shoottype = range_none;
2911 if (!op->invisible)
2912 {
2913 new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));
2914 }
2915 else
2916 {
2917 new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);
2918 }
2919 }
2920 (void) change_abil (who, op);
2889 who->chosen_skill = NULL; 2921 who->chosen_skill = NULL;
2890 CLEAR_FLAG (who, FLAG_READY_SKILL); 2922 CLEAR_FLAG (who, FLAG_READY_SKILL);
2891 break; 2923 break;
2892 2924
2893 case ARMOUR: 2925 case ARMOUR:
2894 case HELMET: 2926 case HELMET:
2895 case SHIELD: 2927 case SHIELD:
2896 case RING: 2928 case RING:
2897 case BOOTS: 2929 case BOOTS:
2898 case GLOVES: 2930 case GLOVES:
2899 case AMULET: 2931 case AMULET:
2900 case GIRDLE: 2932 case GIRDLE:
2901 case BRACERS: 2933 case BRACERS:
2902 case CLOAK: 2934 case CLOAK:
2903 new_draw_info_format(NDI_UNIQUE, 0, who, "You unwear %s.",query_name(op)); 2935 new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));
2904 (void) change_abil (who,op); 2936 (void) change_abil (who, op);
2905 break; 2937 break;
2906 case LAMP: 2938 case LAMP:
2907 new_draw_info_format(NDI_UNIQUE, 0, who, "You turn off your %s.", 2939 new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);
2908 op->name);
2909 tmp2 = arch_to_object(op->other_arch); 2940 tmp2 = arch_to_object (op->other_arch);
2910 tmp2->x = op->x; 2941 tmp2->x = op->x;
2911 tmp2->y = op->y; 2942 tmp2->y = op->y;
2912 tmp2->map = op->map; 2943 tmp2->map = op->map;
2913 tmp2->below = op->below; 2944 tmp2->below = op->below;
2914 tmp2->above = op->above; 2945 tmp2->above = op->above;
2915 tmp2->stats.food = op->stats.food; 2946 tmp2->stats.food = op->stats.food;
2916 CLEAR_FLAG(tmp2, FLAG_APPLIED); 2947 CLEAR_FLAG (tmp2, FLAG_APPLIED);
2948
2917 if (QUERY_FLAG(op, FLAG_INV_LOCKED)) 2949 if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2918 SET_FLAG(tmp2, FLAG_INV_LOCKED); 2950 SET_FLAG (tmp2, FLAG_INV_LOCKED);
2951
2919 if (who->type == PLAYER) 2952 if (who->type == PLAYER)
2920 esrv_del_item(who->contr, (tag_t)op->count); 2953 esrv_del_item (who->contr, op->count);
2921 remove_ob(op); 2954
2922 free_object(op); 2955 op->destroy ();
2923 insert_ob_in_ob(tmp2, who); 2956 insert_ob_in_ob (tmp2, who);
2924 fix_player(who); 2957 fix_player (who);
2925 if (QUERY_FLAG(op, FLAG_CURSED) || QUERY_FLAG(op, FLAG_DAMNED)) { 2958 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2959 {
2926 if (who->type == PLAYER) { 2960 if (who->type == PLAYER)
2961 {
2927 new_draw_info(NDI_UNIQUE, 0,who, "Oops, it feels deadly cold!"); 2962 new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
2928 SET_FLAG(tmp2, FLAG_KNOWN_CURSED); 2963 SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2929 } 2964 }
2930 } 2965 }
2931 if(who->type==PLAYER) 2966 if (who->type == PLAYER)
2932 esrv_send_item(who, tmp2); 2967 esrv_send_item (who, tmp2);
2933 return 1; /* otherwise, an attempt to drop causes problems */ 2968 return 1; /* otherwise, an attempt to drop causes problems */
2934 break; 2969 break;
2935 case BOW: 2970 case BOW:
2936 case WAND: 2971 case WAND:
2937 case ROD: 2972 case ROD:
2938 case HORN: 2973 case HORN:
2939 clear_skill(who); 2974 clear_skill (who);
2940 new_draw_info_format(NDI_UNIQUE, 0, who, "You unready %s.",query_name(op)); 2975 new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2941 if(who->type==PLAYER) { 2976 if (who->type == PLAYER)
2977 {
2942 who->contr->shoottype = range_none; 2978 who->contr->shoottype = range_none;
2943 } else { 2979 }
2944 if (op->type == BOW) 2980 else
2981 {
2982 if (op->type == BOW)
2945 CLEAR_FLAG (who, FLAG_READY_BOW); 2983 CLEAR_FLAG (who, FLAG_READY_BOW);
2946 else 2984 else
2947 CLEAR_FLAG(who, FLAG_READY_RANGE); 2985 CLEAR_FLAG (who, FLAG_READY_RANGE);
2948 } 2986 }
2949 break; 2987 break;
2950 2988
2951 case BUILDER: 2989 case BUILDER:
2952 new_draw_info_format(NDI_UNIQUE, 0, who, "You unready %s.",query_name(op)); 2990 new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2953 who->contr->shoottype = range_none; 2991 who->contr->shoottype = range_none;
2954 who->contr->ranges[ range_builder ] = NULL; 2992 who->contr->ranges[range_builder] = NULL;
2955 break; 2993 break;
2956 2994
2957 default: 2995 default:
2958 new_draw_info_format(NDI_UNIQUE, 0, who, "You unapply %s.",query_name(op)); 2996 new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));
2959 break; 2997 break;
2960 } 2998 }
2961 2999
2962 fix_player(who); 3000 fix_player (who);
2963 3001
2964 if ( ! (aflags & AP_NO_MERGE)) { 3002 if (!(aflags & AP_NO_MERGE))
3003 {
2965 object *tmp; 3004 object *tmp;
2966 3005
2967 tag_t del_tag = op->count;
2968 tmp = merge_ob (op, NULL); 3006 tmp = merge_ob (op, NULL);
2969 if (who->type == PLAYER) { 3007 if (who->type == PLAYER)
2970 if (tmp) { /* it was merged */ 3008 {
3009 if (tmp)
3010 { /* it was merged */
2971 esrv_del_item (who->contr, del_tag); 3011 esrv_del_item (who->contr, op->count);
2972 op = tmp; 3012 op = tmp;
2973 } 3013 }
3014
2974 esrv_send_item (who, op); 3015 esrv_send_item (who, op);
2975 } 3016 }
2976 } 3017 }
2977 return 0; 3018 return 0;
2978} 3019}
2979 3020
2980/** 3021/**
2981 * Returns the object that is using location 'loc'. 3022 * Returns the object that is using location 'loc'.
2982 * Note that 'start' is the first object to start examing - we 3023 * Note that 'start' is the first object to start examing - we
… …
2989 * loc is the index into the array we are looking for a match. 3030 * loc is the index into the array we are looking for a match.
2990 * don't return invisible objects unless they are skill objects 3031 * don't return invisible objects unless they are skill objects
2991 * invisible other objects that use 3032 * invisible other objects that use
2992 * up body locations can be used as restrictions. 3033 * up body locations can be used as restrictions.
2993 */ 3034 */
3035object *
2994object *get_item_from_body_location(object *start, int loc) 3036get_item_from_body_location (object *start, int loc)
2995{ 3037{
2996 object *tmp; 3038 object *tmp;
2997 3039
2998 if (!start) return NULL; 3040 if (!start)
2999
3000 for (tmp=start; tmp; tmp=tmp->below)
3001 if (QUERY_FLAG(tmp, FLAG_APPLIED) && tmp->body_info[loc] &&
3002 (!tmp->invisible || tmp->type==SKILL)) return tmp;
3003
3004 return NULL; 3041 return NULL;
3042
3043 for (tmp = start; tmp; tmp = tmp->below)
3044 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->body_info[loc] && (!tmp->invisible || tmp->type == SKILL))
3045 return tmp;
3046
3047 return NULL;
3005} 3048}
3006 3049
3007 3050
3008 3051
3009/** 3052/**
… …
3015 * Returns 0 on success, returns 1 if there is some problem. 3058 * Returns 0 on success, returns 1 if there is some problem.
3016 * if aflags is AP_PRINT, we instead print out waht to unapply 3059 * if aflags is AP_PRINT, we instead print out waht to unapply
3017 * instead of doing it. This is a lot less code than having 3060 * instead of doing it. This is a lot less code than having
3018 * another function that does just that. 3061 * another function that does just that.
3019 */ 3062 */
3063int
3020int unapply_for_ob(object *who, object *op, int aflags) 3064unapply_for_ob (object *who, object *op, int aflags)
3021{ 3065{
3022 int i; 3066 int i;
3023 object *tmp=NULL, *last; 3067 object *tmp = NULL, *last;
3024 3068
3025 /* If we are applying a shield or weapon, unapply any equipped shield 3069 /* If we are applying a shield or weapon, unapply any equipped shield
3026 * or weapons first - only allowed to use one weapon/shield at a time. 3070 * or weapons first - only allowed to use one weapon/shield at a time.
3027 */ 3071 */
3028 if (op->type == WEAPON || op->type == SHIELD) { 3072 if (op->type == WEAPON || op->type == SHIELD)
3073 {
3029 for (tmp=who->inv; tmp; tmp=tmp->below) { 3074 for (tmp = who->inv; tmp; tmp = tmp->below)
3075 {
3030 if (QUERY_FLAG(tmp, FLAG_APPLIED) && tmp->type == op->type) { 3076 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)
3031 if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || 3077 {
3032 (!QUERY_FLAG(tmp, FLAG_CURSED) && !QUERY_FLAG(tmp, FLAG_DAMNED))) { 3078 if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))
3079 {
3033 if (aflags & AP_PRINT) 3080 if (aflags & AP_PRINT)
3034 new_draw_info(NDI_UNIQUE, 0, who, query_name(tmp)); 3081 new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
3035 else 3082 else
3036 unapply_special(who, tmp, aflags); 3083 unapply_special (who, tmp, aflags);
3037 } 3084 }
3038 else { 3085 else
3086 {
3039 /* In this case, we want to try and remove a cursed item. 3087 /* In this case, we want to try and remove a cursed item.
3040 * While we know it won't work, we want unapply_special to 3088 * While we know it won't work, we want unapply_special to
3041 * at least generate the message. 3089 * at least generate the message.
3042 */ 3090 */
3043 new_draw_info_format(NDI_UNIQUE, 0, who, 3091 new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (tmp));
3044 "No matter how hard you try, you just can't\nremove %s.", 3092 return 1;
3045 query_name(tmp)); 3093 }
3046 return 1;
3047 }
3048 3094
3095 }
3096 }
3049 } 3097 }
3050 }
3051 }
3052 3098
3053 for (i=0; i<NUM_BODY_LOCATIONS; i++) { 3099 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
3100 {
3054 /* this used up a slot that we need to free */ 3101 /* this used up a slot that we need to free */
3055 if (op->body_info[i]) { 3102 if (op->body_info[i])
3103 {
3056 last = who->inv; 3104 last = who->inv;
3057 3105
3058 /* We do a while loop - may need to remove several items in order 3106 /* We do a while loop - may need to remove several items in order
3059 * to free up enough slots. 3107 * to free up enough slots.
3060 */ 3108 */
3061 while ((who->body_used[i] + op->body_info[i]) < 0) { 3109 while ((who->body_used[i] + op->body_info[i]) < 0)
3110 {
3062 tmp = get_item_from_body_location(last, i); 3111 tmp = get_item_from_body_location (last, i);
3063 if (!tmp) { 3112 if (!tmp)
3113 {
3064#if 0 3114#if 0
3065 /* Not a bug - we'll get this if the player has cursed items 3115 /* Not a bug - we'll get this if the player has cursed items
3066 * equipped. 3116 * equipped.
3067 */ 3117 */
3068 LOG(llevError,"Can't find object using location %d (%s) on %s\n", 3118 LOG (llevError, "Can't find object using location %d (%s) on %s\n", i, body_locations[i].save_name, who->name);
3069 i, body_locations[i].save_name, who->name);
3070#endif 3119#endif
3071 return 1; 3120 return 1;
3072 } 3121 }
3073 /* If we are just printing, we don't care about cursed status */ 3122 /* If we are just printing, we don't care about cursed status */
3074 if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || 3123 if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))
3075 (!(QUERY_FLAG(tmp, FLAG_CURSED) || QUERY_FLAG(tmp, FLAG_DAMNED)))) { 3124 {
3076 if (aflags & AP_PRINT) 3125 if (aflags & AP_PRINT)
3077 new_draw_info(NDI_UNIQUE, 0, who, query_name(tmp)); 3126 new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
3078 else 3127 else
3079 unapply_special(who, tmp, aflags); 3128 unapply_special (who, tmp, aflags);
3080 } 3129 }
3081 else { 3130 else
3131 {
3082 /* Cursed item that we can't unequip - tell the player. 3132 /* Cursed item that we can't unequip - tell the player.
3083 * Note this could be annoying if this is just one of a few, 3133 * Note this could be annoying if this is just one of a few,
3084 * so it may not be critical (eg, putting on a ring and you have 3134 * so it may not be critical (eg, putting on a ring and you have
3085 * one cursed ring.) 3135 * one cursed ring.)
3086 */ 3136 */
3087 new_draw_info_format(NDI_UNIQUE, 0, who, "The %s just won't come off", query_name(tmp)); 3137 new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));
3088 } 3138 }
3089 last = tmp->below; 3139 last = tmp->below;
3090 } 3140 }
3091 /* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the 3141 /* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the
3092 * return in the !tmp would have kicked in. 3142 * return in the !tmp would have kicked in.
3093 */ 3143 */
3094 } /* if op is using this body location */ 3144 } /* if op is using this body location */
3095 } /* for body lcoations */ 3145 } /* for body lcoations */
3096 return 0; 3146 return 0;
3097} 3147}
3098 3148
3099/** 3149/**
3100 * Checks to see if 'who' can apply object 'op'. 3150 * Checks to see if 'who' can apply object 'op'.
3101 * Returns 0 if apply can be done without anything special. 3151 * Returns 0 if apply can be done without anything special.
… …
3105 * is set, do we really are what the other flags may be?) 3155 * is set, do we really are what the other flags may be?)
3106 * 3156 *
3107 * See include/define.h for detailed description of the meaning of 3157 * See include/define.h for detailed description of the meaning of
3108 * these return values. 3158 * these return values.
3109 */ 3159 */
3160int
3110int can_apply_object(object *who, object *op) 3161can_apply_object (object *who, object *op)
3111{ 3162{
3163 if (INVOKE_OBJECT (CAN_BE_APPLIED, op, ARG_OBJECT (who)) || INVOKE_OBJECT (CAN_APPLY, who, ARG_OBJECT (op)))
3164 return RESULT_INT (0);
3165
3112 int i, retval=0; 3166 int i, retval = 0;
3113 object *tmp=NULL, *ws=NULL; 3167 object *tmp = NULL, *ws = NULL;
3114 3168
3115 /* Players have 2 'arm's, so they could in theory equip 2 shields or 3169 /* Players have 2 'arm's, so they could in theory equip 2 shields or
3116 * 2 weapons, but we don't want to let them do that. So if they are 3170 * 2 weapons, but we don't want to let them do that. So if they are
3117 * trying to equip a weapon or shield, see if they already have one 3171 * trying to equip a weapon or shield, see if they already have one
3118 * in place and store that way. 3172 * in place and store that way.
3119 */ 3173 */
3120 if (op->type == WEAPON || op->type == SHIELD) { 3174 if (op->type == WEAPON || op->type == SHIELD)
3175 {
3121 for (tmp=who->inv; tmp && !ws; tmp=tmp->below) { 3176 for (tmp = who->inv; tmp && !ws; tmp = tmp->below)
3177 {
3122 if (QUERY_FLAG(tmp, FLAG_APPLIED) && tmp->type == op->type) { 3178 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)
3179 {
3123 retval = CAN_APPLY_UNAPPLY; 3180 retval = CAN_APPLY_UNAPPLY;
3124 ws = tmp; 3181 ws = tmp;
3182 }
3183 }
3125 } 3184 }
3126 }
3127 }
3128
3129 3185
3186
3130 for (i=0; i<NUM_BODY_LOCATIONS; i++) { 3187 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
3188 {
3131 if (op->body_info[i]) { 3189 if (op->body_info[i])
3190 {
3132 /* Item uses more slots than we have */ 3191 /* Item uses more slots than we have */
3133 if (FABS(op->body_info[i]) > who->body_info[i]) { 3192 if (FABS (op->body_info[i]) > who->body_info[i])
3193 {
3134 /* Could return now for efficiently - rest of info below isn' 3194 /* Could return now for efficiently - rest of info below isn'
3135 * really needed. 3195 * really needed.
3136 */ 3196 */
3137 retval |= CAN_APPLY_NEVER; 3197 retval |= CAN_APPLY_NEVER;
3198 }
3138 } else if ((who->body_used[i] + op->body_info[i]) < 0) { 3199 else if ((who->body_used[i] + op->body_info[i]) < 0)
3200 {
3139 /* in this case, equipping this would use more free spots than 3201 /* in this case, equipping this would use more free spots than
3140 * we have. 3202 * we have.
3141 */ 3203 */
3142 object *tmp1; 3204 object *tmp1;
3143 3205
3144 3206
3145 /* if we have an applied weapon/shield, and unapply it would free 3207 /* if we have an applied weapon/shield, and unapply it would free
3146 * enough slots to equip the new item, then just set this can 3208 * enough slots to equip the new item, then just set this can
3147 * continue. We don't care about the logic below - if you have 3209 * continue. We don't care about the logic below - if you have
3148 * shield equipped and try to equip another shield, there is only 3210 * shield equipped and try to equip another shield, there is only
3149 * one choice. However, the check for the number of body locations 3211 * one choice. However, the check for the number of body locations
3150 * does take into the account cases where what is being applied 3212 * does take into the account cases where what is being applied
3151 * may be two handed for example. 3213 * may be two handed for example.
3152 */ 3214 */
3153 if (ws) { 3215 if (ws)
3216 {
3154 if ((who->body_used[i] - ws->body_info[i] + op->body_info[i]) >=0) { 3217 if ((who->body_used[i] - ws->body_info[i] + op->body_info[i]) >= 0)
3155 retval |= CAN_APPLY_UNAPPLY; 3218 {
3156 continue; 3219 retval |= CAN_APPLY_UNAPPLY;
3157 } 3220 continue;
3158 } 3221 }
3222 }
3159 3223
3160 tmp1 = get_item_from_body_location(who->inv, i); 3224 tmp1 = get_item_from_body_location (who->inv, i);
3161 if (!tmp1) { 3225 if (!tmp1)
3226 {
3162#if 0 3227#if 0
3163 /* This is sort of an error, but happens a lot when old players 3228 /* This is sort of an error, but happens a lot when old players
3164 * join in with more stuff equipped than they are now allowed. 3229 * join in with more stuff equipped than they are now allowed.
3165 */ 3230 */
3166 LOG(llevError,"Can't find object using location %d on %s\n", 3231 LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
3167 i, who->name);
3168#endif 3232#endif
3169 retval |= CAN_APPLY_NEVER; 3233 retval |= CAN_APPLY_NEVER;
3170 } else { 3234 }
3235 else
3236 {
3171 /* need to unapply something. However, if this something 3237 /* need to unapply something. However, if this something
3172 * is different than we had found before, it means they need 3238 * is different than we had found before, it means they need
3173 * to apply multiple objects 3239 * to apply multiple objects
3174 */ 3240 */
3175 retval |= CAN_APPLY_UNAPPLY; 3241 retval |= CAN_APPLY_UNAPPLY;
3176 if (!tmp) tmp = tmp1; 3242 if (!tmp)
3177 else if (tmp != tmp1) { 3243 tmp = tmp1;
3178 retval |= CAN_APPLY_UNAPPLY_MULT; 3244 else if (tmp != tmp1)
3179 } 3245 {
3246 retval |= CAN_APPLY_UNAPPLY_MULT;
3247 }
3180 /* This object isn't using up all the slots, so there must 3248 /* This object isn't using up all the slots, so there must
3181 * be another. If so, and it the new item doesn't need all 3249 * be another. If so, and it the new item doesn't need all
3182 * the slots, the player then has a choice. 3250 * the slots, the player then has a choice.
3183 */ 3251 */
3184 if (((who->body_used[i] - tmp1->body_info[i]) != who->body_info[i]) && 3252 if (((who->body_used[i] - tmp1->body_info[i]) != who->body_info[i]) && (FABS (op->body_info[i]) < who->body_info[i]))
3185 (FABS(op->body_info[i]) < who->body_info[i]))
3186 retval |= CAN_APPLY_UNAPPLY_CHOICE; 3253 retval |= CAN_APPLY_UNAPPLY_CHOICE;
3187 3254
3188 /* Does unequippint 'tmp1' free up enough slots for this to be 3255 /* Does unequippint 'tmp1' free up enough slots for this to be
3189 * equipped? If not, there must be something else to unapply. 3256 * equipped? If not, there must be something else to unapply.
3190 */ 3257 */
3191 if ((who->body_used[i] + op->body_info[i] - tmp1->body_info[i]) < 0) 3258 if ((who->body_used[i] + op->body_info[i] - tmp1->body_info[i]) < 0)
3192 retval |= CAN_APPLY_UNAPPLY_MULT; 3259 retval |= CAN_APPLY_UNAPPLY_MULT;
3193 3260
3194 } 3261 }
3195 } /* if not enough free slots */ 3262 } /* if not enough free slots */
3196 } /* if this object uses location i */ 3263 } /* if this object uses location i */
3197 } /* for i -> num_body_locations loop */ 3264 } /* for i -> num_body_locations loop */
3198 3265
3199 /* Note that we don't check for FLAG_USE_ARMOUR - that should 3266 /* Note that we don't check for FLAG_USE_ARMOUR - that should
3200 * really be controlled by use of body locations. We do have 3267 * really be controlled by use of body locations. We do have
3201 * the weapon/shield checks, and the range checks for monsters, 3268 * the weapon/shield checks, and the range checks for monsters,
3202 * because you can't control those just by body location - bows, shields, 3269 * because you can't control those just by body location - bows, shields,
3203 * and weapons all use the same slot. Similar for horn/rod/wand - they 3270 * and weapons all use the same slot. Similar for horn/rod/wand - they
3204 * all use the same location. 3271 * all use the same location.
3205 */ 3272 */
3206 if (op->type == WEAPON && !QUERY_FLAG(who,FLAG_USE_WEAPON)) 3273 if (op->type == WEAPON && !QUERY_FLAG (who, FLAG_USE_WEAPON))
3207 retval |= CAN_APPLY_RESTRICTION;
3208 if (op->type == SHIELD && !QUERY_FLAG(who,FLAG_USE_SHIELD))
3209 retval |= CAN_APPLY_RESTRICTION;
3210
3211
3212 if (who->type != PLAYER) {
3213 if ((op->type == WAND || op->type == HORN || op->type==ROD)
3214 && !QUERY_FLAG(who, FLAG_USE_RANGE))
3215 retval |= CAN_APPLY_RESTRICTION;
3216 if (op->type == BOW && !QUERY_FLAG(who, FLAG_USE_BOW))
3217 retval |= CAN_APPLY_RESTRICTION; 3274 retval |= CAN_APPLY_RESTRICTION;
3218 if (op->type == RING && !QUERY_FLAG(who, FLAG_USE_RING)) 3275 if (op->type == SHIELD && !QUERY_FLAG (who, FLAG_USE_SHIELD))
3219 retval |= CAN_APPLY_RESTRICTION; 3276 retval |= CAN_APPLY_RESTRICTION;
3220 if (op->type == BOW && !QUERY_FLAG(who, FLAG_USE_BOW)) 3277
3278
3279 if (who->type != PLAYER)
3280 {
3281 if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))
3221 retval |= CAN_APPLY_RESTRICTION; 3282 retval |= CAN_APPLY_RESTRICTION;
3283 if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3284 retval |= CAN_APPLY_RESTRICTION;
3285 if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))
3286 retval |= CAN_APPLY_RESTRICTION;
3287 if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3288 retval |= CAN_APPLY_RESTRICTION;
3222 } 3289 }
3223 return retval; 3290 return retval;
3224} 3291}
3225 3292
3226 3293
3227 3294
3228/** 3295/**
3229 * who is the object using the object. It can be a monster. 3296 * who is the object using the object. It can be a monster.
3230 * op is the object they are using. op is an equipment type item, 3297 * op is the object they are using. op is an equipment type item,
3231 * eg, one which you put on and keep on for a while, and not something 3298 * eg, one which you put on and keep on for a while, and not something
… …
3245 * 3312 *
3246 * Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE) 3313 * Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE)
3247 * 3314 *
3248 * apply_special() doesn't check for unpaid items. 3315 * apply_special() doesn't check for unpaid items.
3249 */ 3316 */
3317int
3250int apply_special (object *who, object *op, int aflags) 3318apply_special (object *who, object *op, int aflags)
3251{ 3319{
3252 int basic_flag = aflags & AP_BASIC_FLAGS; 3320 int basic_flag = aflags & AP_BASIC_FLAGS;
3253 object *tmp, *tmp2, *skop=NULL; 3321 object *tmp, *tmp2, *skop = NULL;
3254 int i; 3322 int i;
3255 3323
3256 if(who==NULL) { 3324 if (who == NULL)
3325 {
3257 LOG(llevError,"apply_special() from object without environment.\n"); 3326 LOG (llevError, "apply_special() from object without environment.\n");
3258 return 1; 3327 return 1;
3259 } 3328 }
3260 3329
3261 if(op->env!=who) 3330 if (op->env != who)
3262 return 1; /* op is not in inventory */ 3331 return 1; /* op is not in inventory */
3263 3332
3264 /* trying to unequip op */ 3333 /* trying to unequip op */
3265 if (QUERY_FLAG(op,FLAG_APPLIED)) { 3334 if (QUERY_FLAG (op, FLAG_APPLIED))
3335 {
3266 /* always apply, so no reason to unapply */ 3336 /* always apply, so no reason to unapply */
3267 if (basic_flag == AP_APPLY) return 0; 3337 if (basic_flag == AP_APPLY)
3338 return 0;
3268 3339
3269 if ( ! (aflags & AP_IGNORE_CURSE) 3340 if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
3270 && (QUERY_FLAG(op, FLAG_CURSED) || QUERY_FLAG(op, FLAG_DAMNED))) { 3341 {
3271 new_draw_info_format(NDI_UNIQUE, 0, who, 3342 new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (op));
3272 "No matter how hard you try, you just can't\nremove %s.",
3273 query_name(op));
3274 return 1; 3343 return 1;
3275 } 3344 }
3276 return unapply_special(who, op, aflags); 3345 return unapply_special (who, op, aflags);
3277 } 3346 }
3278 3347
3279 if (basic_flag == AP_UNAPPLY) return 0; 3348 if (basic_flag == AP_UNAPPLY)
3349 return 0;
3280 3350
3281 i = can_apply_object(who, op); 3351 i = can_apply_object (who, op);
3282 3352
3283 /* Can't just apply this object. Lets see what not and what to do */ 3353 /* Can't just apply this object. Lets see what not and what to do */
3284 if (i) { 3354 if (i)
3355 {
3285 if (i & CAN_APPLY_NEVER) { 3356 if (i & CAN_APPLY_NEVER)
3357 {
3286 new_draw_info_format(NDI_UNIQUE, 0, who, "You don't have the body to use a %s\n", query_name(op)); 3358 new_draw_info_format (NDI_UNIQUE, 0, who, "You don't have the body to use a %s\n", query_name (op));
3287 return 1; 3359 return 1;
3360 }
3288 } else if (i & CAN_APPLY_RESTRICTION) { 3361 else if (i & CAN_APPLY_RESTRICTION)
3362 {
3289 new_draw_info_format(NDI_UNIQUE, 0, who, "You have a prohibition against using a %s\n", query_name(op)); 3363 new_draw_info_format (NDI_UNIQUE, 0, who, "You have a prohibition against using a %s\n", query_name (op));
3290 return 1; 3364 return 1;
3291 } 3365 }
3292 if (who->type != PLAYER) { 3366 if (who->type != PLAYER)
3367 {
3293 /* Some error, so don't try to equip something more */ 3368 /* Some error, so don't try to equip something more */
3294 if (unapply_for_ob(who, op, aflags)) return 1; 3369 if (unapply_for_ob (who, op, aflags))
3295 } else { 3370 return 1;
3296 if (who->contr->unapply == unapply_never || 3371 }
3297 (i & CAN_APPLY_UNAPPLY_CHOICE && who->contr->unapply == unapply_nochoice)) { 3372 else
3373 {
3374 if (who->contr->unapply == unapply_never || (i & CAN_APPLY_UNAPPLY_CHOICE && who->contr->unapply == unapply_nochoice))
3375 {
3298 new_draw_info(NDI_UNIQUE, 0, who, "You need to unapply some item(s):"); 3376 new_draw_info (NDI_UNIQUE, 0, who, "You need to unapply some item(s):");
3299 unapply_for_ob(who, op, AP_PRINT); 3377 unapply_for_ob (who, op, AP_PRINT);
3300 return 1; 3378 return 1;
3301 } 3379 }
3302 else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE)) { 3380 else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE))
3381 {
3303 i = unapply_for_ob(who, op, aflags); 3382 i = unapply_for_ob (who, op, aflags);
3304 if (i) return 1; 3383 if (i)
3384 return 1;
3385 }
3386 }
3305 } 3387 }
3306 }
3307 }
3308 if (op->skill && op->type != SKILL && op->type != SKILL_TOOL) { 3388 if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3389 {
3309 skop=find_skill_by_name(who, op->skill); 3390 skop = find_skill_by_name (who, op->skill);
3310 if (!skop) { 3391 if (!skop)
3392 {
3311 new_draw_info_format(NDI_UNIQUE, 0, who, "You need the %s skill to use this item!", op->skill); 3393 new_draw_info_format (NDI_UNIQUE, 0, who, "You need the %s skill to use this item!", &op->skill);
3312 return 1; 3394 return 1;
3313 } else { 3395 }
3396 else
3397 {
3314 /* While experience will be credited properly, we want to change the 3398 /* While experience will be credited properly, we want to change the
3315 * skill so that the dam and wc get updated 3399 * skill so that the dam and wc get updated
3316 */ 3400 */
3317 change_skill(who, skop, 0); 3401 change_skill (who, skop, 0);
3318 } 3402 }
3403 }
3404
3405 if (who->type == PLAYER && op->item_power && (op->item_power + who->contr->item_power) > (settings.item_power_factor * who->level))
3319 } 3406 {
3320
3321 if (who->type == PLAYER && op->item_power &&
3322 (op->item_power + who->contr->item_power) > (settings.item_power_factor * who->level)) {
3323 new_draw_info(NDI_UNIQUE, 0, who, "Equipping that combined with other items would consume your soul!"); 3407 new_draw_info (NDI_UNIQUE, 0, who, "Equipping that combined with other items would consume your soul!");
3324 return 1; 3408 return 1;
3325 } 3409 }
3326
3327 3410
3411
3328 /* Ok. We are now at the state where we can apply the new object. 3412 /* Ok. We are now at the state where we can apply the new object.
3329 * Note that we don't have the checks for can_use_... 3413 * Note that we don't have the checks for can_use_...
3330 * below - that is already taken care of by can_apply_object. 3414 * below - that is already taken care of by can_apply_object.
3331 */ 3415 */
3332
3333 3416
3417
3334 if(op->nrof > 1) 3418 if (op->nrof > 1)
3335 tmp = get_split_ob(op,op->nrof - 1); 3419 tmp = get_split_ob (op, op->nrof - 1);
3336 else 3420 else
3337 tmp = NULL; 3421 tmp = NULL;
3338 3422
3423 if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3424 return RESULT_INT (0);
3425
3339 switch(op->type) { 3426 switch (op->type)
3427 {
3340 case WEAPON: 3428 case WEAPON:
3341 if (!check_weapon_power(who, op->last_eat)) { 3429 if (!check_weapon_power (who, op->last_eat))
3342 new_draw_info(NDI_UNIQUE, 0,who, 3430 {
3343 "That weapon is too powerful for you to use."); 3431 new_draw_info (NDI_UNIQUE, 0, who, "That weapon is too powerful for you to use.");
3344 new_draw_info(NDI_UNIQUE, 0, who, "It would consume your soul!."); 3432 new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");
3345 if(tmp!=NULL) 3433 if (tmp != NULL)
3346 (void) insert_ob_in_ob(tmp,who); 3434 (void) insert_ob_in_ob (tmp, who);
3347 return 1; 3435 return 1;
3348 } 3436 }
3349 if( op->level && (strncmp(op->name,who->name,strlen(who->name)))) { 3437 if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3438 {
3350 /* if the weapon does not have the name as the character, can't use it. */ 3439 /* if the weapon does not have the name as the character, can't use it. */
3351 /* (Ragnarok's sword attempted to be used by Foo: won't work) */ 3440 /* (Ragnarok's sword attempted to be used by Foo: won't work) */
3352 new_draw_info(NDI_UNIQUE, 0,who,"The weapon does not recognize you as its owner."); 3441 new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");
3353 if(tmp!=NULL) 3442 if (tmp != NULL)
3354 (void) insert_ob_in_ob(tmp,who); 3443 (void) insert_ob_in_ob (tmp, who);
3355 return 1; 3444 return 1;
3356 } 3445 }
3357 SET_FLAG(op, FLAG_APPLIED); 3446 SET_FLAG (op, FLAG_APPLIED);
3358 3447
3359 if (skop) change_skill(who, skop, 1); 3448 if (skop)
3449 change_skill (who, skop, 1);
3360 if(!QUERY_FLAG(who,FLAG_READY_WEAPON)) 3450 if (!QUERY_FLAG (who, FLAG_READY_WEAPON))
3361 SET_FLAG(who, FLAG_READY_WEAPON); 3451 SET_FLAG (who, FLAG_READY_WEAPON);
3362 3452
3363 new_draw_info_format(NDI_UNIQUE, 0, who, "You wield %s.",query_name(op)); 3453 new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));
3364 3454
3365 (void) change_abil (who,op); 3455 (void) change_abil (who, op);
3366 break; 3456 break;
3367 3457
3368 case ARMOUR: 3458 case ARMOUR:
3369 case HELMET: 3459 case HELMET:
3370 case SHIELD: 3460 case SHIELD:
3371 case BOOTS: 3461 case BOOTS:
3372 case GLOVES: 3462 case GLOVES:
3373 case GIRDLE: 3463 case GIRDLE:
3374 case BRACERS: 3464 case BRACERS:
3375 case CLOAK: 3465 case CLOAK:
3376 case RING: 3466 case RING:
3377 case AMULET: 3467 case AMULET:
3378 SET_FLAG(op, FLAG_APPLIED); 3468 SET_FLAG (op, FLAG_APPLIED);
3379 new_draw_info_format(NDI_UNIQUE, 0, who, "You wear %s.",query_name(op)); 3469 new_draw_info_format (NDI_UNIQUE, 0, who, "You wear %s.", query_name (op));
3380 (void) change_abil (who,op); 3470 (void) change_abil (who, op);
3381 break; 3471 break;
3382 case LAMP: 3472 case LAMP:
3383 if (op->stats.food < 1) { 3473 if (op->stats.food < 1)
3474 {
3384 new_draw_info_format(NDI_UNIQUE, 0, who, "Your %s is out of" 3475 new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of" " fuel!", &op->name);
3385 " fuel!", op->name); 3476 return 1;
3386 return 1; 3477 }
3387 }
3388 new_draw_info_format(NDI_UNIQUE, 0, who, "You turn on your %s.", 3478 new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);
3389 op->name);
3390 tmp2 = arch_to_object(op->other_arch); 3479 tmp2 = arch_to_object (op->other_arch);
3391 tmp2->stats.food = op->stats.food; 3480 tmp2->stats.food = op->stats.food;
3392 SET_FLAG(tmp2, FLAG_APPLIED); 3481 SET_FLAG (tmp2, FLAG_APPLIED);
3393 if (QUERY_FLAG(op, FLAG_INV_LOCKED)) 3482 if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3394 SET_FLAG(tmp2, FLAG_INV_LOCKED); 3483 SET_FLAG (tmp2, FLAG_INV_LOCKED);
3395 insert_ob_in_ob(tmp2, who); 3484 insert_ob_in_ob (tmp2, who);
3396 3485
3397 /* Remove the old lantern */ 3486 /* Remove the old lantern */
3398 if (who->type == PLAYER) 3487 if (who->type == PLAYER)
3399 esrv_del_item(who->contr, (tag_t)op->count); 3488 esrv_del_item (who->contr, op->count);
3400 remove_ob(op);
3401 free_object(op);
3402 3489
3490 op->destroy ();
3491
3403 /* insert the portion that was split off */ 3492 /* insert the portion that was split off */
3404 if(tmp!=NULL) { 3493 if (tmp != NULL)
3494 {
3405 (void) insert_ob_in_ob(tmp,who); 3495 (void) insert_ob_in_ob (tmp, who);
3406 if(who->type==PLAYER) 3496 if (who->type == PLAYER)
3407 esrv_send_item(who, tmp); 3497 esrv_send_item (who, tmp);
3408 } 3498 }
3409 fix_player(who); 3499 fix_player (who);
3410 if (QUERY_FLAG(op, FLAG_CURSED) || QUERY_FLAG(op, FLAG_DAMNED)) { 3500 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3501 {
3411 if (who->type == PLAYER) { 3502 if (who->type == PLAYER)
3503 {
3412 new_draw_info(NDI_UNIQUE, 0,who, "Oops, it feels deadly cold!"); 3504 new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
3413 SET_FLAG(tmp2, FLAG_KNOWN_CURSED); 3505 SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3414 } 3506 }
3415 } 3507 }
3416 if(who->type==PLAYER) 3508 if (who->type == PLAYER)
3417 esrv_send_item(who, tmp2); 3509 esrv_send_item (who, tmp2);
3418 return 0; 3510 return 0;
3419 break; 3511 break;
3420 3512
3421 /* this part is needed for skill-tools */ 3513 /* this part is needed for skill-tools */
3422 case SKILL: 3514 case SKILL:
3423 case SKILL_TOOL: 3515 case SKILL_TOOL:
3424 if (who->chosen_skill) { 3516 if (who->chosen_skill)
3517 {
3425 LOG (llevError, "BUG: apply_special(): can't apply two skills\n"); 3518 LOG (llevError, "BUG: apply_special(): can't apply two skills\n");
3426 return 1; 3519 return 1;
3427 } 3520 }
3428 if (who->type == PLAYER) { 3521 if (who->type == PLAYER)
3522 {
3429 who->contr->shoottype = range_skill; 3523 who->contr->shoottype = range_skill;
3430 who->contr->ranges[range_skill] = op; 3524 who->contr->ranges[range_skill] = op;
3431 if ( ! op->invisible) { 3525 if (!op->invisible)
3526 {
3432 new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", 3527 new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3433 query_name (op)); 3528 new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);
3434 new_draw_info_format (NDI_UNIQUE, 0, who, 3529 }
3435 "You can now use the skill: %s.", 3530 else
3436 op->skill); 3531 {
3437 } else { 3532 new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);
3438 new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", 3533 }
3439 op->skill? op->skill:op->name); 3534 }
3440 }
3441 }
3442 SET_FLAG (op, FLAG_APPLIED); 3535 SET_FLAG (op, FLAG_APPLIED);
3443 (void) change_abil (who, op); 3536 (void) change_abil (who, op);
3444 who->chosen_skill = op; 3537 who->chosen_skill = op;
3445 SET_FLAG (who, FLAG_READY_SKILL); 3538 SET_FLAG (who, FLAG_READY_SKILL);
3446 break; 3539 break;
3447 3540
3448 case BOW: 3541 case BOW:
3449 if (!check_weapon_power(who, op->last_eat)) { 3542 if (!check_weapon_power (who, op->last_eat))
3450 new_draw_info(NDI_UNIQUE, 0, who, 3543 {
3451 "That item is too powerful for you to use."); 3544 new_draw_info (NDI_UNIQUE, 0, who, "That item is too powerful for you to use.");
3452 new_draw_info(NDI_UNIQUE, 0, who, "It would consume your soul!."); 3545 new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");
3453 if(tmp != NULL) 3546 if (tmp != NULL)
3454 (void)insert_ob_in_ob(tmp,who); 3547 (void) insert_ob_in_ob (tmp, who);
3455 return 1; 3548 return 1;
3456 } 3549 }
3457 if( op->level && (strncmp(op->name,who->name,strlen(who->name)))) { 3550 if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3458 new_draw_info(NDI_UNIQUE, 0, who, 3551 {
3459 "The weapon does not recognize you as its owner."); 3552 new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");
3460 if(tmp != NULL) 3553 if (tmp != NULL)
3461 (void)insert_ob_in_ob(tmp,who); 3554 (void) insert_ob_in_ob (tmp, who);
3462 return 1; 3555 return 1;
3463 } 3556 }
3464 /*FALLTHROUGH*/ 3557 /*FALLTHROUGH*/ case WAND:
3465 case WAND: 3558 case ROD:
3466 case ROD: 3559 case HORN:
3467 case HORN:
3468 /* check for skill, alter player status */ 3560 /* check for skill, alter player status */
3469 SET_FLAG(op, FLAG_APPLIED); 3561 SET_FLAG (op, FLAG_APPLIED);
3470 if (skop) change_skill(who, skop, 0); 3562 if (skop)
3563 change_skill (who, skop, 0);
3471 new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name(op)); 3564 new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3472 3565
3473 if(who->type==PLAYER) { 3566 if (who->type == PLAYER)
3474 if (op->type == BOW) { 3567 {
3568 if (op->type == BOW)
3569 {
3475 (void)change_abil(who, op); 3570 (void) change_abil (who, op);
3476 new_draw_info_format (NDI_UNIQUE, 0, who, 3571 new_draw_info_format (NDI_UNIQUE, 0, who,
3477 "You will now fire %s with %s.", 3572 "You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));
3478 op->race ? op->race : "nothing", query_name(op));
3479 who->contr->shoottype = range_bow; 3573 who->contr->shoottype = range_bow;
3480 } else { 3574 }
3575 else
3576 {
3481 who->contr->shoottype = range_misc; 3577 who->contr->shoottype = range_misc;
3482 } 3578 }
3483 } else { 3579 }
3484 if (op->type == BOW) 3580 else
3581 {
3582 if (op->type == BOW)
3485 SET_FLAG (who, FLAG_READY_BOW); 3583 SET_FLAG (who, FLAG_READY_BOW);
3486 else 3584 else
3487 SET_FLAG (who, FLAG_READY_RANGE); 3585 SET_FLAG (who, FLAG_READY_RANGE);
3488 } 3586 }
3489 break; 3587 break;
3490 3588
3491 case BUILDER: 3589 case BUILDER:
3492 if ( who->contr->ranges[ range_builder ] ) 3590 if (who->contr->ranges[range_builder])
3493 unapply_special( who, who->contr->ranges[ range_builder ], 0 ); 3591 unapply_special (who, who->contr->ranges[range_builder], 0);
3494 who->contr->shoottype = range_builder; 3592 who->contr->shoottype = range_builder;
3495 who->contr->ranges[ range_builder ] = op; 3593 who->contr->ranges[range_builder] = op;
3496 new_draw_info_format( NDI_UNIQUE, 0, who, "You ready your %s.", query_name( op ) ); 3594 new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));
3497 break; 3595 break;
3498 3596
3499 default: 3597 default:
3500 new_draw_info_format(NDI_UNIQUE, 0, who, "You apply %s.",query_name(op)); 3598 new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));
3501 } /* end of switch op->type */ 3599 } /* end of switch op->type */
3502 3600
3503 SET_FLAG(op, FLAG_APPLIED); 3601 SET_FLAG (op, FLAG_APPLIED);
3504 3602
3505 if(tmp!=NULL) 3603 if (tmp != NULL)
3506 tmp = insert_ob_in_ob(tmp,who); 3604 tmp = insert_ob_in_ob (tmp, who);
3507 3605
3508 fix_player(who); 3606 fix_player (who);
3509 3607
3510 /* We exclude spell casting objects. The fire code will set the 3608 /* We exclude spell casting objects. The fire code will set the
3511 * been applied flag when they are used - until that point, 3609 * been applied flag when they are used - until that point,
3512 * you don't know anything about them. 3610 * you don't know anything about them.
3513 */ 3611 */
3514 if (who->type == PLAYER && op->type!=WAND && op->type!=HORN && 3612 if (who->type == PLAYER && op->type != WAND && op->type != HORN && op->type != ROD)
3515 op->type!=ROD)
3516 SET_FLAG(op,FLAG_BEEN_APPLIED); 3613 SET_FLAG (op, FLAG_BEEN_APPLIED);
3517 3614
3518 if (QUERY_FLAG(op, FLAG_CURSED) || QUERY_FLAG(op, FLAG_DAMNED)) { 3615 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3616 {
3519 if (who->type == PLAYER) { 3617 if (who->type == PLAYER)
3618 {
3520 new_draw_info(NDI_UNIQUE, 0,who, "Oops, it feels deadly cold!"); 3619 new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
3521 SET_FLAG(op,FLAG_KNOWN_CURSED); 3620 SET_FLAG (op, FLAG_KNOWN_CURSED);
3522 } 3621 }
3523 } 3622 }
3524 if(who->type==PLAYER) { 3623 if (who->type == PLAYER)
3624 {
3525 /* if multiple objects were applied, update both slots */ 3625 /* if multiple objects were applied, update both slots */
3526 if (tmp) 3626 if (tmp)
3527 esrv_send_item(who, tmp); 3627 esrv_send_item (who, tmp);
3528 esrv_send_item(who, op); 3628 esrv_send_item (who, op);
3529 } 3629 }
3530 return 0; 3630 return 0;
3531} 3631}
3532 3632
3533 3633
3634int
3534int monster_apply_special (object *who, object *op, int aflags) 3635monster_apply_special (object *who, object *op, int aflags)
3535{ 3636{
3536 if (QUERY_FLAG (op, FLAG_UNPAID) && ! QUERY_FLAG (op, FLAG_APPLIED)) 3637 if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3537 return 1; 3638 return 1;
3538 return apply_special (who, op, aflags); 3639 return apply_special (who, op, aflags);
3539} 3640}
3540 3641
3541/** 3642/**
3542 * Map was just loaded, handle op's initialisation. 3643 * Map was just loaded, handle op's initialisation.
3543 * 3644 *
3544 * Generates shop floor's item, and treasures. 3645 * Generates shop floor's item, and treasures.
3545 */ 3646 */
3647int
3546int auto_apply (object *op) { 3648auto_apply (object *op)
3649{
3547 object *tmp = NULL, *tmp2; 3650 object *tmp = NULL, *tmp2;
3548 int i; 3651 int i;
3549 3652
3550 switch(op->type) { 3653 switch (op->type)
3654 {
3551 case SHOP_FLOOR: 3655 case SHOP_FLOOR:
3552 if (!HAS_RANDOM_ITEMS(op)) return 0; 3656 if (!HAS_RANDOM_ITEMS (op))
3553 do { 3657 return 0;
3554 i=10; /* let's give it 10 tries */ 3658
3659 do
3660 {
3661 i = 10; /* let's give it 10 tries */
3555 while((tmp=generate_treasure(op->randomitems, 3662 while ((tmp = generate_treasure (op->randomitems,
3556 op->stats.exp?(int)op->stats.exp:MAX(op->map->difficulty, 5)))==NULL&&--i); 3663 op->stats.exp ? (int) op->stats.exp : MAX (op->map->difficulty, 5))) == NULL && --i);
3557 if(tmp==NULL) 3664 if (tmp == NULL)
3558 return 0; 3665 return 0;
3559 if(QUERY_FLAG(tmp, FLAG_CURSED) || QUERY_FLAG(tmp, FLAG_DAMNED)) { 3666 if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
3560 free_object(tmp); 3667 {
3561 tmp = NULL; 3668 tmp->destroy ();
3562 } 3669 tmp = NULL;
3563 } while(!tmp); 3670 }
3671 }
3672 while (!tmp);
3673
3564 tmp->x=op->x; 3674 tmp->x = op->x;
3565 tmp->y=op->y; 3675 tmp->y = op->y;
3566 SET_FLAG(tmp,FLAG_UNPAID); 3676 SET_FLAG (tmp, FLAG_UNPAID);
3567 insert_ob_in_map(tmp,op->map,NULL,0); 3677 insert_ob_in_map (tmp, op->map, NULL, 0);
3568 CLEAR_FLAG(op,FLAG_AUTO_APPLY); 3678 CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3569 identify(tmp); 3679 identify (tmp);
3570 break; 3680 break;
3571 3681
3572 case TREASURE: 3682 case TREASURE:
3573 if (QUERY_FLAG(op,FLAG_IS_A_TEMPLATE)) 3683 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
3574 return 0; 3684 return 0;
3685
3575 while ((op->stats.hp--)>0) 3686 while ((op->stats.hp--) > 0)
3576 create_treasure(op->randomitems, op, op->map?GT_ENVIRONMENT:0, 3687 create_treasure (op->randomitems, op, op->map ? GT_ENVIRONMENT : 0,
3577 op->stats.exp ? (int)op->stats.exp : 3688 op->stats.exp ? (int) op->stats.exp : op->map == NULL ? 14 : op->map->difficulty, 0);
3578 op->map == NULL ? 14: op->map->difficulty,0);
3579 3689
3580 /* If we generated an object and put it in this object inventory, 3690 /* If we generated an object and put it in this object inventory,
3581 * move it to the parent object as the current object is about 3691 * move it to the parent object as the current object is about
3582 * to disappear. An example of this item is the random_* stuff 3692 * to disappear. An example of this item is the random_* stuff
3583 * that is put inside other objects. 3693 * that is put inside other objects.
3584 */ 3694 */
3585 for (tmp=op->inv; tmp; tmp=tmp2) { 3695 for (tmp = op->inv; tmp; tmp = tmp2)
3586 tmp2 = tmp->below; 3696 {
3587 remove_ob(tmp); 3697 tmp2 = tmp->below;
3588 if (op->env) insert_ob_in_ob(tmp, op->env); 3698 tmp->remove ();
3589 else free_object(tmp); 3699
3700 if (op->env)
3701 insert_ob_in_ob (tmp, op->env);
3702 else
3703 tmp->destroy ();
3704 }
3705
3706 op->destroy ();
3707 break;
3590 } 3708 }
3591 remove_ob(op);
3592 free_object(op);
3593 break;
3594 }
3595 return tmp ? 1 : 0; 3709 return tmp ? 1 : 0;
3596} 3710}
3597 3711
3598/** 3712/**
3599 * fix_auto_apply goes through the entire map (only the first time 3713 * fix_auto_apply goes through the entire map (only the first time
3600 * when an original map is loaded) and performs special actions for 3714 * when an original map is loaded) and performs special actions for
3601 * certain objects (most initialization of chests and creation of 3715 * certain objects (most initialization of chests and creation of
3602 * treasures and stuff). Calls auto_apply if appropriate. 3716 * treasures and stuff). Calls auto_apply if appropriate.
3603 */ 3717 */
3604 3718void
3605void fix_auto_apply(mapstruct *m) { 3719fix_auto_apply (maptile *m)
3720{
3606 object *tmp,*above=NULL; 3721 object *tmp, *above = NULL;
3607 int x,y; 3722 int x, y;
3608 3723
3609 if(m==NULL) return; 3724 if (m == NULL)
3725 return;
3610 3726
3611 for(x=0;x<MAP_WIDTH(m);x++) 3727 for (x = 0; x < MAP_WIDTH (m); x++)
3612 for(y=0;y<MAP_HEIGHT(m);y++) 3728 for (y = 0; y < MAP_HEIGHT (m); y++)
3613 for(tmp=get_map_ob(m,x,y);tmp!=NULL;tmp=above) { 3729 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above)
3614 above=tmp->above; 3730 {
3731 above = tmp->above;
3615 3732
3616 if (tmp->inv) { 3733 if (tmp->inv)
3734 {
3617 object *invtmp, *invnext; 3735 object *invtmp, *invnext;
3618 3736
3619 for (invtmp=tmp->inv; invtmp != NULL; invtmp = invnext) { 3737 for (invtmp = tmp->inv; invtmp != NULL; invtmp = invnext)
3620 invnext = invtmp->below; 3738 {
3739 invnext = invtmp->below;
3621 3740
3622 if(QUERY_FLAG(invtmp,FLAG_AUTO_APPLY)) 3741 if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
3623 auto_apply(invtmp); 3742 auto_apply (invtmp);
3624 else if(invtmp->type==TREASURE && HAS_RANDOM_ITEMS(invtmp)) { 3743 else if (invtmp->type == TREASURE && HAS_RANDOM_ITEMS (invtmp))
3625 while ((invtmp->stats.hp--)>0) 3744 {
3626 create_treasure(invtmp->randomitems, invtmp, 0, 3745 while ((invtmp->stats.hp--) > 0)
3627 m->difficulty,0); 3746 create_treasure (invtmp->randomitems, invtmp, 0, m->difficulty, 0);
3628 invtmp->randomitems = NULL; 3747
3629 } 3748 invtmp->randomitems = NULL;
3630 else if (invtmp && invtmp->arch && 3749 }
3631 invtmp->type!=TREASURE && 3750 else if (invtmp && invtmp->arch
3632 invtmp->type != SPELL && 3751 && invtmp->type != TREASURE && invtmp->type != SPELL && invtmp->type != CLASS && HAS_RANDOM_ITEMS (invtmp))
3633 invtmp->type != CLASS && 3752 {
3634 HAS_RANDOM_ITEMS(invtmp)) { 3753 create_treasure (invtmp->randomitems, invtmp, 0, m->difficulty, 0);
3635 create_treasure(invtmp->randomitems, invtmp, 0,
3636 m->difficulty,0);
3637 /* Need to clear this so that we never try to create 3754 /* Need to clear this so that we never try to create
3638 * treasure again for this object 3755 * treasure again for this object
3639 */ 3756 */
3640 invtmp->randomitems = NULL; 3757 invtmp->randomitems = NULL;
3641 } 3758 }
3642 } 3759 }
3643 /* This is really temporary - the code at the bottom will 3760 /* This is really temporary - the code at the bottom will
3644 * also set randomitems to null. The problem is there are bunches 3761 * also set randomitems to null. The problem is there are bunches
3645 * of maps/players already out there with items that have spells 3762 * of maps/players already out there with items that have spells
3646 * which haven't had the randomitems set to null yet. 3763 * which haven't had the randomitems set to null yet.
3647 * MSW 2004-05-13 3764 * MSW 2004-05-13
3648 * 3765 *
3649 * And if it's a spellbook, it's better to set randomitems to NULL too, 3766 * And if it's a spellbook, it's better to set randomitems to NULL too,
3650 * else you get two spells in the book ^_- 3767 * else you get two spells in the book ^_-
3651 * Ryo 2004-08-16 3768 * Ryo 2004-08-16
3652 */ 3769 */
3653 if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL || 3770 if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
3654 tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || 3771 || tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)
3655 tmp->type == ALTAR || tmp->type == SPELLBOOK)
3656 tmp->randomitems = NULL; 3772 tmp->randomitems = NULL;
3657 3773
3658 } 3774 }
3659 3775
3660 if(QUERY_FLAG(tmp,FLAG_AUTO_APPLY)) 3776 if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
3661 auto_apply(tmp); 3777 auto_apply (tmp);
3662 else if((tmp->type==TREASURE || (tmp->type==CONTAINER))&& HAS_RANDOM_ITEMS(tmp)) { 3778 else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && HAS_RANDOM_ITEMS (tmp))
3779 {
3663 while ((tmp->stats.hp--)>0) 3780 while ((tmp->stats.hp--) > 0)
3664 create_treasure(tmp->randomitems, tmp, 0, 3781 create_treasure (tmp->randomitems, tmp, 0, m->difficulty, 0);
3665 m->difficulty,0);
3666 tmp->randomitems = NULL; 3782 tmp->randomitems = NULL;
3667 } 3783 }
3668 else if(tmp->type==TIMED_GATE) { 3784 else if (tmp->type == TIMED_GATE)
3785 {
3669 object *head = tmp->head != NULL ? tmp->head : tmp; 3786 object *head = tmp->head != NULL ? tmp->head : tmp;
3787
3670 if (QUERY_FLAG(head, FLAG_IS_LINKED)) { 3788 if (QUERY_FLAG (head, FLAG_IS_LINKED))
3671 tmp->speed = 0; 3789 {
3672 update_ob_speed(tmp); 3790 tmp->speed = 0;
3673 } 3791 update_ob_speed (tmp);
3674 } 3792 }
3793 }
3675 /* This function can be called everytime a map is loaded, even when 3794 /* This function can be called everytime a map is loaded, even when
3676 * swapping back in. As such, we don't want to create the treasure 3795 * swapping back in. As such, we don't want to create the treasure
3677 * over and ove again, so after we generate the treasure, blank out 3796 * over and ove again, so after we generate the treasure, blank out
3678 * randomitems so if it is swapped in again, it won't make anything. 3797 * randomitems so if it is swapped in again, it won't make anything.
3679 * This is a problem for the above objects, because they have counters 3798 * This is a problem for the above objects, because they have counters
3680 * which say how many times to make the treasure. 3799 * which say how many times to make the treasure.
3681 */ 3800 */
3682 else if(tmp && tmp->arch && tmp->type!=PLAYER && tmp->type!=TREASURE && 3801 else if (tmp && tmp->arch && tmp->type != PLAYER
3683 tmp->type != SPELL && tmp->type != PLAYER_CHANGER && tmp->type != CLASS && 3802 && tmp->type != TREASURE && tmp->type != SPELL
3684 HAS_RANDOM_ITEMS(tmp)) { 3803 && tmp->type != PLAYER_CHANGER && tmp->type != CLASS && HAS_RANDOM_ITEMS (tmp))
3804 {
3685 create_treasure(tmp->randomitems, tmp, GT_APPLY, 3805 create_treasure (tmp->randomitems, tmp, GT_APPLY, m->difficulty, 0);
3686 m->difficulty,0);
3687 tmp->randomitems = NULL; 3806 tmp->randomitems = NULL;
3688 } 3807 }
3689 } 3808 }
3690 3809
3691 for(x=0;x<MAP_WIDTH(m);x++) 3810 for (x = 0; x < MAP_WIDTH (m); x++)
3692 for(y=0;y<MAP_HEIGHT(m);y++) 3811 for (y = 0; y < MAP_HEIGHT (m); y++)
3693 for(tmp=get_map_ob(m,x,y);tmp!=NULL;tmp=tmp->above) 3812 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)
3694 if (tmp->above &&
3695 (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL)) 3813 if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3696 check_trigger (tmp, tmp->above); 3814 check_trigger (tmp, tmp->above);
3697} 3815}
3698 3816
3699/** 3817/**
3700 * Handles player eating food that temporarily changes status (resistances, stats). 3818 * Handles player eating food that temporarily changes status (resistances, stats).
3701 * This used to call cast_change_attr(), but 3819 * This used to call cast_change_attr(), but
3702 * that doesn't work with the new spell code. Since we know what 3820 * that doesn't work with the new spell code. Since we know what
3703 * the food changes, just grab a force and use that instead. 3821 * the food changes, just grab a force and use that instead.
3704 */ 3822 */
3705 3823
3824void
3706void eat_special_food(object *who, object *food) { 3825eat_special_food (object *who, object *food)
3826{
3707 object *force; 3827 object *force;
3708 int i, did_one=0; 3828 int i, did_one = 0;
3709 sint8 k; 3829 sint8 k;
3710 3830
3711 force = get_archetype(FORCE_NAME); 3831 force = get_archetype (FORCE_NAME);
3712 3832
3713 for (i=0; i < NUM_STATS; i++) { 3833 for (i = 0; i < NUM_STATS; i++)
3834 {
3714 k = get_attr_value(&food->stats, i); 3835 k = get_attr_value (&food->stats, i);
3715 if (k) { 3836 if (k)
3837 {
3716 set_attr_value(&force->stats, i, k); 3838 set_attr_value (&force->stats, i, k);
3717 did_one = 1; 3839 did_one = 1;
3718 } 3840 }
3719 } 3841 }
3720 3842
3721 /* check if we can protect the eater */ 3843 /* check if we can protect the eater */
3722 for (i=0; i<NROFATTACKS; i++) { 3844 for (i = 0; i < NROFATTACKS; i++)
3845 {
3723 if (food->resist[i]>0) { 3846 if (food->resist[i] > 0)
3847 {
3724 force->resist[i] = food->resist[i] / 2; 3848 force->resist[i] = food->resist[i] / 2;
3725 did_one = 1; 3849 did_one = 1;
3726 } 3850 }
3727 } 3851 }
3728 if (did_one) { 3852 if (did_one)
3853 {
3729 force->speed = 0.1; 3854 force->speed = 0.1;
3730 update_ob_speed(force); 3855 update_ob_speed (force);
3731 /* bigger morsel of food = longer effect time */ 3856 /* bigger morsel of food = longer effect time */
3732 force->stats.food = food->stats.food / 5; 3857 force->stats.food = food->stats.food / 5;
3733 SET_FLAG(force, FLAG_IS_USED_UP); 3858 SET_FLAG (force, FLAG_IS_USED_UP);
3734 SET_FLAG(force, FLAG_APPLIED); 3859 SET_FLAG (force, FLAG_APPLIED);
3735 change_abil(who, force); 3860 change_abil (who, force);
3736 insert_ob_in_ob(force, who); 3861 insert_ob_in_ob (force, who);
3737 } else {
3738 free_object(force);
3739 } 3862 }
3863 else
3864 force->destroy ();
3740 3865
3741 /* check for hp, sp change */ 3866 /* check for hp, sp change */
3742 if(food->stats.hp!=0) { 3867 if (food->stats.hp != 0)
3868 {
3743 if(QUERY_FLAG(food, FLAG_CURSED)) { 3869 if (QUERY_FLAG (food, FLAG_CURSED))
3870 {
3744 strcpy(who->contr->killer,food->name); 3871 strcpy (who->contr->killer, food->name);
3745 hit_player(who, food->stats.hp, food, AT_POISON, 1); 3872 hit_player (who, food->stats.hp, food, AT_POISON, 1);
3746 new_draw_info(NDI_UNIQUE, 0,who,"Eck!...that was poisonous!"); 3873 new_draw_info (NDI_UNIQUE, 0, who, "Eck!...that was poisonous!");
3747 } else { 3874 }
3875 else
3876 {
3748 if(food->stats.hp>0) 3877 if (food->stats.hp > 0)
3749 new_draw_info(NDI_UNIQUE, 0,who,"You begin to feel better."); 3878 new_draw_info (NDI_UNIQUE, 0, who, "You begin to feel better.");
3750 else 3879 else
3751 new_draw_info(NDI_UNIQUE, 0,who,"Eck!...that was poisonous!"); 3880 new_draw_info (NDI_UNIQUE, 0, who, "Eck!...that was poisonous!");
3752 who->stats.hp += food->stats.hp; 3881 who->stats.hp += food->stats.hp;
3753 } 3882 }
3754 } 3883 }
3755 if(food->stats.sp!=0) { 3884 if (food->stats.sp != 0)
3885 {
3756 if(QUERY_FLAG(food, FLAG_CURSED)) { 3886 if (QUERY_FLAG (food, FLAG_CURSED))
3887 {
3757 new_draw_info(NDI_UNIQUE, 0,who,"You are drained of mana!"); 3888 new_draw_info (NDI_UNIQUE, 0, who, "You are drained of mana!");
3758 who->stats.sp -= food->stats.sp; 3889 who->stats.sp -= food->stats.sp;
3759 if(who->stats.sp<0) who->stats.sp=0; 3890 if (who->stats.sp < 0)
3760 } else { 3891 who->stats.sp = 0;
3892 }
3893 else
3894 {
3761 new_draw_info(NDI_UNIQUE, 0,who,"You feel a rush of magical energy!"); 3895 new_draw_info (NDI_UNIQUE, 0, who, "You feel a rush of magical energy!");
3762 who->stats.sp += food->stats.sp; 3896 who->stats.sp += food->stats.sp;
3763 /* place limit on max sp from food? */ 3897 /* place limit on max sp from food? */
3898 }
3764 } 3899 }
3765 }
3766 fix_player(who); 3900 fix_player (who);
3767} 3901}
3768 3902
3769 3903
3770/** 3904/**
3771 * Designed primarily to light torches/lanterns/etc. 3905 * Designed primarily to light torches/lanterns/etc.
3772 * Also burns up burnable material too. First object in the inventory is 3906 * Also burns up burnable material too. First object in the inventory is
3773 * the selected object to "burn". -b.t. 3907 * the selected object to "burn". -b.t.
3774 */ 3908 */
3775 3909
3910void
3776void apply_lighter(object *who, object *lighter) { 3911apply_lighter (object *who, object *lighter)
3912{
3777 object *item; 3913 object *item;
3778 int is_player_env=0; 3914 int is_player_env = 0;
3779 uint32 nrof;
3780 tag_t count;
3781 char item_name[MAX_BUF]; 3915 char item_name[MAX_BUF];
3782 3916
3783 item=find_marked_object(who); 3917 item = find_marked_object (who);
3784 if(item) { 3918 if (item)
3919 {
3785 if(lighter->last_eat && lighter->stats.food) { /* lighter gets used up */ 3920 if (lighter->last_eat && lighter->stats.food)
3921 { /* lighter gets used up */
3786 /* Split multiple lighters if they're being used up. Otherwise * 3922 /* Split multiple lighters if they're being used up. Otherwise *
3787 * one charge from each would be used up. --DAMN */ 3923 * one charge from each would be used up. --DAMN */
3788 if(lighter->nrof > 1) { 3924 if (lighter->nrof > 1)
3789 object *oneLighter = get_object(); 3925 {
3790 copy_object(lighter, oneLighter); 3926 object *oneLighter = object::create ();
3927
3928 lighter->copy_to (oneLighter);
3791 lighter->nrof -= 1; 3929 lighter->nrof -= 1;
3792 oneLighter->nrof = 1; 3930 oneLighter->nrof = 1;
3793 oneLighter->stats.food--; 3931 oneLighter->stats.food--;
3794 esrv_send_item(who, lighter); 3932 esrv_send_item (who, lighter);
3795 oneLighter=insert_ob_in_ob(oneLighter, who); 3933 oneLighter = insert_ob_in_ob (oneLighter, who);
3796 esrv_send_item(who, oneLighter); 3934 esrv_send_item (who, oneLighter);
3797 } else { 3935 }
3936 else
3798 lighter->stats.food--; 3937 lighter->stats.food--;
3799 } 3938 }
3800 3939 else if (lighter->last_eat)
3801 } else if(lighter->last_eat) { /* no charges left in lighter */ 3940 { /* no charges left in lighter */
3802 new_draw_info_format(NDI_UNIQUE, 0,who, 3941 new_draw_info_format (NDI_UNIQUE, 0, who, "You attempt to light the %s with a used up %s.", &item->name, &lighter->name);
3803 "You attempt to light the %s with a used up %s.",
3804 item->name, lighter->name);
3805 return; 3942 return;
3806 } 3943 }
3807 /* Perhaps we should split what we are trying to light on fire? 3944 /* Perhaps we should split what we are trying to light on fire?
3808 * I can't see many times when you would want to light multiple 3945 * I can't see many times when you would want to light multiple
3809 * objects at once. 3946 * objects at once.
3810 */ 3947 */
3811 nrof=item->nrof;
3812 count=item->count;
3813 /* If the item is destroyed, we don't have a valid pointer to the 3948 /* If the item is destroyed, we don't have a valid pointer to the
3814 * name object, so make a copy so the message we print out makes 3949 * name object, so make a copy so the message we print out makes
3815 * some sense. 3950 * some sense.
3816 */ 3951 */
3817 strcpy(item_name, item->name); 3952 strcpy (item_name, item->name);
3818 if (who == is_player_inv(item)) is_player_env=1; 3953 if (who == is_player_inv (item))
3954 is_player_env = 1;
3819 3955
3820 save_throw_object(item,AT_FIRE,who); 3956 save_throw_object (item, AT_FIRE, who);
3821 /* Change to check count and not freed, since the object pointer 3957 /* Change to check count and not freed, since the object pointer
3822 * may have gotten recycled 3958 * may have gotten recycled
3823 */ 3959 */
3824 if ((nrof != item->nrof ) || (count != item->count)) { 3960 if (item->destroyed ())
3825 new_draw_info_format(NDI_UNIQUE, 0,who, 3961 {
3826 "You light the %s with the %s.",item_name,lighter->name); 3962 new_draw_info_format (NDI_UNIQUE, 0, who, "You light the %s with the %s.", &item_name, &lighter->name);
3827 /* Need to update the player so that the players glow radius 3963 /* Need to update the player so that the players glow radius
3828 * gets changed. 3964 * gets changed.
3829 */ 3965 */
3830 if (is_player_env) fix_player(who); 3966 if (is_player_env)
3831 } else { 3967 fix_player (who);
3832 new_draw_info_format(NDI_UNIQUE, 0,who, 3968 }
3833 "You attempt to light the %s with the %s and fail.",item->name,lighter->name); 3969 else
3834 } 3970 new_draw_info_format (NDI_UNIQUE, 0, who, "You attempt to light the %s with the %s and fail.", &item->name, &lighter->name);
3835 3971 }
3836 } else /* nothing to light */ 3972 else /* nothing to light */
3837 new_draw_info(NDI_UNIQUE, 0,who,"You need to mark a lightable object."); 3973 new_draw_info (NDI_UNIQUE, 0, who, "You need to mark a lightable object.");
3838 3974
3839} 3975}
3840 3976
3841/** 3977/**
3842 * op made some mistake with a scroll, this takes care of punishment. 3978 * op made some mistake with a scroll, this takes care of punishment.
3843 * scroll_failure()- hacked directly from spell_failure 3979 * scroll_failure()- hacked directly from spell_failure
3844 */ 3980 */
3981void
3845void scroll_failure(object *op, int failure, int power) 3982scroll_failure (object *op, int failure, int power)
3846{ 3983{
3847 if(abs(failure/4)>power) power=abs(failure/4); /* set minimum effect */ 3984 if (abs (failure / 4) > power)
3985 power = abs (failure / 4); /* set minimum effect */
3848 3986
3849 if(failure<= -1&&failure > -15) {/* wonder */ 3987 if (failure <= -1 && failure > -15)
3988 { /* wonder */
3850 object *tmp; 3989 object *tmp;
3851 3990
3852 new_draw_info(NDI_UNIQUE, 0,op,"Your spell warps!."); 3991 new_draw_info (NDI_UNIQUE, 0, op, "Your spell warps!.");
3853 tmp=get_archetype(SPELL_WONDER); 3992 tmp = get_archetype (SPELL_WONDER);
3854 cast_wonder(op, op, 0, tmp); 3993 cast_wonder (op, op, 0, tmp);
3855 free_object(tmp); 3994 tmp->destroy ();
3995 }
3856 } else if (failure <= -15&&failure > -35) {/* drain mana */ 3996 else if (failure <= -15 && failure > -35)
3997 { /* drain mana */
3857 new_draw_info(NDI_UNIQUE, 0,op,"Your mana is drained!."); 3998 new_draw_info (NDI_UNIQUE, 0, op, "Your mana is drained!.");
3858 op->stats.sp -= random_roll(0, power-1, op, PREFER_LOW); 3999 op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3859 if(op->stats.sp<0) op->stats.sp = 0; 4000 if (op->stats.sp < 0)
4001 op->stats.sp = 0;
4002 }
3860 } else if (settings.spell_failure_effects == TRUE) { 4003 else if (settings.spell_failure_effects == TRUE)
3861 if (failure <= -35&&failure > -60) { /* confusion */ 4004 {
4005 if (failure <= -35 && failure > -60)
4006 { /* confusion */
3862 new_draw_info(NDI_UNIQUE, 0,op,"The magic recoils on you!"); 4007 new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");
3863 confuse_player(op,op,power); 4008 confuse_player (op, op, power);
3864 } else if (failure <= -60&&failure> -70) {/* paralysis */ 4009 }
4010 else if (failure <= -60 && failure > -70)
4011 { /* paralysis */
3865 new_draw_info(NDI_UNIQUE, 0,op,"The magic recoils and paralyzes " 4012 new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils and paralyzes " "you!");
3866 "you!");
3867 paralyze_player(op,op,power); 4013 paralyze_player (op, op, power);
4014 }
3868 } else if (failure <= -70&&failure> -80) {/* blind */ 4015 else if (failure <= -70 && failure > -80)
4016 { /* blind */
3869 new_draw_info(NDI_UNIQUE, 0,op,"The magic recoils on you!"); 4017 new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");
3870 blind_player(op,op,power); 4018 blind_player (op, op, power);
3871 } else if (failure <= -80) {/* blast the immediate area */ 4019 }
4020 else if (failure <= -80)
4021 { /* blast the immediate area */
3872 object *tmp; 4022 object *tmp;
4023
3873 tmp=get_archetype(LOOSE_MANA); 4024 tmp = get_archetype (LOOSE_MANA);
3874 cast_magic_storm(op,tmp, power); 4025 cast_magic_storm (op, tmp, power);
3875 new_draw_info(NDI_UNIQUE, 0,op,"You unlease uncontrolled mana!"); 4026 new_draw_info (NDI_UNIQUE, 0, op, "You unlease uncontrolled mana!");
3876 free_object(tmp); 4027 tmp->destroy ();
3877 } 4028 }
3878 } 4029 }
3879} 4030}
3880 4031
4032void
3881void apply_changes_to_player(object *pl, object *change) { 4033apply_changes_to_player (object *pl, object *change)
4034{
3882 int excess_stat=0; /* if the stat goes over the maximum 4035 int excess_stat = 0; /* if the stat goes over the maximum
3883 for the race, put the excess stat some 4036 for the race, put the excess stat some
3884 where else. */ 4037 where else. */
3885 4038
3886 switch (change->type) { 4039 switch (change->type)
3887 case CLASS: { 4040 {
4041 case CLASS:
4042 {
3888 living *stats = &(pl->contr->orig_stats); 4043 living *stats = &(pl->contr->orig_stats);
3889 living *ns = &(change->stats); 4044 living *ns = &(change->stats);
3890 object *walk; 4045 object *walk;
3891 int flag_change_face=1; 4046 int flag_change_face = 1;
3892 4047
3893 /* the following code assigns stats up to the stat max 4048 /* the following code assigns stats up to the stat max
3894 * for the race, and if the stat max is exceeded, 4049 * for the race, and if the stat max is exceeded,
3895 * tries to randomly reassign the excess stat 4050 * tries to randomly reassign the excess stat
3896 */ 4051 */
3897 int i,j; 4052 int i, j;
4053
3898 for(i=0;i<NUM_STATS;i++) { 4054 for (i = 0; i < NUM_STATS; i++)
4055 {
3899 sint8 stat=get_attr_value(stats,i); 4056 sint8 stat = get_attr_value (stats, i);
3900 int race_bonus = get_attr_value(&(pl->arch->clone.stats),i); 4057 int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);
4058
3901 stat += get_attr_value(ns,i); 4059 stat += get_attr_value (ns, i);
3902 if(stat > 20 + race_bonus) { 4060 if (stat > 20 + race_bonus)
3903 excess_stat++; 4061 {
3904 stat = 20+race_bonus; 4062 excess_stat++;
3905 } 4063 stat = 20 + race_bonus;
4064 }
3906 set_attr_value(stats,i,stat); 4065 set_attr_value (stats, i, stat);
3907 } 4066 }
3908 4067
3909 for(j=0;excess_stat >0 && j<100;j++) {/* try 100 times to assign excess stats */ 4068 for (j = 0; excess_stat > 0 && j < 100; j++)
3910 int i = rndm(0, 6); 4069 { /* try 100 times to assign excess stats */
4070 int i = rndm (0, 6);
3911 int stat=get_attr_value(stats,i); 4071 int stat = get_attr_value (stats, i);
3912 int race_bonus = get_attr_value(&(pl->arch->clone.stats),i); 4072 int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);
3913 if(i==CHA) continue; /* exclude cha from this */ 4073
3914 if( stat < 20 + race_bonus) { 4074 if (i == CHA)
4075 continue; /* exclude cha from this */
4076 if (stat < 20 + race_bonus)
4077 {
3915 change_attr_value(stats,i,1); 4078 change_attr_value (stats, i, 1);
3916 excess_stat--; 4079 excess_stat--;
3917 } 4080 }
3918 } 4081 }
3919 4082
3920 /* insert the randomitems from the change's treasurelist into 4083 /* insert the randomitems from the change's treasurelist into
3921 * the player ref: player.c 4084 * the player ref: player.c
3922 */ 4085 */
3923 if(change->randomitems!=NULL) 4086 if (change->randomitems != NULL)
3924 give_initial_items(pl,change->randomitems); 4087 give_initial_items (pl, change->randomitems);
3925 4088
3926 4089
3927 /* set up the face, for some races. */ 4090 /* set up the face, for some races. */
3928 4091
3929 /* first, look for the force object banning 4092 /* first, look for the force object banning
3930 * changing the face. Certain races never change face with class. 4093 * changing the face. Certain races never change face with class.
3931 */ 4094 */
3932 for(walk=pl->inv;walk!=NULL;walk=walk->below) 4095 for (walk = pl->inv; walk != NULL; walk = walk->below)
3933 if (!strcmp(walk->name,"NOCLASSFACECHANGE")) flag_change_face=0; 4096 if (!strcmp (walk->name, "NOCLASSFACECHANGE"))
4097 flag_change_face = 0;
3934 4098
3935 if(flag_change_face) { 4099 if (flag_change_face)
4100 {
3936 pl->animation_id = GET_ANIM_ID(change); 4101 pl->animation_id = GET_ANIM_ID (change);
3937 pl->face = change->face; 4102 pl->face = change->face;
3938 4103
3939 if(QUERY_FLAG(change,FLAG_ANIMATE)) 4104 if (QUERY_FLAG (change, FLAG_ANIMATE))
3940 SET_FLAG(pl,FLAG_ANIMATE); 4105 SET_FLAG (pl, FLAG_ANIMATE);
3941 else 4106 else
3942 CLEAR_FLAG(pl,FLAG_ANIMATE); 4107 CLEAR_FLAG (pl, FLAG_ANIMATE);
3943 } 4108 }
3944 4109
3945 /* check the special case of can't use weapons */ 4110 /* check the special case of can't use weapons */
3946 /*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON);*/ 4111 /*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3947 if(!strcmp(change->name,"monk")) CLEAR_FLAG(pl,FLAG_USE_WEAPON); 4112 if (!strcmp (change->name, "monk"))
4113 CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3948 4114
3949 break; 4115 break;
3950 } 4116 }
3951 } 4117 }
3952} 4118}
3953 4119
3954/** 4120/**
3955 * This handles items of type 'transformer'. 4121 * This handles items of type 'transformer'.
… …
3959 * Change information is contained in the 'slaying' field of the marked item. 4125 * Change information is contained in the 'slaying' field of the marked item.
3960 * The format is as follow: transformer:[number ]yield[;transformer:...]. 4126 * The format is as follow: transformer:[number ]yield[;transformer:...].
3961 * This way an item can be transformed in many things, and/or many objects. 4127 * This way an item can be transformed in many things, and/or many objects.
3962 * The 'slaying' field for transformer is used as verb for the action. 4128 * The 'slaying' field for transformer is used as verb for the action.
3963 */ 4129 */
4130void
3964void apply_item_transformer( object* pl, object* transformer ) 4131apply_item_transformer (object *pl, object *transformer)
3965 { 4132{
3966 object* marked; 4133 object *marked;
3967 object* new_item; 4134 object *new_item;
3968 char* find; 4135 char *find;
3969 char* separator; 4136 char *separator;
3970 int yield; 4137 int yield;
3971 char got[ MAX_BUF ]; 4138 char got[MAX_BUF];
3972 int len; 4139 int len;
3973 4140
3974 if ( !pl || !transformer ) 4141 if (!pl || !transformer)
3975 return; 4142 return;
3976 marked = find_marked_object( pl ); 4143 marked = find_marked_object (pl);
3977 if ( !marked ) 4144 if (!marked)
3978 { 4145 {
3979 new_draw_info_format( NDI_UNIQUE, 0, pl, "Use the %s with what item?", query_name( transformer ) ); 4146 new_draw_info_format (NDI_UNIQUE, 0, pl, "Use the %s with what item?", query_name (transformer));
3980 return; 4147 return;
3981 } 4148 }
3982 if ( !marked->slaying ) 4149 if (!marked->slaying)
3983 { 4150 {
3984 new_draw_info_format( NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name( transformer ), query_name( marked ) ); 4151 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));
3985 return; 4152 return;
3986 } 4153 }
3987 /* check whether they are compatible or not */ 4154 /* check whether they are compatible or not */
3988 find = strstr( marked->slaying, transformer->arch->name ); 4155 find = strstr (marked->slaying, transformer->arch->name);
3989 if ( !find || ( *( find + strlen( transformer->arch->name ) ) != ':' ) ) 4156 if (!find || (*(find + strlen (transformer->arch->name)) != ':'))
3990 { 4157 {
3991 new_draw_info_format( NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name( transformer ), query_name( marked ) ); 4158 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));
3992 return; 4159 return;
3993 } 4160 }
3994 find += strlen( transformer->arch->name ) + 1; 4161 find += strlen (transformer->arch->name) + 1;
3995 /* Item can be used, now find how many and what it yields */ 4162 /* Item can be used, now find how many and what it yields */
3996 if ( isdigit( *( find ) ) ) 4163 if (isdigit (*(find)))
3997 { 4164 {
3998 yield = atoi( find ); 4165 yield = atoi (find);
3999 if ( yield < 1 ) 4166 if (yield < 1)
4000 { 4167 {
4001 LOG( llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name( marked, 0 ), yield ); 4168 LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4002 yield = 1; 4169 yield = 1;
4003 } 4170 }
4004 } 4171 }
4005 else 4172 else
4006 yield = 1; 4173 yield = 1;
4007 4174
4008 while ( isdigit( *find ) ) 4175 while (isdigit (*find))
4009 find++; 4176 find++;
4010 while ( *find == ' ' ) 4177 while (*find == ' ')
4011 find++; 4178 find++;
4012 memset( got, 0, MAX_BUF ); 4179 memset (got, 0, MAX_BUF);
4013 if ( (separator = strchr( find, ';' ))!=NULL) 4180 if ((separator = strchr (find, ';')) != NULL)
4014 { 4181 {
4015 len = separator - find; 4182 len = separator - find;
4016 } 4183 }
4017 else 4184 else
4018 { 4185 {
4019 len = strlen(find); 4186 len = strlen (find);
4020 } 4187 }
4021 if ( len > MAX_BUF-1) 4188 if (len > MAX_BUF - 1)
4022 len = MAX_BUF-1; 4189 len = MAX_BUF - 1;
4023 strcpy( got, find ); 4190 strcpy (got, find);
4024 got[len] = '\0'; 4191 got[len] = '\0';
4025 4192
4026 /* Now create new item, remove used ones when required. */ 4193 /* Now create new item, remove used ones when required. */
4027 new_item = get_archetype( got ); 4194 new_item = get_archetype (got);
4028 if ( !new_item ) 4195 if (!new_item)
4029 { 4196 {
4030 new_draw_info_format( NDI_UNIQUE, 0, pl, "This %s is strange, better to not use it.", query_base_name( marked, 0 ) ); 4197 new_draw_info_format (NDI_UNIQUE, 0, pl, "This %s is strange, better to not use it.", query_base_name (marked, 0));
4031 return; 4198 return;
4032 } 4199 }
4200
4033 new_item->nrof = yield; 4201 new_item->nrof = yield;
4034 new_draw_info_format( NDI_UNIQUE, 0, pl, "You %s the %s.", transformer->slaying, query_base_name( marked, 0 ) ); 4202 new_draw_info_format (NDI_UNIQUE, 0, pl, "You %s the %s.", &transformer->slaying, query_base_name (marked, 0));
4035 insert_ob_in_ob( new_item, pl ); 4203 insert_ob_in_ob (new_item, pl);
4036 esrv_send_inventory( pl, pl ); 4204 esrv_send_inventory (pl, pl);
4037 /* Eat up one item */ 4205 /* Eat up one item */
4038 decrease_ob_nr( marked, 1 ); 4206 decrease_ob_nr (marked, 1);
4039 /* Eat one transformer if needed */ 4207 /* Eat one transformer if needed */
4040 if ( transformer->stats.food ) 4208 if (transformer->stats.food)
4041 if ( --transformer->stats.food == 0 ) 4209 if (--transformer->stats.food == 0)
4042 decrease_ob_nr( transformer, 1 ); 4210 decrease_ob_nr (transformer, 1);
4043 } 4211}

Diff Legend

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