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.8 by root, Fri Aug 25 15:21:57 2006 UTC vs.
Revision 1.51 by root, Fri Dec 22 16:34:00 2006 UTC

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

Diff Legend

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