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

Comparing deliantra/server/server/time.C (file contents):
Revision 1.68 by root, Wed Sep 12 11:10:11 2007 UTC vs.
Revision 1.107 by root, Sun Apr 11 18:50:04 2010 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24/* 25/*
25 * Routines that is executed from objects based on their speed have been 26 * Routines that is executed from objects based on their speed have been
26 * collected in this file. 27 * collected in this file.
… …
34 * so those will be removed shortly (in a cascade like fashion.) 35 * so those will be removed shortly (in a cascade like fashion.)
35 */ 36 */
36void 37void
37remove_door (object *op) 38remove_door (object *op)
38{ 39{
39 int i; 40 for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
41 {
40 object *tmp; 42 object *tmp;
41 43 mapxy pos (op);
42 for (i = 1; i < 9; i += 2) 44 pos.move (i);
43 if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL) 45 if (pos.normalise ()
46 && (tmp = present (DOOR, pos.m, pos.x, pos.y)))
44 { 47 {
45 tmp->set_speed (0.1f); 48 tmp->set_speed (0.1f);
46 tmp->speed_left = -0.2f; 49 tmp->speed_left = -0.2f;
47 } 50 }
51 }
48 52
49 if (op->other_arch) 53 if (op->other_arch)
50 { 54 {
51 tmp = arch_to_object (op->other_arch); 55 object *tmp = op->other_arch->instance ();
52 tmp->x = op->x; 56 tmp->x = op->x;
53 tmp->y = op->y; 57 tmp->y = op->y;
54 tmp->map = op->map; 58 tmp->map = op->map;
55 tmp->level = op->level; 59 tmp->level = op->level;
56 insert_ob_in_map (tmp, op->map, op, 0); 60 insert_ob_in_map (tmp, op->map, op, 0);
57 } 61 }
58 62
59 op->destroy (); 63 op->drop_and_destroy ();
60} 64}
61 65
62void 66void
63remove_door2 (object *op) 67remove_door2 (object *op)
64{ 68{
… …
75 } 79 }
76 } 80 }
77 81
78 if (op->other_arch) 82 if (op->other_arch)
79 { 83 {
80 tmp = arch_to_object (op->other_arch); 84 tmp = op->other_arch->instance ();
81 tmp->x = op->x; 85 tmp->x = op->x;
82 tmp->y = op->y; 86 tmp->y = op->y;
83 tmp->map = op->map; 87 tmp->map = op->map;
84 tmp->level = op->level; 88 tmp->level = op->level;
85 insert_ob_in_map (tmp, op->map, op, 0); 89 insert_ob_in_map (tmp, op->map, op, 0);
86 } 90 }
87 91
88 op->destroy (); 92 op->drop_and_destroy ();
89} 93}
90 94
91void 95static void
92generate_monster (object *gen) 96generate_monster (object *gen)
93{ 97{
94 if (!gen->map) 98 if (!gen->map)
95 return; 99 return;
96 100
97 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1)) 101 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
98 return; 102 return;
99 103
104 // sleeping generators won't generate, this will make monsters like
105 // centipedes not generate more centipedes when being asleep.
106 if (gen->flag [FLAG_SLEEP])
107 return;
108
100 object *op; 109 object *op;
101 int dir; 110 int dir;
102 111
103 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 112 if (gen->flag [FLAG_CONTENT_ON_GEN])
104 { 113 {
105 // either copy one item from the inventory... 114 // either copy one item from the inventory...
106 if (!gen->inv) 115 if (!gen->inv)
107 return; 116 return;
108 117
… …
114 123
115 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1); 124 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
116 if (dir < 0) 125 if (dir < 0)
117 return; 126 return;
118 127
119 op = object_create_clone (op); 128 op = op->deep_clone ();
120 129
121 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 130 op->clr_flag (FLAG_IS_A_TEMPLATE);
122 unflag_inv (op, FLAG_IS_A_TEMPLATE); 131 unflag_inv (op, FLAG_IS_A_TEMPLATE);
123 } 132 }
124 else if (gen->other_arch) 133 else if (gen->other_arch)
125 { 134 {
126 // ...or use other_arch 135 // ...or use other_arch
127 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1); 136 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
128 if (dir < 0) 137 if (dir < 0)
129 return; 138 return;
130 139
131 op = arch_to_object (gen->other_arch); 140 op = gen->other_arch->instance ();
132 } 141 }
133 else 142 else
134 return; 143 return;
135 144
136 op->expand_tail (); 145 op->expand_tail ();
… …
149 } 158 }
150 159
151 op->destroy (); 160 op->destroy ();
152} 161}
153 162
154void 163static void
155remove_force (object *op) 164remove_force (object *op)
156{ 165{
157 if (--op->duration > 0) 166 if (--op->duration > 0)
158 return; 167 return;
159 168
160 if (op->env) 169 if (op->env)
161 switch (op->subtype) 170 switch (op->subtype)
162 { 171 {
163 case FORCE_CONFUSION: 172 case FORCE_CONFUSION:
164 CLEAR_FLAG (op->env, FLAG_CONFUSED); 173 op->env->clr_flag (FLAG_CONFUSED);
165 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n"); 174 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
166 175
167 default: 176 default:
168 CLEAR_FLAG (op, FLAG_APPLIED); 177 op->clr_flag (FLAG_APPLIED);
169 change_abil (op->env, op); 178 change_abil (op->env, op);
170 op->env->update_stats (); 179 op->env->update_stats ();
171 } 180 }
172 181
173 op->destroy (); 182 op->destroy ();
174} 183}
175 184
176void 185static void
177remove_blindness (object *op) 186remove_blindness (object *op)
178{ 187{
179 if (--op->stats.food > 0) 188 if (--op->stats.food > 0)
180 return; 189 return;
181 190
182 CLEAR_FLAG (op, FLAG_APPLIED); 191 op->clr_flag (FLAG_APPLIED);
183 192
184 if (op->env) 193 if (op->env)
185 { 194 {
186 change_abil (op->env, op); 195 change_abil (op->env, op);
187 op->env->update_stats (); 196 op->env->update_stats ();
188 } 197 }
189 198
190 op->destroy (); 199 op->destroy ();
191} 200}
192 201
193void 202static void
194poison_more (object *op) 203poison_more (object *op)
195{ 204{
196 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0) 205 if (op->env == NULL || !op->env->flag [FLAG_ALIVE] || op->env->stats.hp < 0)
197 { 206 {
198 op->destroy (); 207 op->destroy ();
199 return; 208 return;
200 } 209 }
201 210
… …
204 /* need to unapply the object before update_stats is called, else fix_player 213 /* need to unapply the object before update_stats is called, else fix_player
205 * will not do anything. 214 * will not do anything.
206 */ 215 */
207 if (op->env->type == PLAYER) 216 if (op->env->type == PLAYER)
208 { 217 {
209 CLEAR_FLAG (op, FLAG_APPLIED); 218 op->clr_flag (FLAG_APPLIED);
210 op->env->update_stats (); 219 op->env->update_stats ();
211 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now."); 220 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
212 } 221 }
213 222
214 op->destroy (); 223 op->destroy ();
… …
223 232
224 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 233 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
225} 234}
226 235
227 236
228void 237static void
229move_gate (object *op) 238move_gate (object *op)
230{ /* 1 = going down, 0 = going up */ 239{ /* 1 = going down, 0 = going up */
231 object *tmp; 240 object *tmp;
232 241
233 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 242 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
… …
240 if (op->value) 249 if (op->value)
241 { 250 {
242 if (--op->stats.wc <= 0) 251 if (--op->stats.wc <= 0)
243 { /* Reached bottom, let's stop */ 252 { /* Reached bottom, let's stop */
244 op->stats.wc = 0; 253 op->stats.wc = 0;
245 if (op->arch->speed) 254 if (op->arch->has_active_speed ())
246 op->value = 0; 255 op->value = 0;
247 else 256 else
248 op->set_speed (0); 257 op->set_speed (0);
249 } 258 }
250 259
251 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 260 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
252 { 261 {
253 op->move_block = 0; 262 op->move_block = 0;
254 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 263 op->clr_flag (FLAG_BLOCKSVIEW);
255 update_all_los (op->map, op->x, op->y); 264 update_all_los (op->map, op->x, op->y);
256 } 265 }
257 266
258 SET_ANIMATION (op, op->stats.wc); 267 SET_ANIMATION (op, op->stats.wc);
259 update_object (op, UP_OBJ_CHANGE); 268 update_object (op, UP_OBJ_CHANGE);
… …
271 * otherwise, we fall through to the code below which should lower 280 * otherwise, we fall through to the code below which should lower
272 * the gate slightly. 281 * the gate slightly.
273 */ 282 */
274 283
275 for (tmp = op->above; tmp; tmp = tmp->above) 284 for (tmp = op->above; tmp; tmp = tmp->above)
276 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 285 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
277 break; 286 break;
278 287
279 if (!tmp) 288 if (!tmp)
280 { 289 {
281 if (op->arch->speed) 290 if (op->arch->has_active_speed ())
282 op->value = 1; 291 op->value = 1;
283 else 292 else
284 op->set_speed (0); 293 op->set_speed (0);
285 294
286 return; 295 return;
… …
297 } 306 }
298 else 307 else
299 { /* The gate is still going up */ 308 { /* The gate is still going up */
300 op->stats.wc++; 309 op->stats.wc++;
301 310
302 if ((int) op->stats.wc >= (NUM_ANIMATIONS (op))) 311 if (op->stats.wc >= NUM_ANIMATIONS (op))
303 op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1; 312 op->stats.wc = NUM_ANIMATIONS (op) - 1;
304 313
305 /* If there is something on top of the gate, we try to roll it off. 314 /* If there is something on top of the gate, we try to roll it off.
306 * If a player/monster, we don't roll, we just hit them with damage 315 * If a player/monster, we don't roll, we just hit them with damage
307 */ 316 */
308 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 317 if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
309 { 318 {
310 /* Halfway or further, check blocks */ 319 /* Halfway or further, check blocks */
311 /* First, get the top object on the square. */ 320 /* First, get the top object on the square. */
312 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 321 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
313 ; 322 ;
314 323
315 if (tmp) 324 if (tmp)
316 { 325 {
317 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 326 if (tmp->flag [FLAG_ALIVE])
318 { 327 {
319 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 328 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
320 op->play_sound (sound_find ("blocked_gate")); 329 op->play_sound (sound_find ("blocked_gate"));
321 330
322 if (tmp->type == PLAYER) 331 if (tmp->type == PLAYER)
… …
324 } 333 }
325 /* If the object is not alive, and the object either can 334 /* If the object is not alive, and the object either can
326 * be picked up or the object rolls, move the object 335 * be picked up or the object rolls, move the object
327 * off the gate. 336 * off the gate.
328 */ 337 */
329 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL))) 338 else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
330 { 339 {
331 /* If it has speed, it should move itself, otherwise: */ 340 /* If it has speed, it should move itself, otherwise: */
332 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9); 341 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
333 342
334 /* If there is a free spot, move the object someplace */ 343 /* If there is a free spot, move the object someplace */
335 if (i != -1) 344 if (i > 0)
336 { 345 {
346 mapxy pos (tmp);
347 pos.move (i);
348 if (pos.normalise ())
337 tmp->remove (); 349 tmp->move_to (pos);
338 tmp->x += freearr_x[i], tmp->y += freearr_y[i];
339 insert_ob_in_map (tmp, op->map, op, 0);
340 } 350 }
341 } 351 }
342 } 352 }
343 353
344 /* See if there is still anything blocking the gate */ 354 /* See if there is still anything blocking the gate */
345 for (tmp = op->above; tmp; tmp = tmp->above) 355 for (tmp = op->above; tmp; tmp = tmp->above)
346 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 356 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
347 break; 357 break;
348 358
349 /* IF there is, start putting the gate down */ 359 /* IF there is, start putting the gate down */
350 if (tmp) 360 if (tmp)
351 op->stats.food = 1; 361 op->stats.food = 1;
352 else 362 else
353 { 363 {
354 op->move_block = MOVE_ALL; 364 op->move_block = MOVE_ALL;
355 365
356 if (!op->arch->stats.ac) 366 if (!op->arch->stats.ac)
357 SET_FLAG (op, FLAG_BLOCKSVIEW); 367 op->set_flag (FLAG_BLOCKSVIEW);
358 update_all_los (op->map, op->x, op->y); 368 update_all_los (op->map, op->x, op->y);
359 } 369 }
360 } /* gate is halfway up */ 370 } /* gate is halfway up */
361 371
362 SET_ANIMATION (op, op->stats.wc); 372 SET_ANIMATION (op, op->stats.wc);
… …
366 376
367/* hp : how long door is open/closed 377/* hp : how long door is open/closed
368 * maxhp : initial value for hp 378 * maxhp : initial value for hp
369 * sp : 1 = open, 0 = close 379 * sp : 1 = open, 0 = close
370 */ 380 */
371void 381static void
372move_timed_gate (object *op) 382move_timed_gate (object *op)
373{ 383{
374 int v = op->value; 384 int v = op->value;
375 385
376 if (op->stats.sp) 386 if (op->stats.sp)
… …
395 * speed: frequency of 'glances' 405 * speed: frequency of 'glances'
396 * connected: connected value of detector 406 * connected: connected value of detector
397 * sp: 1 if detection sets buttons 407 * sp: 1 if detection sets buttons
398 * -1 if detection unsets buttons 408 * -1 if detection unsets buttons
399 */ 409 */
400 410static void
401void
402move_detector (object *op) 411move_detector (object *op)
403{ 412{
404 object *tmp; 413 object *tmp;
405 int last = op->value; 414 int last = op->value;
406 int detected; 415 int detected;
… …
433 if (op->stats.sp == 1) 442 if (op->stats.sp == 1)
434 { 443 {
435 if (detected && last == 0) 444 if (detected && last == 0)
436 { 445 {
437 op->value = 1; 446 op->value = 1;
438 push_button (op); 447 push_button (op, tmp);
439 } 448 }
440 449
441 if (!detected && last == 1) 450 if (!detected && last == 1)
442 { 451 {
443 op->value = 0; 452 op->value = 0;
444 push_button (op); 453 push_button (op, tmp);
445 } 454 }
446 } 455 }
447 else 456 else
448 { /* in this case, we unset buttons */ 457 { /* in this case, we unset buttons */
449 if (detected && last == 1) 458 if (detected && last == 1)
450 { 459 {
451 op->value = 0; 460 op->value = 0;
452 push_button (op); 461 push_button (op, tmp);
453 } 462 }
454 463
455 if (!detected && last == 0) 464 if (!detected && last == 0)
456 { 465 {
457 op->value = 1; 466 op->value = 1;
458 push_button (op); 467 push_button (op, tmp);
459 } 468 }
460 } 469 }
461} 470}
462 471
463void 472void
… …
473 SET_ANIMATION (op, op->stats.wc); 482 SET_ANIMATION (op, op->stats.wc);
474 update_object (op, UP_OBJ_FACE); 483 update_object (op, UP_OBJ_FACE);
475 } 484 }
476} 485}
477 486
478void 487static void
479move_hole (object *op) 488move_hole (object *op)
480{ /* 1 = opening, 0 = closing */ 489{ /* 1 = opening, 0 = closing */
481 object *next, *tmp;
482
483 if (op->value) 490 if (op->value)
484 { /* We're opening */ 491 { /* We're opening */
485 if (--op->stats.wc <= 0) 492 if (--op->stats.wc <= 0)
486 { /* Opened, let's stop */ 493 { /* Opened, let's stop */
487 op->stats.wc = 0; 494 op->stats.wc = 0;
488 op->set_speed (0); 495 op->set_speed (0);
489 496
490 /* Hard coding this makes sense for holes I suppose */ 497 /* Hard coding this makes sense for holes I suppose */
491 op->move_on = MOVE_WALK; 498 op->move_on = MOVE_WALK;
492 for (tmp = op->above; tmp != NULL; tmp = next) 499 for (object *next, *tmp = op->above; tmp; tmp = next)
493 { 500 {
494 next = tmp->above; 501 next = tmp->above;
495 move_apply (op, tmp, tmp); 502 move_apply (op, tmp, tmp);
496 } 503 }
497 } 504 }
… …
539 { 546 {
540 object *payload = op->inv; 547 object *payload = op->inv;
541 548
542 if (payload == NULL) 549 if (payload == NULL)
543 return NULL; 550 return NULL;
551
544 payload->remove (); 552 payload->remove ();
545 op->destroy (); 553 op->destroy ();
546 return payload; 554 return payload;
547 } 555 }
548 556
… …
565fix_stopped_item (object *op, maptile *map, object *originator) 573fix_stopped_item (object *op, maptile *map, object *originator)
566{ 574{
567 if (map == NULL) 575 if (map == NULL)
568 return; 576 return;
569 577
570 if (QUERY_FLAG (op, FLAG_REMOVED)) 578 if (op->flag [FLAG_REMOVED])
571 insert_ob_in_map (op, map, originator, 0); 579 insert_ob_in_map (op, map, originator, 0);
572 else if (op->type == ARROW) 580 else if (op->type == ARROW)
573 merge_ob (op, NULL); /* only some arrows actually need this */ 581 merge_ob (op, NULL); /* only some arrows actually need this */
574} 582}
575 583
… …
591 599
592 // restore original wc, dam, attacktype and slaying 600 // restore original wc, dam, attacktype and slaying
593 op->stats.wc = op->stats.sp; 601 op->stats.wc = op->stats.sp;
594 op->stats.dam = op->stats.hp; 602 op->stats.dam = op->stats.hp;
595 op->attacktype = op->stats.grace; 603 op->attacktype = op->stats.grace;
604 op->slaying = op->custom_name;
596 605
597 if (op->spellarg)
598 {
599 op->slaying = op->spellarg;
600 free (op->spellarg);
601 op->spellarg = 0;
602 }
603 else
604 op->slaying = 0;
605
606 /* Reset these to zero, so that object::can_merge will work properly */ 606 /* Reset these to defaults, so that object::can_merge will work properly */
607 op->spellarg = NULL; 607 op->custom_name = 0;
608 op->stats.sp = 0; 608 op->stats.sp = 0;
609 op->stats.hp = 0; 609 op->stats.hp = 0;
610 op->stats.grace = 0; 610 op->stats.grace = 0;
611 op->level = 0; 611 op->level = 0;
612 op->face = op->arch->face; 612 op->face = op->arch->face;
613 op->owner = NULL; /* So that stopped arrows will be saved */ 613 op->owner = 0;
614
614 update_object (op, UP_OBJ_CHANGE); 615 update_object (op, UP_OBJ_CHANGE);
616
615 return op; 617 return op;
616} 618}
617 619
618/* stop_arrow() - what to do when a non-living flying object 620/* stop_arrow() - what to do when a non-living flying object
619 * has to stop. Sept 96 - I added in thrown object code in 621 * has to stop. Sept 96 - I added in thrown object code in
… …
628 if (INVOKE_OBJECT (STOP, op)) 630 if (INVOKE_OBJECT (STOP, op))
629 return; 631 return;
630 632
631 if (op->inv) 633 if (op->inv)
632 { 634 {
635 // replace this by straightforward drop to ground?
633 object *payload = op->inv; 636 object *payload = op->inv;
634 637
635 payload->remove ();
636 payload->owner = 0; 638 payload->owner = 0;
637 insert_ob_in_map (payload, op->map, payload, 0); 639 insert_ob_in_map (payload, op->map, payload, 0);
638 op->destroy (); 640 op->destroy ();
639 } 641 }
640 else 642 else
… …
644 if (op) 646 if (op)
645 merge_ob (op, 0); 647 merge_ob (op, 0);
646 } 648 }
647} 649}
648 650
649/* Move an arrow along its course. op is the arrow or thrown object. 651/* Move an arrow or throwen_obj along its course. op is the arrow or thrown object.
650 */ 652 */
651void 653void
652move_arrow (object *op) 654move_arrow (object *op)
653{ 655{
654 int was_reflected; 656 int was_reflected;
… …
669 * is if the player throws a bomb - the bomb explodes on its own, 671 * is if the player throws a bomb - the bomb explodes on its own,
670 * but this object sticks around. We could handle the cleanup in the 672 * but this object sticks around. We could handle the cleanup in the
671 * bomb code, but there are potential other cases where that could happen, 673 * bomb code, but there are potential other cases where that could happen,
672 * and it is easy enough to clean it up here. 674 * and it is easy enough to clean it up here.
673 */ 675 */
674 if (op->inv == NULL) 676 if (!op->inv)
675 { 677 {
676 op->destroy (); 678 op->destroy ();
677 return; 679 return;
678 } 680 }
679 681
… …
682 stop_arrow (op); 684 stop_arrow (op);
683 return; 685 return;
684 } 686 }
685 } 687 }
686 688
689 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
690 * about 17 squares. Tune as needed.
691 */
692 op->speed -= 0.05;
693
687 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower 694 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower
688 values look rediculous. */ 695 values look rediculous. */
689 if (op->speed < 0.5 && op->type == ARROW) 696 if (op->speed < (op->type == ARROW ? 0.05 : MIN_ACTIVE_SPEED))
690 { 697 {
691 stop_arrow (op); 698 stop_arrow (op);
692 return; 699 return;
693 } 700 }
694 701
… …
707 if (pos->flags () & P_IS_ALIVE) 714 if (pos->flags () & P_IS_ALIVE)
708 { 715 {
709 object *tmp; 716 object *tmp;
710 717
711 for (tmp = pos->bot; tmp; tmp = tmp->above) 718 for (tmp = pos->bot; tmp; tmp = tmp->above)
712 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 719 if (tmp->flag [FLAG_ALIVE])
713 break; 720 break;
714 721
715 /* Not really fair, but don't let monsters hit themselves with 722 /* Not really fair, but don't let monsters hit themselves with
716 * their own arrow - this can be because they fire it then 723 * their own arrow - this can be because they fire it then
717 * move into it. 724 * move into it.
… …
720 { 727 {
721 /* Found living object, but it is reflecting the missile. Update 728 /* Found living object, but it is reflecting the missile. Update
722 * as below. (Note that for living creatures there is a small 729 * as below. (Note that for living creatures there is a small
723 * chance that reflect_missile fails.) 730 * chance that reflect_missile fails.)
724 */ 731 */
725 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 732 if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
726 { 733 {
727 int number = op->face; 734 int number = op->face;
728 735
729 op->direction = absdir (op->direction + 4); 736 op->direction = absdir (op->direction + 4);
730 update_turn_face (op); 737 update_turn_face (op);
… …
749 * note that this code will now catch cases where a monster is 756 * note that this code will now catch cases where a monster is
750 * on a wall but has reflecting - the arrow won't reflect. 757 * on a wall but has reflecting - the arrow won't reflect.
751 * Mapmakers shouldn't put monsters on top of wall in the first 758 * Mapmakers shouldn't put monsters on top of wall in the first
752 * place, so I don't consider that a problem. 759 * place, so I don't consider that a problem.
753 */ 760 */
754 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 761 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
755 { 762 {
756 stop_arrow (op); 763 stop_arrow (op);
757 return; 764 return;
758 } 765 }
759 else 766 else
… …
808 return; 815 return;
809 } 816 }
810 817
811 /* update object image for new facing */ 818 /* update object image for new facing */
812 /* many thrown objects *don't* have more than one face */ 819 /* many thrown objects *don't* have more than one face */
813 if (GET_ANIM_ID (op)) 820 if (op->has_anim ())
814 SET_ANIMATION (op, op->direction); 821 op->set_anim_frame (op->direction);
815 } /* object is reflected */ 822 } /* object is reflected */
816 } /* object ran into a wall */ 823 } /* object ran into a wall */
817 824
818 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
819 * about 17 squares. Tune as needed.
820 */
821 op->speed -= 0.05;
822
823 /* Move the arrow. */ 825 /* Move the arrow. */
824 op->move_to (pos); 826 op->move_to (pos);
825} 827}
826 828
827void 829static void
828change_object (object *op) 830change_object (object *op)
829{ /* Doesn`t handle linked objs yet */ 831{ /* Doesn`t handle linked objs yet */
830 int i, j;
831
832 if (!op->other_arch) 832 if (!op->other_arch)
833 { 833 {
834 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ()); 834 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
835 return; 835 return;
836 } 836 }
837 837
838 /* In non-living items only change when food value is 0 */ 838 /* In non-living items only change when food value is 0 */
839 if (!QUERY_FLAG (op, FLAG_ALIVE)) 839 if (!op->flag [FLAG_ALIVE])
840 { 840 {
841 if (op->stats.food-- > 0) 841 if (op->stats.food-- > 0)
842 return; 842 return;
843 843
844 op->stats.food = 1; /* so 1 other_arch is made */ 844 op->stats.food = 1; /* so 1 other_arch is made */
845 } 845 }
846 846
847 object *env = op->env; 847 object *env = op->env;
848 848
849 op->remove (); 849 op->remove ();
850 for (i = 0; i < op->stats.food; i++) 850 for (int i = 0; i < op->stats.food; i++)
851 { 851 {
852 object *tmp = arch_to_object (op->other_arch); 852 object *tmp = op->other_arch->instance ();
853
854 if (op->type == LAMP)
855 tmp->stats.food = op->stats.food - 1;
856 853
857 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 854 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
855
858 if (env) 856 if (env)
859 {
860 tmp = env->insert (tmp); 857 env->insert (tmp);
861
862 /* If this object is the players inventory, we need to tell the
863 * client of the change. Insert_ob_in_map takes care of the
864 * updating the client, so we don't need to do that below.
865 */
866 if (object *pl = op->in_player ())
867 {
868 esrv_del_item (pl->contr, op->count);
869 esrv_send_item (pl, tmp);
870 }
871 }
872 else 858 else
873 { 859 {
874 j = find_first_free_spot (tmp, op->map, op->x, op->y); 860 int j = find_first_free_spot (tmp, op->map, op->x, op->y);
861
875 if (j < 0) /* No free spot */ 862 if (j < 0) /* No free spot */
876 tmp->destroy (); 863 tmp->destroy ();
877 else 864 else
878 { 865 {
879 mapxy pos (op); pos.move (j); 866 mapxy pos (op); pos.move (j);
… …
904 891
905 if (op->head) 892 if (op->head)
906 head = op->head; 893 head = op->head;
907 894
908 for (tmp = op->above; tmp; tmp = tmp->above) 895 for (tmp = op->above; tmp; tmp = tmp->above)
909 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 896 if (!tmp->flag [FLAG_IS_FLOOR])
910 break; 897 break;
911 898
912 /* If nothing above us to move, nothing to do */ 899 /* If nothing above us to move, nothing to do */
913 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 900 if (!tmp || tmp->flag [FLAG_WIZPASS])
914 return; 901 return;
915 902
916 if (EXIT_PATH (head)) 903 if (EXIT_PATH (head))
917 { 904 {
918 if (tmp->type == PLAYER) 905 if (tmp->type == PLAYER)
… …
943 else 930 else
944 { 931 {
945 /* Random teleporter */ 932 /* Random teleporter */
946 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 933 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
947 return; 934 return;
935
948 teleport (head, TELEPORTER, tmp); 936 teleport (head, TELEPORTER, tmp);
949 } 937 }
950} 938}
951 939
952/* This object will teleport someone to a different map 940/* This object will teleport someone to a different map
953 and will also apply changes to the player from its inventory. 941 and will also apply changes to the player from its inventory.
954 This was invented for giving classes, but there's no reason it 942 This was invented for giving classes, but there's no reason it
955 can't be generalized. 943 can't be generalized.
956*/ 944*/
957void 945static void
958move_player_changer (object *op) 946move_player_changer (object *op)
959{ 947{
960 object *player;
961 object *walk;
962
963 if (!op->above || !EXIT_PATH (op)) 948 if (!op->above || !EXIT_PATH (op))
964 return; 949 return;
965 950
966 /* This isn't all that great - means that the player_mover 951 /* This isn't all that great - means that the player_mover
967 * needs to be on top. 952 * needs to be on top.
968 */ 953 */
969 if (op->above->type == PLAYER) 954 if (op->above->type == PLAYER)
970 { 955 {
956 object *player = op->above;
957
971 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 958 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
972 return; 959 return;
973 960
974 player = op->above;
975
976 for (walk = op->inv; walk; walk = walk->below) 961 for (object *walk = op->inv; walk; walk = walk->below)
977 apply_changes_to_player (player, walk); 962 apply_changes_to_player (player, walk);
978 963
979 player->update_stats (); 964 player->update_stats ();
980 965
981 esrv_send_inventory (op->above, op->above); 966 esrv_send_inventory (op->above, op->above);
… …
1028 * moves them in the op->stats.sp direction. speed is how often it'll move. 1013 * moves them in the op->stats.sp direction. speed is how often it'll move.
1029 * If attacktype is nonzero it will paralyze the player. If lifesave is set, 1014 * If attacktype is nonzero it will paralyze the player. If lifesave is set,
1030 * it'll dissapear after hp+1 moves. If hp is set and attacktype is set, 1015 * it'll dissapear after hp+1 moves. If hp is set and attacktype is set,
1031 * it'll paralyze the victim for hp*his speed/op->speed 1016 * it'll paralyze the victim for hp*his speed/op->speed
1032 */ 1017 */
1033void 1018static void
1034move_player_mover (object *op) 1019move_player_mover (object *op)
1035{ 1020{
1036 int dir = op->stats.sp; 1021 int dir = op->stats.sp;
1037 sint16 nx, ny; 1022 sint16 nx, ny;
1038 maptile *m; 1023 maptile *m;
… …
1041 if (!dir) 1026 if (!dir)
1042 dir = rndm (1, 8); 1027 dir = rndm (1, 8);
1043 1028
1044 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1029 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1045 { 1030 {
1046 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1031 if (victim->flag [FLAG_ALIVE] && !victim->flag [FLAG_WIZPASS] &&
1047 (victim->move_type & op->move_type || !victim->move_type)) 1032 (victim->move_type & op->move_type || !victim->move_type))
1048 { 1033 {
1049 1034
1050 if (victim->head) 1035 if (victim->head)
1051 victim = victim->head; 1036 victim = victim->head;
1052 1037
1053 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0) 1038 if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
1054 { 1039 {
1055 op->remove (); 1040 op->remove ();
1056 return; 1041 return;
1057 } 1042 }
1058 1043
… …
1071 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above) 1056 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1072 { 1057 {
1073 if (nextmover->type == PLAYERMOVER) 1058 if (nextmover->type == PLAYERMOVER)
1074 nextmover->speed_left = -.99f; 1059 nextmover->speed_left = -.99f;
1075 1060
1076 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1061 if (nextmover->flag [FLAG_ALIVE])
1077 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */ 1062 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1078 } 1063 }
1079 1064
1080 if (victim->type == PLAYER) 1065 if (victim->type == PLAYER)
1081 { 1066 {
1082 /* only level >=1 movers move people */ 1067 /* only level >=1 movers move people */
1083 if (op->level) 1068 if (op->level)
1084 { 1069 {
1085 /* Following is a bit of hack. We need to make sure it 1070 /* Following is a bit of hack. We need to make sure it
1086 * is cleared, otherwise the player will get stuck in 1071 * is cleared, otherwise the player will get stuck in
1087 * place. This can happen if the player used a spell to 1072 * place. This can happen if the player used a spell to
1088 * get to this space. 1073 * get to this space.
1089 */ 1074 */
1090 victim->contr->fire_on = 0; 1075 victim->contr->fire_on = 0;
1091 victim->speed_left = 1.f; 1076 victim->speed_left = 1.f;
1092 move_player (victim, dir); 1077 move_player (victim, dir);
1093 } 1078 }
1094 else 1079 else
1095 return; 1080 return;
1096 } 1081 }
1097 else 1082 else
1098 move_object (victim, dir); 1083 victim->move (dir);
1099 1084
1100 if (!op->stats.maxsp && op->attacktype) 1085 if (!op->stats.maxsp && op->attacktype)
1101 op->stats.maxsp = 2; 1086 op->stats.maxsp = 2;
1102 1087
1103 if (op->attacktype) 1088 if (op->attacktype)
1104 { /* flag to paralyze the player */ 1089 { /* flag to paralyze the player */
1105 victim->speed_left = max (-5.f, -FABS (op->stats.maxsp * victim->speed / op->speed)); 1090 victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1106 } 1091 }
1107 } 1092 }
1108 } 1093 }
1109} 1094}
1110 1095
… …
1166void 1151void
1167move_creator (object *creator) 1152move_creator (object *creator)
1168{ 1153{
1169 object *new_ob; 1154 object *new_ob;
1170 1155
1171 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1156 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1172 { 1157 {
1173 creator->stats.hp = -1; 1158 creator->stats.hp = -1;
1174 return; 1159 return;
1175 } 1160 }
1176 1161
1177 if (creator->inv != NULL) 1162 if (creator->inv)
1178 { 1163 {
1179 object *ob; 1164 object *ob;
1180 int i; 1165 int i;
1181 object *ob_to_copy; 1166 object *ob_to_copy;
1182 1167
… …
1187 if (rndm (0, i) == 0) 1172 if (rndm (0, i) == 0)
1188 { 1173 {
1189 ob_to_copy = ob; 1174 ob_to_copy = ob;
1190 } 1175 }
1191 } 1176 }
1192 new_ob = object_create_clone (ob_to_copy); 1177 new_ob = ob_to_copy->deep_clone ();
1193 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1178 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1194 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1179 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1195 } 1180 }
1196 else 1181 else
1197 { 1182 {
1198 if (creator->other_arch == NULL) 1183 if (!creator->other_arch)
1199 { 1184 {
1200 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n", 1185 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1201 &creator->name, &creator->map->path, creator->x, creator->y); 1186 &creator->name, &creator->map->path, creator->x, creator->y);
1202 return; 1187 return;
1203 } 1188 }
… …
1213 return; 1198 return;
1214 } 1199 }
1215 1200
1216 // for now lets try to identify everything generated here, it mostly 1201 // for now lets try to identify everything generated here, it mostly
1217 // happens automated, so this will at least fix many identify-experience holes 1202 // happens automated, so this will at least fix many identify-experience holes
1218 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1203 new_ob->set_flag (FLAG_IDENTIFIED);
1219 1204
1220 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y); 1205 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1221 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1206 if (new_ob->flag [FLAG_FREED])
1222 return; 1207 return;
1223 1208
1224 if (creator->slaying) 1209 if (creator->slaying)
1225 {
1226 new_ob->name = new_ob->title = creator->slaying; 1210 new_ob->name = new_ob->title = creator->slaying;
1227 }
1228} 1211}
1229 1212
1230/* move_marker --peterm@soda.csua.berkeley.edu 1213/* move_marker --peterm@soda.csua.berkeley.edu
1231 when moved, a marker will search for a player sitting above 1214 when moved, a marker will search for a player sitting above
1232 it, and insert an invisible, weightless force into him 1215 it, and insert an invisible, weightless force into him
… …
1242 { 1225 {
1243 /* remove an old force with a slaying field == op->name */ 1226 /* remove an old force with a slaying field == op->name */
1244 if (object *force = tmp->force_find (op->name)) 1227 if (object *force = tmp->force_find (op->name))
1245 force->destroy (); 1228 force->destroy ();
1246 1229
1247 if (!tmp->force_find (op->slaying)) 1230 if (op->slaying && !tmp->force_find (op->slaying))
1248 { 1231 {
1249 tmp->force_add (op->slaying, op->stats.food); 1232 tmp->force_add (op->slaying, op->stats.food);
1250 1233
1251 if (op->msg) 1234 if (op->msg)
1252 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg); 1235 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
… …
1264 } 1247 }
1265 } 1248 }
1266 } 1249 }
1267} 1250}
1268 1251
1252// mapscript objects activate themselves (only) then their timer fires
1253// TODO: maybe they should simply trigger the link like any other object?
1254static void
1255move_mapscript (object *op)
1256{
1257 op->set_speed (0);
1258 cfperl_mapscript_activate (op, true, op, 0);
1259}
1260
1261static void
1262move_lamp (object *op)
1263{
1264 // if the lamp/torch is off, we should disable it.
1265 if (!op->glow_radius)
1266 {
1267 op->set_speed (0);
1268 return;
1269 }
1270 else
1271 {
1272 // check whether the face might need to be updated
1273 // (currently this is needed to have already switched on torches
1274 // on maps, as they just set the glow_radius in the archetype)
1275 if (op->other_arch
1276 && (
1277 (op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
1278 || (op->flag [FLAG_ANIMATE]
1279 ? (op->animation_id != op->other_arch->animation_id)
1280 : (op->face != op->other_arch->face))
1281 ))
1282 get_animation_from_arch (op, op->other_arch);
1283 }
1284
1285 // lamps and torches on maps don't use up their fuel
1286 if (op->is_on_map ())
1287 return;
1288
1289 if (op->stats.food > 0)
1290 {
1291 op->stats.food--;
1292 return;
1293 }
1294
1295 apply_lamp (op, false);
1296}
1297
1269void 1298void
1270process_object (object *op) 1299process_object (object *op)
1271{ 1300{
1272 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1301 if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1273 return; 1302 return;
1274 1303
1275 if (expect_false (INVOKE_OBJECT (TICK, op))) 1304 if (expect_false (INVOKE_OBJECT (TICK, op)))
1276 return; 1305 return;
1277 1306
1278 if (QUERY_FLAG (op, FLAG_MONSTER)) 1307 if (op->flag [FLAG_MONSTER])
1279 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1308 if (move_monster (op) || op->flag [FLAG_FREED])
1280 return; 1309 return;
1281 1310
1282 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1311 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1283 { 1312 {
1284 animate_object (op, op->contr ? op->facing : op->direction); 1313 animate_object (op, op->contr ? op->facing : op->direction);
1285 1314
1286 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1315 if (op->flag [FLAG_SEE_ANYWHERE])
1287 make_sure_seen (op); 1316 make_sure_seen (op);
1288 } 1317 }
1289 1318
1290 if (expect_false ( 1319 if (expect_false (
1291 op->flag [FLAG_GENERATOR] 1320 op->flag [FLAG_GENERATOR]
1292 || op->flag [FLAG_CHANGING] 1321 || op->flag [FLAG_CHANGING]
1293 || op->flag [FLAG_IS_USED_UP] 1322 || op->flag [FLAG_IS_USED_UP]
1294 )) 1323 ))
1295 { 1324 {
1296 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1325 if (op->flag [FLAG_CHANGING] && !op->state)
1297 { 1326 {
1298 change_object (op); 1327 change_object (op);
1299 return; 1328 return;
1300 } 1329 }
1301 1330
1302 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1331 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1303 generate_monster (op); 1332 generate_monster (op);
1304 1333
1305 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1334 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1306 { 1335 {
1307 if (QUERY_FLAG (op, FLAG_APPLIED)) 1336 if (op->flag [FLAG_APPLIED])
1308 remove_force (op); 1337 remove_force (op);
1309 else 1338 else
1310 { 1339 {
1311 /* If necessary, delete the item from the players inventory */ 1340 op->remove (); // TODO: really necessary?
1312 if (object *pl = op->in_player ())
1313 esrv_del_item (pl->contr, op->count);
1314 1341
1315 op->remove ();
1316
1317 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1342 if (op->flag [FLAG_SEE_ANYWHERE])
1318 make_sure_not_seen (op); 1343 make_sure_not_seen (op);
1319 1344
1320 op->destroy (); 1345 op->drop_and_destroy ();
1321 } 1346 }
1322 1347
1323 return; 1348 return;
1324 } 1349 }
1325 } 1350 }
… …
1449 1474
1450 case PLAYER: 1475 case PLAYER:
1451 // players have their own speed-management, so undo the --speed_left 1476 // players have their own speed-management, so undo the --speed_left
1452 ++op->speed_left; 1477 ++op->speed_left;
1453 break; 1478 break;
1454 }
1455}
1456 1479
1480 case MAPSCRIPT:
1481 move_mapscript (op);
1482 break;
1483
1484 case LAMP:
1485 case TORCH:
1486 move_lamp (op);
1487 break;
1488 }
1489}
1490

Diff Legend

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