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.13 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.35 by root, Tue Jan 9 01:28:32 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 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,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
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.
27 */ 28 */
28
29#include <global.h> 29#include <global.h>
30#include <spells.h> 30#include <spells.h>
31#ifndef __CEXTRACT__
32# include <sproto.h> 31#include <sproto.h>
33#endif
34 32
35/* The following removes doors. The functions check to see if similar 33/* The following removes doors. The functions check to see if similar
36 * doors are next to the one that is being removed, and if so, set it 34 * doors are next to the one that is being removed, and if so, set it
37 * so those will be removed shortly (in a cascade like fashion.) 35 * so those will be removed shortly (in a cascade like fashion.)
38 */ 36 */
39
40void 37void
41remove_door (object *op) 38remove_door (object *op)
42{ 39{
43 int i; 40 int i;
44 object *tmp; 41 object *tmp;
45 42
46 for (i = 1; i < 9; i += 2) 43 for (i = 1; i < 9; i += 2)
47 if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL) 44 if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL)
48 { 45 {
49 tmp->speed = 0.1; 46 tmp->set_speed (0.1);
50 update_ob_speed (tmp);
51 tmp->speed_left = -0.2; 47 tmp->speed_left = -0.2;
52 } 48 }
53 49
54 if (op->other_arch) 50 if (op->other_arch)
55 { 51 {
… …
58 tmp->y = op->y; 54 tmp->y = op->y;
59 tmp->map = op->map; 55 tmp->map = op->map;
60 tmp->level = op->level; 56 tmp->level = op->level;
61 insert_ob_in_map (tmp, op->map, op, 0); 57 insert_ob_in_map (tmp, op->map, op, 0);
62 } 58 }
63 remove_ob (op); 59
64 free_object (op); 60 op->destroy ();
65} 61}
66 62
67void 63void
68remove_door2 (object *op) 64remove_door2 (object *op)
69{ 65{
… …
73 for (i = 1; i < 9; i += 2) 69 for (i = 1; i < 9; i += 2)
74 { 70 {
75 tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]); 71 tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);
76 if (tmp && tmp->slaying == op->slaying) 72 if (tmp && tmp->slaying == op->slaying)
77 { /* same key both doors */ 73 { /* same key both doors */
78 tmp->speed = 0.1; 74 tmp->set_speed (0.1);
79 update_ob_speed (tmp);
80 tmp->speed_left = -0.2; 75 tmp->speed_left = -0.2;
81 } 76 }
82 } 77 }
78
83 if (op->other_arch) 79 if (op->other_arch)
84 { 80 {
85 tmp = arch_to_object (op->other_arch); 81 tmp = arch_to_object (op->other_arch);
86 tmp->x = op->x; 82 tmp->x = op->x;
87 tmp->y = op->y; 83 tmp->y = op->y;
88 tmp->map = op->map; 84 tmp->map = op->map;
89 tmp->level = op->level; 85 tmp->level = op->level;
90 insert_ob_in_map (tmp, op->map, op, 0); 86 insert_ob_in_map (tmp, op->map, op, 0);
91 } 87 }
92 remove_ob (op); 88
93 free_object (op); 89 op->destroy ();
94} 90}
95 91
96/* Will generate a monster according to content 92/* Will generate a monster according to content
97 * of generator. 93 * of generator.
98 */ 94 */
… …
133 if (rndm (0, 9)) 129 if (rndm (0, 9))
134 generate_artifact (head, gen->map->difficulty); 130 generate_artifact (head, gen->map->difficulty);
135 insert_ob_in_map_at (head, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]); 131 insert_ob_in_map_at (head, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]);
136 if (QUERY_FLAG (head, FLAG_FREED)) 132 if (QUERY_FLAG (head, FLAG_FREED))
137 return; 133 return;
138 if (HAS_RANDOM_ITEMS (head)) 134 if (head->has_random_items ())
139 create_treasure (head->randomitems, head, GT_APPLY, gen->map->difficulty, 0); 135 create_treasure (head->randomitems, head, GT_APPLY, gen->map->difficulty, 0);
140} 136}
141 137
142void 138void
143generate_monster_arch (object *gen) 139generate_monster_arch (object *gen)
144{ 140{
145 int i; 141 int i;
146 object *op, *head = NULL, *prev = NULL; 142 object *op, *head = NULL, *prev = NULL;
147 archetype *at = gen->other_arch; 143 archetype *at = gen->other_arch;
148 144
149 if (gen->other_arch == NULL) 145 if (!gen->other_arch)
150 {
151 //LOG(llevError,"Generator without other_arch: %s\n",gen->name);
152 return; 146 return;
153 } 147
154 /* Code below assumes the generator is on a map, as it tries 148 /* Code below assumes the generator is on a map, as it tries
155 * to place the monster on the map. So if the generator 149 * to place the monster on the map. So if the generator
156 * isn't on a map, complain and exit. 150 * isn't on a map, complain and exit.
157 */ 151 */
158 if (gen->map == NULL) 152 if (!gen->map)
159 {
160 //LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
161 return; 153 return;
162 } 154
163 i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9); 155 i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9);
164 if (i == -1) 156 if (i == -1)
165 return; 157 return;
158
166 while (at != NULL) 159 while (at)
167 { 160 {
168 op = arch_to_object (at); 161 op = arch_to_object (at);
169 op->x = gen->x + freearr_x[i] + at->clone.x; 162 op->x = gen->x + freearr_x[i] + at->clone.x;
170 op->y = gen->y + freearr_y[i] + at->clone.y; 163 op->y = gen->y + freearr_y[i] + at->clone.y;
171 164
172 if (head != NULL) 165 if (head)
173 op->head = head, prev->more = op; 166 op->head = head, prev->more = op;
174 167
175 if (rndm (0, 9)) 168 if (rndm (0, 9))
176 generate_artifact (op, gen->map->difficulty); 169 generate_artifact (op, gen->map->difficulty);
170
177 insert_ob_in_map (op, gen->map, gen, 0); 171 insert_ob_in_map (op, gen->map, gen, 0);
178 if (QUERY_FLAG (op, FLAG_FREED)) 172 if (QUERY_FLAG (op, FLAG_FREED))
179 return; 173 return;
180 if (HAS_RANDOM_ITEMS (op)) 174
175 if (op->has_random_items ())
181 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0); 176 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0);
177
182 if (head == NULL) 178 if (head == NULL)
183 head = op; 179 head = op;
180
184 prev = op; 181 prev = op;
185 at = at->more; 182 at = at->more;
186 } 183 }
187} 184}
188 185
… …
190generate_monster (object *gen) 187generate_monster (object *gen)
191{ 188{
192 189
193 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1)) 190 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
194 return; 191 return;
192
195 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 193 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
196 generate_monster_inv (gen); 194 generate_monster_inv (gen);
197 else 195 else
198 generate_monster_arch (gen); 196 generate_monster_arch (gen);
199 197
… …
203remove_force (object *op) 201remove_force (object *op)
204{ 202{
205 if (--op->duration > 0) 203 if (--op->duration > 0)
206 return; 204 return;
207 205
206 if (op->env)
208 switch (op->subtype) 207 switch (op->subtype)
209 { 208 {
210 case FORCE_CONFUSION: 209 case FORCE_CONFUSION:
211 if (op->env != NULL)
212 {
213 CLEAR_FLAG (op->env, FLAG_CONFUSED); 210 CLEAR_FLAG (op->env, FLAG_CONFUSED);
214 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n"); 211 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
215 }
216 212
217 default: 213 default:
218 if (op->env != NULL)
219 {
220 CLEAR_FLAG (op, FLAG_APPLIED); 214 CLEAR_FLAG (op, FLAG_APPLIED);
221 change_abil (op->env, op); 215 change_abil (op->env, op);
222 fix_player (op->env); 216 op->env->update_stats ();
223 }
224 } 217 }
225 remove_ob (op); 218
226 free_object (op); 219 op->destroy ();
227} 220}
228 221
229void 222void
230remove_blindness (object *op) 223remove_blindness (object *op)
231{ 224{
232 if (--op->stats.food > 0) 225 if (--op->stats.food > 0)
233 return; 226 return;
227
234 CLEAR_FLAG (op, FLAG_APPLIED); 228 CLEAR_FLAG (op, FLAG_APPLIED);
229
235 if (op->env != NULL) 230 if (op->env)
236 { 231 {
237 change_abil (op->env, op); 232 change_abil (op->env, op);
238 fix_player (op->env); 233 op->env->update_stats ();
239 } 234 }
240 remove_ob (op); 235
241 free_object (op); 236 op->destroy ();
242} 237}
243 238
244void 239void
245poison_more (object *op) 240poison_more (object *op)
246{ 241{
247 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0) 242 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0)
248 { 243 {
249 remove_ob (op); 244 op->destroy ();
250 free_object (op);
251 return; 245 return;
252 } 246 }
247
253 if (op->stats.food == 1) 248 if (op->stats.food == 1)
254 { 249 {
255 /* need to remove the object before fix_player is called, else fix_player 250 /* need to remove the object before fix_player is called, else fix_player
256 * will not do anything. 251 * will not do anything.
257 */ 252 */
258 if (op->env->type == PLAYER) 253 if (op->env->type == PLAYER)
259 { 254 {
260 CLEAR_FLAG (op, FLAG_APPLIED); 255 CLEAR_FLAG (op, FLAG_APPLIED);
261 fix_player (op->env); 256 op->env->update_stats ();
262 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now."); 257 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
263 } 258 }
264 remove_ob (op); 259
265 free_object (op); 260 op->destroy ();
266 return; 261 return;
267 } 262 }
263
268 if (op->env->type == PLAYER) 264 if (op->env->type == PLAYER)
269 { 265 {
270 op->env->stats.food--; 266 op->env->stats.food--;
271 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick..."); 267 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick...");
272 } 268 }
269
273 (void) hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 270 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
274} 271}
275 272
276 273
277void 274void
278move_gate (object *op) 275move_gate (object *op)
… …
280 object *tmp; 277 object *tmp;
281 278
282 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 279 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
283 { 280 {
284 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op)); 281 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op));
285 dump_object (op);
286 LOG (llevError, "%s\n", errmsg);
287 op->stats.wc = 0; 282 op->stats.wc = 0;
288 } 283 }
289 284
290 /* We're going down */ 285 /* We're going down */
291 if (op->value) 286 if (op->value)
… …
294 { /* Reached bottom, let's stop */ 289 { /* Reached bottom, let's stop */
295 op->stats.wc = 0; 290 op->stats.wc = 0;
296 if (op->arch->clone.speed) 291 if (op->arch->clone.speed)
297 op->value = 0; 292 op->value = 0;
298 else 293 else
299 {
300 op->speed = 0; 294 op->set_speed (0);
301 update_ob_speed (op);
302 } 295 }
303 } 296
304 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 297 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
305 { 298 {
306 op->move_block = 0; 299 op->move_block = 0;
307 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 300 CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
308 update_all_los (op->map, op->x, op->y); 301 update_all_los (op->map, op->x, op->y);
309 } 302 }
303
310 SET_ANIMATION (op, op->stats.wc); 304 SET_ANIMATION (op, op->stats.wc);
311 update_object (op, UP_OBJ_CHANGE); 305 update_object (op, UP_OBJ_CHANGE);
312 return; 306 return;
313 } 307 }
314 308
… …
331 if (tmp == NULL) 325 if (tmp == NULL)
332 { 326 {
333 if (op->arch->clone.speed) 327 if (op->arch->clone.speed)
334 op->value = 1; 328 op->value = 1;
335 else 329 else
336 {
337 op->speed = 0; 330 op->set_speed (0);
338 update_ob_speed (op); /* Reached top, let's stop */ 331
339 }
340 return; 332 return;
341 } 333 }
342 } 334 }
343 335
344 if (op->stats.food) 336 if (op->stats.food)
… …
384 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9); 376 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
385 377
386 /* If there is a free spot, move the object someplace */ 378 /* If there is a free spot, move the object someplace */
387 if (i != -1) 379 if (i != -1)
388 { 380 {
389 remove_ob (tmp); 381 tmp->remove ();
390 tmp->x += freearr_x[i], tmp->y += freearr_y[i]; 382 tmp->x += freearr_x[i], tmp->y += freearr_y[i];
391 insert_ob_in_map (tmp, op->map, op, 0); 383 insert_ob_in_map (tmp, op->map, op, 0);
392 } 384 }
393 } 385 }
394 } 386 }
… …
435 } 427 }
436 if (--op->stats.hp <= 0) 428 if (--op->stats.hp <= 0)
437 { /* keep gate down */ 429 { /* keep gate down */
438 move_gate (op); 430 move_gate (op);
439 if (op->value != v) 431 if (op->value != v)
440 { /* ready ? */
441 op->speed = 0; 432 op->set_speed (0);
442 update_ob_speed (op);
443 }
444 } 433 }
445} 434}
446 435
447/* slaying: name of the thing the detector is to look for 436/* slaying: name of the thing the detector is to look for
448 * speed: frequency of 'glances' 437 * speed: frequency of 'glances'
… …
458 int last = op->value; 447 int last = op->value;
459 int detected; 448 int detected;
460 449
461 detected = 0; 450 detected = 0;
462 451
463 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above) 452 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above)
464 { 453 {
465 object *tmp2; 454 object *tmp2;
466 455
467 if (op->stats.hp) 456 if (op->stats.hp)
468 { 457 {
… …
535 if (op->value) 524 if (op->value)
536 { /* We're opening */ 525 { /* We're opening */
537 if (--op->stats.wc <= 0) 526 if (--op->stats.wc <= 0)
538 { /* Opened, let's stop */ 527 { /* Opened, let's stop */
539 op->stats.wc = 0; 528 op->stats.wc = 0;
540 op->speed = 0; 529 op->set_speed (0);
541 update_ob_speed (op);
542 530
543 /* Hard coding this makes sense for holes I suppose */ 531 /* Hard coding this makes sense for holes I suppose */
544 op->move_on = MOVE_WALK; 532 op->move_on = MOVE_WALK;
545 for (tmp = op->above; tmp != NULL; tmp = next) 533 for (tmp = op->above; tmp != NULL; tmp = next)
546 { 534 {
547 next = tmp->above; 535 next = tmp->above;
548 move_apply (op, tmp, tmp); 536 move_apply (op, tmp, tmp);
549 } 537 }
550 } 538 }
539
551 SET_ANIMATION (op, op->stats.wc); 540 SET_ANIMATION (op, op->stats.wc);
552 update_object (op, UP_OBJ_FACE); 541 update_object (op, UP_OBJ_FACE);
553 return; 542 return;
554 } 543 }
555 /* We're closing */ 544 /* We're closing */
556 op->move_on = 0; 545 op->move_on = 0;
557 546
558 op->stats.wc++; 547 op->stats.wc++;
559 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 548 if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
560 op->stats.wc = NUM_ANIMATIONS (op) - 1; 549 op->stats.wc = NUM_ANIMATIONS (op) - 1;
550
561 SET_ANIMATION (op, op->stats.wc); 551 SET_ANIMATION (op, op->stats.wc);
562 update_object (op, UP_OBJ_FACE); 552 update_object (op, UP_OBJ_FACE);
563 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 553 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
564 {
565 op->speed = 0;
566 update_ob_speed (op); /* closed, let's stop */ 554 op->set_speed (0); /* closed, let's stop */
567 return;
568 }
569} 555}
570 556
571 557
572/* stop_item() returns a pointer to the stopped object. The stopped object 558/* stop_item() returns a pointer to the stopped object. The stopped object
573 * may or may not have been removed from maps or inventories. It will not 559 * may or may not have been removed from maps or inventories. It will not
… …
593 { 579 {
594 object *payload = op->inv; 580 object *payload = op->inv;
595 581
596 if (payload == NULL) 582 if (payload == NULL)
597 return NULL; 583 return NULL;
598 remove_ob (payload); 584 payload->remove ();
599 remove_ob (op); 585 op->destroy ();
600 free_object (op);
601 return payload; 586 return payload;
602 } 587 }
603 588
604 case ARROW: 589 case ARROW:
605 if (op->speed >= MIN_ACTIVE_SPEED) 590 if (op->has_active_speed ())
606 op = fix_stopped_arrow (op); 591 op = fix_stopped_arrow (op);
607 return op; 592 return op;
608 593
609 default: 594 default:
610 return op; 595 return op;
… …
632fix_stopped_arrow (object *op) 617fix_stopped_arrow (object *op)
633{ 618{
634 if (rndm (0, 99) < op->stats.food) 619 if (rndm (0, 99) < op->stats.food)
635 { 620 {
636 /* Small chance of breaking */ 621 /* Small chance of breaking */
637 remove_ob (op); 622 op->destroy ();
638 free_object (op);
639 return NULL; 623 return NULL;
640 } 624 }
641 625
626 op->set_speed (0);
642 op->direction = 0; 627 op->direction = 0;
643 op->move_on = 0; 628 op->move_on = 0;
644 op->move_type = 0; 629 op->move_type = 0;
645 op->speed = 0;
646 update_ob_speed (op);
647 op->stats.wc = op->stats.sp; 630 op->stats.wc = op->stats.sp;
648 op->stats.dam = op->stats.hp; 631 op->stats.dam = op->stats.hp;
649 op->attacktype = op->stats.grace; 632 op->attacktype = op->stats.grace;
650 op->slaying = 0; 633 op->slaying = 0;
651 op->skill = 0; 634 op->skill = 0;
… …
657 op->spellarg = NULL; 640 op->spellarg = NULL;
658 } 641 }
659 else 642 else
660 op->slaying = NULL; 643 op->slaying = NULL;
661 644
662 /* Reset these to zero, so that CAN_MERGE will work properly */ 645 /* Reset these to zero, so that object::can_merge will work properly */
663 op->spellarg = NULL; 646 op->spellarg = NULL;
664 op->stats.sp = 0; 647 op->stats.sp = 0;
665 op->stats.hp = 0; 648 op->stats.hp = 0;
666 op->stats.grace = 0; 649 op->stats.grace = 0;
667 op->level = 0; 650 op->level = 0;
… …
676 * here too. -b.t. 659 * here too. -b.t.
677 * 660 *
678 * Returns a pointer to the stopped object (which will have been removed 661 * Returns a pointer to the stopped object (which will have been removed
679 * from maps or inventories), or NULL if was destroyed. 662 * from maps or inventories), or NULL if was destroyed.
680 */ 663 */
681
682static void 664static void
683stop_arrow (object *op) 665stop_arrow (object *op)
684{ 666{
685 if (INVOKE_OBJECT (STOP, op)) 667 if (INVOKE_OBJECT (STOP, op))
686 return; 668 return;
687 669
688 if (op->inv) 670 if (op->inv)
689 { 671 {
690 object *payload = op->inv; 672 object *payload = op->inv;
691 673
692 remove_ob (payload); 674 payload->remove ();
693 clear_owner (payload); 675 payload->owner = 0;
694 insert_ob_in_map (payload, op->map, payload, 0); 676 insert_ob_in_map (payload, op->map, payload, 0);
695 remove_ob (op); 677 op->destroy ();
696 free_object (op);
697 } 678 }
698 else 679 else
699 { 680 {
700 op = fix_stopped_arrow (op); 681 op = fix_stopped_arrow (op);
701 if (op) 682 if (op)
… …
715 maptile *m; 696 maptile *m;
716 697
717 if (op->map == NULL) 698 if (op->map == NULL)
718 { 699 {
719 LOG (llevError, "BUG: Arrow had no map.\n"); 700 LOG (llevError, "BUG: Arrow had no map.\n");
720 remove_ob (op); 701 op->destroy ();
721 free_object (op);
722 return; 702 return;
723 } 703 }
724 704
725 /* we need to stop thrown objects at some point. Like here. */ 705 /* we need to stop thrown objects at some point. Like here. */
726 if (op->type == THROWN_OBJ) 706 if (op->type == THROWN_OBJ)
… …
733 * bomb code, but there are potential other cases where that could happen, 713 * bomb code, but there are potential other cases where that could happen,
734 * and it is easy enough to clean it up here. 714 * and it is easy enough to clean it up here.
735 */ 715 */
736 if (op->inv == NULL) 716 if (op->inv == NULL)
737 { 717 {
738 remove_ob (op); 718 op->destroy ();
739 free_object (op);
740 return; 719 return;
741 } 720 }
721
742 if (op->last_sp-- < 0) 722 if (op->last_sp-- < 0)
743 { 723 {
744 stop_arrow (op); 724 stop_arrow (op);
745 return; 725 return;
746 } 726 }
… …
769 } 749 }
770 750
771 /* only need to look for living creatures if this flag is set */ 751 /* only need to look for living creatures if this flag is set */
772 if (mflags & P_IS_ALIVE) 752 if (mflags & P_IS_ALIVE)
773 { 753 {
774 for (tmp = get_map_ob (m, new_x, new_y); tmp != NULL; tmp = tmp->above) 754 for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above)
775 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 755 if (QUERY_FLAG (tmp, FLAG_ALIVE))
776 break; 756 break;
777
778 757
779 /* Not really fair, but don't let monsters hit themselves with 758 /* Not really fair, but don't let monsters hit themselves with
780 * their own arrow - this can be because they fire it then 759 * their own arrow - this can be because they fire it then
781 * move into it. 760 * move into it.
782 */ 761 */
783
784 if (tmp != NULL && tmp != op->owner) 762 if (tmp && tmp != op->owner)
785 { 763 {
786 /* Found living object, but it is reflecting the missile. Update 764 /* Found living object, but it is reflecting the missile. Update
787 * as below. (Note that for living creatures there is a small 765 * as below. (Note that for living creatures there is a small
788 * chance that reflect_missile fails.) 766 * chance that reflect_missile fails.)
789 */ 767 */
790
791 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 768 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10))
792 { 769 {
793
794 int number = op->face->number; 770 int number = op->face->number;
795 771
796 op->direction = absdir (op->direction + 4); 772 op->direction = absdir (op->direction + 4);
797 op->state = 0; 773 op->state = 0;
774
798 if (GET_ANIM_ID (op)) 775 if (GET_ANIM_ID (op))
799 { 776 {
800 number += 4; 777 number += 4;
778
801 if (number > GET_ANIMATION (op, 8)) 779 if (number > GET_ANIMATION (op, 8))
802 number -= 8; 780 number -= 8;
781
803 op->face = &new_faces[number]; 782 op->face = &new_faces[number];
804 } 783 }
784
805 was_reflected = 1; /* skip normal movement calculations */ 785 was_reflected = 1; /* skip normal movement calculations */
806 } 786 }
807 else 787 else
808 { 788 {
809 /* Attack the object. */ 789 /* Attack the object. */
810 op = hit_with_arrow (op, tmp); 790 op = hit_with_arrow (op, tmp);
791
811 if (op == NULL) 792 if (!op)
812 return; 793 return;
813 } 794 }
814 } /* if this is not hitting its owner */ 795 } /* if this is not hitting its owner */
815 } /* if there is something alive on this space */ 796 } /* if there is something alive on this space */
816
817 797
818 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 798 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
819 { 799 {
820 int retry = 0; 800 int retry = 0;
821 801
… …
893 SET_ANIMATION (op, op->direction); 873 SET_ANIMATION (op, op->direction);
894 } /* object is reflected */ 874 } /* object is reflected */
895 } /* object ran into a wall */ 875 } /* object ran into a wall */
896 876
897 /* Move the arrow. */ 877 /* Move the arrow. */
898 remove_ob (op); 878 op->remove ();
899 op->x = new_x; 879 op->x = new_x;
900 op->y = new_y; 880 op->y = new_y;
901 881
902 /* decrease the speed as it flies. 0.05 means a standard bow will shoot 882 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
903 * about 17 squares. Tune as needed. 883 * about 17 squares. Tune as needed.
… …
911 * Modified this routine to allow held objects. b.t. */ 891 * Modified this routine to allow held objects. b.t. */
912 892
913void 893void
914change_object (object *op) 894change_object (object *op)
915{ /* Doesn`t handle linked objs yet */ 895{ /* Doesn`t handle linked objs yet */
916 object *tmp, *env, *pl;
917 int i, j; 896 int i, j;
918 897
919 if (op->other_arch == NULL) 898 if (op->other_arch == NULL)
920 { 899 {
921 LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name); 900 LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name);
… …
928 if (op->stats.food-- > 0) 907 if (op->stats.food-- > 0)
929 return; 908 return;
930 else 909 else
931 op->stats.food = 1; /* so 1 other_arch is made */ 910 op->stats.food = 1; /* so 1 other_arch is made */
932 } 911 }
912
913 object *pl = op->in_player ();
933 env = op->env; 914 object *env = op->env;
934 remove_ob (op); 915
916 op->remove ();
935 for (i = 0; i < NROFNEWOBJS (op); i++) 917 for (i = 0; i < NROFNEWOBJS (op); i++)
936 { 918 {
937 tmp = arch_to_object (op->other_arch); 919 object *tmp = arch_to_object (op->other_arch);
920
938 if (op->type == LAMP) 921 if (op->type == LAMP)
939 tmp->stats.food = op->stats.food - 1; 922 tmp->stats.food = op->stats.food - 1;
923
940 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 924 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
941 if (env) 925 if (env)
942 { 926 {
943 tmp->x = env->x, tmp->y = env->y; 927 tmp->x = env->x, tmp->y = env->y;
944 tmp = insert_ob_in_ob (tmp, env); 928 tmp = insert_ob_in_ob (tmp, env);
929
945 /* If this object is the players inventory, we need to tell the 930 /* If this object is the players inventory, we need to tell the
946 * client of the change. Insert_ob_in_map takes care of the 931 * client of the change. Insert_ob_in_map takes care of the
947 * updating the client, so we don't need to do that below. 932 * updating the client, so we don't need to do that below.
948 */ 933 */
949 if ((pl = is_player_inv (env)) != NULL) 934 if (pl)
950 { 935 {
951 esrv_del_item (pl->contr, op->count); 936 esrv_del_item (pl->contr, op->count);
952 esrv_send_item (pl, tmp); 937 esrv_send_item (pl, tmp);
953 } 938 }
954 } 939 }
955 else 940 else
956 { 941 {
957 j = find_first_free_spot (tmp, op->map, op->x, op->y); 942 j = find_first_free_spot (tmp, op->map, op->x, op->y);
958 if (j == -1) /* No free spot */ 943 if (j == -1) /* No free spot */
959 free_object (tmp); 944 tmp->destroy ();
960 else 945 else
961 { 946 {
962 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j]; 947 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];
963 insert_ob_in_map (tmp, op->map, op, 0); 948 insert_ob_in_map (tmp, op->map, op, 0);
964 } 949 }
965 } 950 }
966 } 951 }
967 free_object (op); 952
953 op->destroy ();
968} 954}
969 955
970void 956void
971move_teleporter (object *op) 957move_teleporter (object *op)
972{ 958{
… …
977 * there is an old multipart teleporter in which the other parts 963 * there is an old multipart teleporter in which the other parts
978 * have speed, we don't really want to call it twice for the same 964 * have speed, we don't really want to call it twice for the same
979 * function - in fact, as written below, part N would get called 965 * function - in fact, as written below, part N would get called
980 * N times without the speed check. 966 * N times without the speed check.
981 */ 967 */
982 if (op->more && FABS (op->more->speed) < MIN_ACTIVE_SPEED) 968 if (op->more && !op->more->has_active_speed ())
983 move_teleporter (op->more); 969 move_teleporter (op->more);
984 970
985 if (op->head) 971 if (op->head)
986 head = op->head; 972 head = op->head;
987 973
… …
998 if (tmp->type == PLAYER) 984 if (tmp->type == PLAYER)
999 { 985 {
1000 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 986 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1001 return; 987 return;
1002 988
1003 enter_exit (tmp, head); 989 tmp->enter_exit (head);
1004 } 990 }
1005 else 991 else
1006 /* Currently only players can transfer maps */ 992 /* Currently only players can transfer maps */
1007 return; 993 return;
1008 } 994 }
1009 else if (EXIT_X (head) || EXIT_Y (head)) 995 else if (EXIT_X (head) || EXIT_Y (head))
1010 { 996 {
1011 if (out_of_map (head->map, EXIT_X (head), EXIT_Y (head))) 997 if (out_of_map (head->map, EXIT_X (head), EXIT_Y (head)))
1012 { 998 {
1013 LOG (llevError, "Removed illegal teleporter.\n"); 999 LOG (llevError, "Removed illegal teleporter.\n");
1014 remove_ob (head); 1000 head->destroy ();
1015 free_object (head);
1016 return; 1001 return;
1017 } 1002 }
1003
1018 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 1004 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1019 return; 1005 return;
1006
1020 transfer_ob (tmp, EXIT_X (head), EXIT_Y (head), 0, head); 1007 transfer_ob (tmp, EXIT_X (head), EXIT_Y (head), 0, head);
1021 } 1008 }
1022 else 1009 else
1023 { 1010 {
1024 /* Random teleporter */ 1011 /* Random teleporter */
… …
1032/* This object will teleport someone to a different map 1019/* This object will teleport someone to a different map
1033 and will also apply changes to the player from its inventory. 1020 and will also apply changes to the player from its inventory.
1034 This was invented for giving classes, but there's no reason it 1021 This was invented for giving classes, but there's no reason it
1035 can't be generalized. 1022 can't be generalized.
1036*/ 1023*/
1037
1038void 1024void
1039move_player_changer (object *op) 1025move_player_changer (object *op)
1040{ 1026{
1041 object *player; 1027 object *player;
1042 object *walk; 1028 object *walk;
1043 char c;
1044 1029
1045 if (!op->above || !EXIT_PATH (op)) 1030 if (!op->above || !EXIT_PATH (op))
1046 return; 1031 return;
1047 1032
1048 /* This isn't all that great - means that the player_mover 1033 /* This isn't all that great - means that the player_mover
1049 * needs to be on top. 1034 * needs to be on top.
1050 */ 1035 */
1051 if (op->above->type == PLAYER) 1036 if (op->above->type == PLAYER)
1052 { 1037 {
1053 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 1038 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
1054 return; 1039 return;
1040
1055 player = op->above; 1041 player = op->above;
1056 1042
1057 for (walk = op->inv; walk != NULL; walk = walk->below) 1043 for (walk = op->inv; walk; walk = walk->below)
1058 apply_changes_to_player (player, walk); 1044 apply_changes_to_player (player, walk);
1059 1045
1060 fix_player (player); 1046 player->update_stats ();
1061 1047
1062 esrv_send_inventory (op->above, op->above); 1048 esrv_send_inventory (op->above, op->above);
1063 esrv_update_item (UPD_FACE, op->above, op->above); 1049 esrv_update_item (UPD_FACE, op->above, op->above);
1064 1050
1065 /* update players death & WoR home-position */ 1051 /* update players death & WoR home-position */
1066 sscanf (EXIT_PATH (op), "%c", &c); 1052 if (*EXIT_PATH (op) == '/')
1067 if (c == '/')
1068 { 1053 {
1069 strcpy (player->contr->savebed_map, EXIT_PATH (op)); 1054 player->contr->savebed_map = EXIT_PATH (op);
1070 player->contr->bed_x = EXIT_X (op); 1055 player->contr->bed_x = EXIT_X (op);
1071 player->contr->bed_y = EXIT_Y (op); 1056 player->contr->bed_y = EXIT_Y (op);
1072 } 1057 }
1073 else 1058 else
1074 LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op)); 1059 LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op));
1075 1060
1076 enter_exit (op->above, op); 1061 op->above->enter_exit (op);
1077 save_player (player, 1);
1078 } 1062 }
1079} 1063}
1080 1064
1081/* firewalls fire other spells. 1065/* firewalls fire other spells.
1082 * The direction of the wall is stored in op->stats.sp. 1066 * The direction of the wall is stored in op->stats.sp.
… …
1089 1073
1090 if (!op->map) 1074 if (!op->map)
1091 return; /* dm has created a firewall in his inventory */ 1075 return; /* dm has created a firewall in his inventory */
1092 1076
1093 spell = op->inv; 1077 spell = op->inv;
1078
1094 if (!spell || spell->type != SPELL) 1079 if (!spell || spell->type != SPELL)
1095 spell = &op->other_arch->clone; 1080 spell = &op->other_arch->clone;
1081
1096 if (!spell) 1082 if (!spell)
1097 { 1083 {
1098 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, op->map->name, op->x, op->y); 1084 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);
1099 return; 1085 return;
1100 } 1086 }
1101 1087
1102 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL); 1088 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
1103} 1089}
1104
1105 1090
1106/* move_player_mover: this function takes a "player mover" as an 1091/* move_player_mover: this function takes a "player mover" as an
1107 * argument, and performs the function of a player mover, which is: 1092 * argument, and performs the function of a player mover, which is:
1108 * 1093 *
1109 * a player mover finds any players that are sitting on it. It 1094 * a player mover finds any players that are sitting on it. It
… …
1122 1107
1123 /* Determine direction now for random movers so we do the right thing */ 1108 /* Determine direction now for random movers so we do the right thing */
1124 if (!dir) 1109 if (!dir)
1125 dir = rndm (1, 8); 1110 dir = rndm (1, 8);
1126 1111
1127 for (victim = get_map_ob (op->map, op->x, op->y); victim != NULL; victim = victim->above) 1112 for (victim = GET_MAP_OB (op->map, op->x, op->y); victim != NULL; victim = victim->above)
1128 { 1113 {
1129 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1114 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&
1130 (victim->move_type & op->move_type || !victim->move_type)) 1115 (victim->move_type & op->move_type || !victim->move_type))
1131 { 1116 {
1132 1117
1133 if (victim->head) 1118 if (victim->head)
1134 victim = victim->head; 1119 victim = victim->head;
1135 1120
1136 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0) 1121 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1137 { 1122 {
1138 remove_ob (op); 1123 op->remove ();
1139 free_object (op);
1140 return; 1124 return;
1141 } 1125 }
1126
1142 nx = op->x + freearr_x[dir]; 1127 nx = op->x + freearr_x[dir];
1143 ny = op->y + freearr_y[dir]; 1128 ny = op->y + freearr_y[dir];
1144 m = op->map; 1129 m = op->map;
1145 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) 1130 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1146 { 1131 {
1147 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", m->path, op->x, op->y); 1132 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1148 return; 1133 return;
1149 } 1134 }
1150 1135
1151 if (should_director_abort (op, victim)) 1136 if (should_director_abort (op, victim))
1152 return; 1137 return;
1153 1138
1154 for (nextmover = get_map_ob (m, nx, ny); nextmover != NULL; nextmover = nextmover->above) 1139 for (nextmover = GET_MAP_OB (m, nx, ny); nextmover != NULL; nextmover = nextmover->above)
1155 { 1140 {
1156 if (nextmover->type == PLAYERMOVER) 1141 if (nextmover->type == PLAYERMOVER)
1157 nextmover->speed_left = -.99; 1142 nextmover->speed_left = -.99;
1158 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1143 if (QUERY_FLAG (nextmover, FLAG_ALIVE))
1159 { 1144 {
… …
1213{ 1198{
1214 object *tmp; 1199 object *tmp;
1215 1200
1216 if (!op->other_arch) 1201 if (!op->other_arch)
1217 { 1202 {
1218 LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? op->map->path : "nullmap"); 1203 LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? &op->map->path : "nullmap");
1219 return; 1204 return;
1220 } 1205 }
1221 1206
1222 if (op->above == NULL) 1207 if (op->above == NULL)
1223 return; 1208 return;
1224 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 1209 for (tmp = op->above; tmp != NULL; tmp = tmp->above)
1225 { 1210 {
1226 if (strcmp (op->other_arch->name, tmp->arch->name) == 0) 1211 if (strcmp (op->other_arch->name, tmp->arch->name) == 0)
1227 { 1212 {
1228 if (op->level <= 0) 1213 if (op->level <= 0)
1229 { 1214 tmp->destroy ();
1230 remove_ob (tmp);
1231 free_object (tmp);
1232 }
1233 else 1215 else
1234 { 1216 {
1235 uint64 new_nrof = (uint64) tmp->nrof * op->level; 1217 uint64 new_nrof = (uint64) tmp->nrof * op->level;
1236 1218
1237 if (new_nrof >= 1UL << 31) 1219 if (new_nrof >= 1UL << 31)
1238 new_nrof = 1UL << 31; 1220 new_nrof = 1UL << 31;
1221
1239 tmp->nrof = new_nrof; 1222 tmp->nrof = new_nrof;
1240 } 1223 }
1224
1241 break; 1225 break;
1242 } 1226 }
1243 } 1227 }
1244} 1228}
1245 1229
… …
1289 } 1273 }
1290 else 1274 else
1291 { 1275 {
1292 if (creator->other_arch == NULL) 1276 if (creator->other_arch == NULL)
1293 { 1277 {
1294 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n", &creator->name, creator->map->path, 1278 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1295 creator->x, creator->y); 1279 &creator->name, &creator->map->path, creator->x, creator->y);
1296 return; 1280 return;
1297 } 1281 }
1298 1282
1299 new_ob = object_create_arch (creator->other_arch); 1283 new_ob = object_create_arch (creator->other_arch);
1300 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1284 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1301 } 1285 }
1302 1286
1303 /* Make sure this multipart object fits */ 1287 /* Make sure this multipart object fits */
1304 if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y)) 1288 if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y))
1305 { 1289 {
1306 free_object (new_ob); 1290 new_ob->destroy ();
1307 return; 1291 return;
1308 } 1292 }
1309 1293
1310 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y); 1294 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1311 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1295 if (QUERY_FLAG (new_ob, FLAG_FREED))
… …
1327 unless hp was zero to start with, in which case it is infinite.*/ 1311 unless hp was zero to start with, in which case it is infinite.*/
1328 1312
1329void 1313void
1330move_marker (object *op) 1314move_marker (object *op)
1331{ 1315{
1316 if (object *tmp = op->ms ().player ())
1317 {
1332 object *tmp, *tmp2; 1318 object *tmp2;
1333 1319
1334 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1335 {
1336 if (tmp->type == PLAYER)
1337 { /* we've got someone to MARK */
1338
1339 /* remove an old force with a slaying field == op->name */ 1320 /* remove an old force with a slaying field == op->name */
1340 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1321 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1341 {
1342 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->name)) 1322 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->name))
1343 break;
1344 }
1345
1346 if (tmp2)
1347 { 1323 {
1348 remove_ob (tmp2); 1324 tmp2->destroy ();
1349 free_object (tmp2); 1325 break;
1350 } 1326 }
1351 1327
1352 /* cycle through his inventory to look for the MARK we want to 1328 /* cycle through his inventory to look for the MARK we want to
1353 * place 1329 * place
1354 */ 1330 */
1355 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1331 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1356 {
1357 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying)) 1332 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying))
1358 break; 1333 break;
1359 }
1360 1334
1361 /* if we didn't find our own MARK */ 1335 /* if we didn't find our own MARK */
1362 if (tmp2 == NULL) 1336 if (tmp2 == NULL)
1363 { 1337 {
1364 object *force = get_archetype (FORCE_NAME); 1338 object *force = get_archetype (FORCE_NAME);
1365 1339
1366 force->speed = 0;
1367 if (op->stats.food) 1340 if (op->stats.food)
1341 {
1342 force->set_speed (0.01);
1343 force->speed_left = -op->stats.food;
1344 }
1345 else
1346 force->set_speed (0);
1347
1348 /* put in the lock code */
1349 force->slaying = op->slaying;
1350
1351 if (op->lore)
1352 force->lore = op->lore;
1353
1354 insert_ob_in_ob (force, tmp);
1355 if (op->msg)
1356 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1357
1358 if (op->stats.hp > 0)
1359 {
1360 op->stats.hp--;
1361 if (op->stats.hp == 0)
1368 { 1362 {
1369 force->speed = 0.01; 1363 /* marker expires--granted mark number limit */
1370 force->speed_left = -op->stats.food; 1364 op->destroy ();
1365 return;
1371 } 1366 }
1372 update_ob_speed (force);
1373 /* put in the lock code */
1374 force->slaying = op->slaying;
1375
1376 if (op->lore)
1377 force->lore = op->lore;
1378
1379 insert_ob_in_ob (force, tmp);
1380 if (op->msg)
1381 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1382
1383 if (op->stats.hp > 0)
1384 {
1385 op->stats.hp--;
1386 if (op->stats.hp == 0)
1387 {
1388 /* marker expires--granted mark number limit */
1389 remove_ob (op);
1390 free_object (op);
1391 return;
1392 }
1393 } 1367 }
1394 } /* if tmp2 == NULL */ 1368 }
1395 } /* if tmp->type == PLAYER */ 1369 }
1396 } /* For all objects on this space */
1397} 1370}
1398 1371
1399int 1372int
1400process_object (object *op) 1373process_object (object *op)
1401{ 1374{
… …
1434 if (QUERY_FLAG (op, FLAG_APPLIED)) 1407 if (QUERY_FLAG (op, FLAG_APPLIED))
1435 remove_force (op); 1408 remove_force (op);
1436 else 1409 else
1437 { 1410 {
1438 /* IF necessary, delete the item from the players inventory */ 1411 /* IF necessary, delete the item from the players inventory */
1439 object *pl = is_player_inv (op); 1412 object *pl = op->in_player ();
1440 1413
1441 if (pl) 1414 if (pl)
1442 esrv_del_item (pl->contr, op->count); 1415 esrv_del_item (pl->contr, op->count);
1443 1416
1444 remove_ob (op); 1417 op->remove ();
1445 1418
1446 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1419 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1447 make_sure_not_seen (op); 1420 make_sure_not_seen (op);
1448 1421
1449 free_object (op); 1422 op->destroy ();
1450 } 1423 }
1451 1424
1452 return 1; 1425 return 1;
1453 } 1426 }
1454 1427
… …
1485 return 0; 1458 return 0;
1486 1459
1487 case THROWN_OBJ: 1460 case THROWN_OBJ:
1488 case ARROW: 1461 case ARROW:
1489 move_arrow (op); 1462 move_arrow (op);
1490 return 0;
1491
1492 case LIGHTNING: /* It now moves twice as fast */
1493 move_bolt (op);
1494 return 0; 1463 return 0;
1495 1464
1496 case DOOR: 1465 case DOOR:
1497 remove_door (op); 1466 remove_door (op);
1498 return 0; 1467 return 0;

Diff Legend

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