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.25 by root, Tue Dec 26 08:17:59 2006 UTC vs.
Revision 1.51 by root, Fri May 18 20:45:37 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.1f);
50 update_ob_speed (tmp);
51 tmp->speed_left = -0.2; 47 tmp->speed_left = -0.2f;
52 } 48 }
53 49
54 if (op->other_arch) 50 if (op->other_arch)
55 { 51 {
56 tmp = arch_to_object (op->other_arch); 52 tmp = arch_to_object (op->other_arch);
… …
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.1f);
79 update_ob_speed (tmp);
80 tmp->speed_left = -0.2; 75 tmp->speed_left = -0.2f;
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;
… …
91 } 87 }
92 88
93 op->destroy (); 89 op->destroy ();
94} 90}
95 91
96/* Will generate a monster according to content
97 * of generator.
98 */
99void 92void
100generate_monster_inv (object *gen) 93generate_monster (object *gen)
101{ 94{
102 int i;
103 object *op, *head = NULL;
104
105 int qty = 0;
106
107 /* Code below assumes the generator is on a map, as it tries
108 * to place the monster on the map. So if the generator
109 * isn't on a map, complain and exit.
110 */
111 if (gen->map == NULL)
112 {
113 //LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
114 return;
115 }
116 /*First count numer of objects in inv */
117 for (op = gen->inv; op; op = op->below)
118 qty++;
119 if (!qty)
120 {
121 LOG (llevError, "Generator (%s) has no inventory in generate_monster_inv?\n", &gen->name);
122 return; /*No inventory */
123 }
124 qty = rndm (0, qty - 1);
125 for (op = gen->inv; qty; qty--)
126 op = op->below;
127 i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);
128 if (i == -1)
129 return;
130 head = object_create_clone (op);
131 CLEAR_FLAG (head, FLAG_IS_A_TEMPLATE);
132 unflag_inv (head, FLAG_IS_A_TEMPLATE);
133 if (rndm (0, 9))
134 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]);
136 if (QUERY_FLAG (head, FLAG_FREED))
137 return;
138 if (head->has_random_items ())
139 create_treasure (head->randomitems, head, GT_APPLY, gen->map->difficulty, 0);
140}
141
142void
143generate_monster_arch (object *gen)
144{
145 int i;
146 object *op, *head = NULL, *prev = NULL;
147 archetype *at = gen->other_arch;
148
149 if (!gen->other_arch)
150 return;
151
152 /* Code below assumes the generator is on a map, as it tries
153 * to place the monster on the map. So if the generator
154 * isn't on a map, complain and exit.
155 */
156 if (!gen->map) 95 if (!gen->map)
157 return; 96 return;
158 97
159 i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9);
160 if (i == -1)
161 return;
162
163 while (at)
164 {
165 op = arch_to_object (at);
166 op->x = gen->x + freearr_x[i] + at->clone.x;
167 op->y = gen->y + freearr_y[i] + at->clone.y;
168
169 if (head)
170 op->head = head, prev->more = op;
171
172 if (rndm (0, 9))
173 generate_artifact (op, gen->map->difficulty);
174
175 insert_ob_in_map (op, gen->map, gen, 0);
176 if (QUERY_FLAG (op, FLAG_FREED))
177 return;
178
179 if (op->has_random_items ())
180 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0);
181
182 if (head == NULL)
183 head = op;
184
185 prev = op;
186 at = at->more;
187 }
188}
189
190void
191generate_monster (object *gen)
192{
193
194 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1)) 98 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
195 return; 99 return;
196 100
101 object *op;
102
197 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 103 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
198 generate_monster_inv (gen); 104 {
105 // either copy one item form the inventory...
106 if (!gen->inv)
107 return;
108
109 // first select one item from the inventory
110 int index = 0;
111 for (object *tmp = gen->inv; tmp; tmp = tmp->below)
112 if (!rndm (++index))
113 op = tmp;
114
115 op = object_create_clone (op);
116
117 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);
118 unflag_inv (op, FLAG_IS_A_TEMPLATE);
119 }
199 else 120 else
200 generate_monster_arch (gen); 121 {
122 // ...or use other_arch
123 if (archetype *at = gen->other_arch)
124 op = arch_to_object (at);
125 else
126 return;
127 }
201 128
129 op->expand_tail ();
130
131 int i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);
132 if (i >= 0)
133 {
134 if (insert_ob_in_map_at (op, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]))
135 {
136 if (rndm (0, 9))
137 generate_artifact (op, gen->map->difficulty);
138
139 if (op->has_random_items ())
140 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);
141
142 return;
143 }
144 }
145
146 op->destroy ();
202} 147}
203 148
204void 149void
205remove_force (object *op) 150remove_force (object *op)
206{ 151{
… …
229 if (--op->stats.food > 0) 174 if (--op->stats.food > 0)
230 return; 175 return;
231 176
232 CLEAR_FLAG (op, FLAG_APPLIED); 177 CLEAR_FLAG (op, FLAG_APPLIED);
233 178
234 if (op->env != NULL) 179 if (op->env)
235 { 180 {
236 change_abil (op->env, op); 181 change_abil (op->env, op);
237 op->env->update_stats (); 182 op->env->update_stats ();
238 } 183 }
239 184
… …
249 return; 194 return;
250 } 195 }
251 196
252 if (op->stats.food == 1) 197 if (op->stats.food == 1)
253 { 198 {
254 /* need to remove the object before fix_player is called, else fix_player 199 /* need to unapply the object before update_stats is called, else fix_player
255 * will not do anything. 200 * will not do anything.
256 */ 201 */
257 if (op->env->type == PLAYER) 202 if (op->env->type == PLAYER)
258 { 203 {
259 CLEAR_FLAG (op, FLAG_APPLIED); 204 CLEAR_FLAG (op, FLAG_APPLIED);
… …
268 if (op->env->type == PLAYER) 213 if (op->env->type == PLAYER)
269 { 214 {
270 op->env->stats.food--; 215 op->env->stats.food--;
271 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick..."); 216 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick...");
272 } 217 }
218
273 (void) hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 219 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
274} 220}
275 221
276 222
277void 223void
278move_gate (object *op) 224move_gate (object *op)
279{ /* 1 = going down, 0 = goind up */ 225{ /* 1 = going down, 0 = going up */
280 object *tmp; 226 object *tmp;
281 227
282 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 228 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
283 { 229 {
284 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op)); 230 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op));
… …
292 { /* Reached bottom, let's stop */ 238 { /* Reached bottom, let's stop */
293 op->stats.wc = 0; 239 op->stats.wc = 0;
294 if (op->arch->clone.speed) 240 if (op->arch->clone.speed)
295 op->value = 0; 241 op->value = 0;
296 else 242 else
297 {
298 op->speed = 0; 243 op->set_speed (0);
299 update_ob_speed (op);
300 } 244 }
301 } 245
302 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 246 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
303 { 247 {
304 op->move_block = 0; 248 op->move_block = 0;
305 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 249 CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
306 update_all_los (op->map, op->x, op->y); 250 update_all_los (op->map, op->x, op->y);
307 } 251 }
252
308 SET_ANIMATION (op, op->stats.wc); 253 SET_ANIMATION (op, op->stats.wc);
309 update_object (op, UP_OBJ_CHANGE); 254 update_object (op, UP_OBJ_CHANGE);
310 return; 255 return;
311 } 256 }
312 257
… …
329 if (tmp == NULL) 274 if (tmp == NULL)
330 { 275 {
331 if (op->arch->clone.speed) 276 if (op->arch->clone.speed)
332 op->value = 1; 277 op->value = 1;
333 else 278 else
334 {
335 op->speed = 0; 279 op->set_speed (0);
336 update_ob_speed (op); /* Reached top, let's stop */ 280
337 }
338 return; 281 return;
339 } 282 }
340 } 283 }
341 284
342 if (op->stats.food) 285 if (op->stats.food)
… …
359 */ 302 */
360 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 303 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2)
361 { 304 {
362 /* Halfway or further, check blocks */ 305 /* Halfway or further, check blocks */
363 /* First, get the top object on the square. */ 306 /* First, get the top object on the square. */
364 for (tmp = op->above; tmp != NULL && tmp->above != NULL; tmp = tmp->above); 307 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
308 ;
365 309
366 if (tmp != NULL) 310 if (tmp)
367 { 311 {
368 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 312 if (QUERY_FLAG (tmp, FLAG_ALIVE))
369 { 313 {
370 hit_player (tmp, random_roll (1, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 314 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
315
371 if (tmp->type == PLAYER) 316 if (tmp->type == PLAYER)
372 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name); 317 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
373 } 318 }
374 else 319 else
375 /* If the object is not alive, and the object either can 320 /* If the object is not alive, and the object either can
… …
433 } 378 }
434 if (--op->stats.hp <= 0) 379 if (--op->stats.hp <= 0)
435 { /* keep gate down */ 380 { /* keep gate down */
436 move_gate (op); 381 move_gate (op);
437 if (op->value != v) 382 if (op->value != v)
438 { /* ready ? */
439 op->speed = 0; 383 op->set_speed (0);
440 update_ob_speed (op);
441 }
442 } 384 }
443} 385}
444 386
445/* slaying: name of the thing the detector is to look for 387/* slaying: name of the thing the detector is to look for
446 * speed: frequency of 'glances' 388 * speed: frequency of 'glances'
… …
464 406
465 if (op->stats.hp) 407 if (op->stats.hp)
466 { 408 {
467 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below) 409 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
468 { 410 {
469 if (op->slaying && !strcmp (op->slaying, tmp->name)) 411 if (op->slaying && op->slaying == tmp->name)
470 detected = 1; 412 detected = 1;
413
471 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying)) 414 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
472 detected = 1; 415 detected = 1;
473 } 416 }
474 } 417 }
418
475 if (op->slaying && !strcmp (op->slaying, tmp->name)) 419 if (op->slaying && op->slaying == tmp->name)
476 {
477 detected = 1; 420 detected = 1;
478 }
479 else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying) 421 else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying)
480 detected = 1; 422 detected = 1;
481 } 423 }
482 424
483 /* the detector sets the button if detection is found */ 425 /* the detector sets the button if detection is found */
… …
533 if (op->value) 475 if (op->value)
534 { /* We're opening */ 476 { /* We're opening */
535 if (--op->stats.wc <= 0) 477 if (--op->stats.wc <= 0)
536 { /* Opened, let's stop */ 478 { /* Opened, let's stop */
537 op->stats.wc = 0; 479 op->stats.wc = 0;
538 op->speed = 0; 480 op->set_speed (0);
539 update_ob_speed (op);
540 481
541 /* Hard coding this makes sense for holes I suppose */ 482 /* Hard coding this makes sense for holes I suppose */
542 op->move_on = MOVE_WALK; 483 op->move_on = MOVE_WALK;
543 for (tmp = op->above; tmp != NULL; tmp = next) 484 for (tmp = op->above; tmp != NULL; tmp = next)
544 { 485 {
545 next = tmp->above; 486 next = tmp->above;
546 move_apply (op, tmp, tmp); 487 move_apply (op, tmp, tmp);
547 } 488 }
548 } 489 }
490
549 SET_ANIMATION (op, op->stats.wc); 491 SET_ANIMATION (op, op->stats.wc);
550 update_object (op, UP_OBJ_FACE); 492 update_object (op, UP_OBJ_FACE);
551 return; 493 return;
552 } 494 }
553 /* We're closing */ 495 /* We're closing */
554 op->move_on = 0; 496 op->move_on = 0;
555 497
556 op->stats.wc++; 498 op->stats.wc++;
557 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 499 if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
558 op->stats.wc = NUM_ANIMATIONS (op) - 1; 500 op->stats.wc = NUM_ANIMATIONS (op) - 1;
501
559 SET_ANIMATION (op, op->stats.wc); 502 SET_ANIMATION (op, op->stats.wc);
560 update_object (op, UP_OBJ_FACE); 503 update_object (op, UP_OBJ_FACE);
561 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 504 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
562 {
563 op->speed = 0;
564 update_ob_speed (op); /* closed, let's stop */ 505 op->set_speed (0); /* closed, let's stop */
565 return;
566 }
567} 506}
568 507
569 508
570/* stop_item() returns a pointer to the stopped object. The stopped object 509/* stop_item() returns a pointer to the stopped object. The stopped object
571 * may or may not have been removed from maps or inventories. It will not 510 * may or may not have been removed from maps or inventories. It will not
… …
597 op->destroy (); 536 op->destroy ();
598 return payload; 537 return payload;
599 } 538 }
600 539
601 case ARROW: 540 case ARROW:
602 if (op->speed >= MIN_ACTIVE_SPEED) 541 if (op->has_active_speed ())
603 op = fix_stopped_arrow (op); 542 op = fix_stopped_arrow (op);
604 return op; 543 return op;
605 544
606 default: 545 default:
607 return op; 546 return op;
… …
616void 555void
617fix_stopped_item (object *op, maptile *map, object *originator) 556fix_stopped_item (object *op, maptile *map, object *originator)
618{ 557{
619 if (map == NULL) 558 if (map == NULL)
620 return; 559 return;
560
621 if (QUERY_FLAG (op, FLAG_REMOVED)) 561 if (QUERY_FLAG (op, FLAG_REMOVED))
622 insert_ob_in_map (op, map, originator, 0); 562 insert_ob_in_map (op, map, originator, 0);
623 else if (op->type == ARROW) 563 else if (op->type == ARROW)
624 merge_ob (op, NULL); /* only some arrows actually need this */ 564 merge_ob (op, NULL); /* only some arrows actually need this */
625} 565}
626 566
627
628object * 567object *
629fix_stopped_arrow (object *op) 568fix_stopped_arrow (object *op)
630{ 569{
631 if (rndm (0, 99) < op->stats.food) 570 if (rndm (0, 99) < op->stats.food)
632 { 571 {
633 /* Small chance of breaking */ 572 /* Small chance of breaking */
634 op->destroy (); 573 op->destroy ();
635 return NULL; 574 return NULL;
636 } 575 }
637 576
577 op->set_speed (0);
638 op->direction = 0; 578 op->direction = 0;
639 op->move_on = 0; 579 op->move_on = 0;
640 op->move_type = 0; 580 op->move_type = 0;
641 op->speed = 0; 581 op->skill = 0; // really?
642 update_ob_speed (op); 582
583 // restore original wc, dam, attacktype and slaying
643 op->stats.wc = op->stats.sp; 584 op->stats.wc = op->stats.sp;
644 op->stats.dam = op->stats.hp; 585 op->stats.dam = op->stats.hp;
645 op->attacktype = op->stats.grace; 586 op->attacktype = op->stats.grace;
646 op->slaying = 0;
647 op->skill = 0;
648 587
649 if (op->spellarg != NULL) 588 if (op->spellarg)
650 { 589 {
651 op->slaying = op->spellarg; 590 op->slaying = op->spellarg;
652 free (op->spellarg); 591 free (op->spellarg);
653 op->spellarg = NULL; 592 op->spellarg = 0;
654 } 593 }
655 else 594 else
656 op->slaying = NULL; 595 op->slaying = 0;
657 596
658 /* Reset these to zero, so that object::can_merge will work properly */ 597 /* Reset these to zero, so that object::can_merge will work properly */
659 op->spellarg = NULL; 598 op->spellarg = NULL;
660 op->stats.sp = 0; 599 op->stats.sp = 0;
661 op->stats.hp = 0; 600 op->stats.hp = 0;
662 op->stats.grace = 0; 601 op->stats.grace = 0;
663 op->level = 0; 602 op->level = 0;
664 op->face = op->arch->clone.face; 603 op->face = op->arch->clone.face;
665 op->owner = NULL; /* So that stopped arrows will be saved */ 604 op->owner = NULL; /* So that stopped arrows will be saved */
666 update_object (op, UP_OBJ_FACE); 605 update_object (op, UP_OBJ_CHANGE);
667 return op; 606 return op;
668} 607}
669 608
670/* stop_arrow() - what to do when a non-living flying object 609/* stop_arrow() - what to do when a non-living flying object
671 * has to stop. Sept 96 - I added in thrown object code in 610 * has to stop. Sept 96 - I added in thrown object code in
672 * here too. -b.t. 611 * here too. -b.t.
673 * 612 *
674 * Returns a pointer to the stopped object (which will have been removed 613 * Returns a pointer to the stopped object (which will have been removed
675 * from maps or inventories), or NULL if was destroyed. 614 * from maps or inventories), or NULL if was destroyed.
676 */ 615 */
677
678static void 616static void
679stop_arrow (object *op) 617stop_arrow (object *op)
680{ 618{
681 if (INVOKE_OBJECT (STOP, op)) 619 if (INVOKE_OBJECT (STOP, op))
682 return; 620 return;
… …
691 op->destroy (); 629 op->destroy ();
692 } 630 }
693 else 631 else
694 { 632 {
695 op = fix_stopped_arrow (op); 633 op = fix_stopped_arrow (op);
634
696 if (op) 635 if (op)
697 merge_ob (op, NULL); 636 merge_ob (op, 0);
698 } 637 }
699} 638}
700 639
701/* Move an arrow along its course. op is the arrow or thrown object. 640/* Move an arrow along its course. op is the arrow or thrown object.
702 */ 641 */
703
704void 642void
705move_arrow (object *op) 643move_arrow (object *op)
706{ 644{
707 object *tmp; 645 object *tmp;
708 sint16 new_x, new_y; 646 sint16 new_x, new_y;
… …
779 * as below. (Note that for living creatures there is a small 717 * as below. (Note that for living creatures there is a small
780 * chance that reflect_missile fails.) 718 * chance that reflect_missile fails.)
781 */ 719 */
782 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 720 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10))
783 { 721 {
784 int number = op->face->number; 722 int number = op->face;
785 723
786 op->direction = absdir (op->direction + 4); 724 op->direction = absdir (op->direction + 4);
787 op->state = 0; 725 update_turn_face (op);
788
789 if (GET_ANIM_ID (op))
790 {
791 number += 4;
792
793 if (number > GET_ANIMATION (op, 8))
794 number -= 8;
795
796 op->face = &new_faces[number];
797 }
798
799 was_reflected = 1; /* skip normal movement calculations */ 726 was_reflected = 1; /* skip normal movement calculations */
800 } 727 }
801 else 728 else
802 { 729 {
803 /* Attack the object. */ 730 /* Attack the object. */
… …
977 * there is an old multipart teleporter in which the other parts 904 * 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 905 * 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 906 * function - in fact, as written below, part N would get called
980 * N times without the speed check. 907 * N times without the speed check.
981 */ 908 */
982 if (op->more && FABS (op->more->speed) < MIN_ACTIVE_SPEED) 909 if (op->more && !op->more->has_active_speed ())
983 move_teleporter (op->more); 910 move_teleporter (op->more);
984 911
985 if (op->head) 912 if (op->head)
986 head = op->head; 913 head = op->head;
987 914
… …
998 if (tmp->type == PLAYER) 925 if (tmp->type == PLAYER)
999 { 926 {
1000 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 927 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1001 return; 928 return;
1002 929
1003 enter_exit (tmp, head); 930 tmp->enter_exit (head);
1004 } 931 }
1005 else 932 else
1006 /* Currently only players can transfer maps */ 933 /* Currently only players can transfer maps */
1007 return; 934 return;
1008 } 935 }
… …
1033/* This object will teleport someone to a different map 960/* This object will teleport someone to a different map
1034 and will also apply changes to the player from its inventory. 961 and will also apply changes to the player from its inventory.
1035 This was invented for giving classes, but there's no reason it 962 This was invented for giving classes, but there's no reason it
1036 can't be generalized. 963 can't be generalized.
1037*/ 964*/
1038
1039void 965void
1040move_player_changer (object *op) 966move_player_changer (object *op)
1041{ 967{
1042 object *player; 968 object *player;
1043 object *walk; 969 object *walk;
1044 char c;
1045 970
1046 if (!op->above || !EXIT_PATH (op)) 971 if (!op->above || !EXIT_PATH (op))
1047 return; 972 return;
1048 973
1049 /* This isn't all that great - means that the player_mover 974 /* This isn't all that great - means that the player_mover
1050 * needs to be on top. 975 * needs to be on top.
1051 */ 976 */
1052 if (op->above->type == PLAYER) 977 if (op->above->type == PLAYER)
1053 { 978 {
1054 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 979 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
1055 return; 980 return;
981
1056 player = op->above; 982 player = op->above;
1057 983
1058 for (walk = op->inv; walk != NULL; walk = walk->below) 984 for (walk = op->inv; walk; walk = walk->below)
1059 apply_changes_to_player (player, walk); 985 apply_changes_to_player (player, walk);
1060 986
1061 player->update_stats (); 987 player->update_stats ();
1062 988
1063 esrv_send_inventory (op->above, op->above); 989 esrv_send_inventory (op->above, op->above);
1064 esrv_update_item (UPD_FACE, op->above, op->above); 990 esrv_update_item (UPD_FACE, op->above, op->above);
1065 991
1066 /* update players death & WoR home-position */ 992 /* update players death & WoR home-position */
1067 sscanf (EXIT_PATH (op), "%c", &c); 993 if (*EXIT_PATH (op) == '/')
1068 if (c == '/')
1069 { 994 {
1070 strcpy (player->contr->savebed_map, EXIT_PATH (op)); 995 player->contr->savebed_map = EXIT_PATH (op);
1071 player->contr->bed_x = EXIT_X (op); 996 player->contr->bed_x = EXIT_X (op);
1072 player->contr->bed_y = EXIT_Y (op); 997 player->contr->bed_y = EXIT_Y (op);
1073 } 998 }
1074 else 999 else
1075 LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op)); 1000 LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op));
1076 1001
1077 enter_exit (op->above, op); 1002 op->above->enter_exit (op);
1078 player->contr->save ();
1079 } 1003 }
1080} 1004}
1081 1005
1082/* firewalls fire other spells. 1006/* firewalls fire other spells.
1083 * The direction of the wall is stored in op->stats.sp. 1007 * The direction of the wall is stored in op->stats.sp.
… …
1096 if (!spell || spell->type != SPELL) 1020 if (!spell || spell->type != SPELL)
1097 spell = &op->other_arch->clone; 1021 spell = &op->other_arch->clone;
1098 1022
1099 if (!spell) 1023 if (!spell)
1100 { 1024 {
1101 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, op->map->name, op->x, op->y); 1025 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);
1102 return; 1026 return;
1103 } 1027 }
1104 1028
1105 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL); 1029 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
1106} 1030}
… …
1115 * it'll paralyze the victim for hp*his speed/op->speed 1039 * it'll paralyze the victim for hp*his speed/op->speed
1116 */ 1040 */
1117void 1041void
1118move_player_mover (object *op) 1042move_player_mover (object *op)
1119{ 1043{
1120 object *victim, *nextmover;
1121 int dir = op->stats.sp; 1044 int dir = op->stats.sp;
1122 sint16 nx, ny; 1045 sint16 nx, ny;
1123 maptile *m; 1046 maptile *m;
1124 1047
1125 /* Determine direction now for random movers so we do the right thing */ 1048 /* Determine direction now for random movers so we do the right thing */
1126 if (!dir) 1049 if (!dir)
1127 dir = rndm (1, 8); 1050 dir = rndm (1, 8);
1128 1051
1129 for (victim = GET_MAP_OB (op->map, op->x, op->y); victim != NULL; victim = victim->above) 1052 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1130 { 1053 {
1131 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1054 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&
1132 (victim->move_type & op->move_type || !victim->move_type)) 1055 (victim->move_type & op->move_type || !victim->move_type))
1133 { 1056 {
1134 1057
… …
1144 nx = op->x + freearr_x[dir]; 1067 nx = op->x + freearr_x[dir];
1145 ny = op->y + freearr_y[dir]; 1068 ny = op->y + freearr_y[dir];
1146 m = op->map; 1069 m = op->map;
1147 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) 1070 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1148 { 1071 {
1149 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", m->path, op->x, op->y); 1072 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1150 return; 1073 return;
1151 } 1074 }
1152 1075
1153 if (should_director_abort (op, victim)) 1076 if (should_director_abort (op, victim))
1154 return; 1077 return;
1155 1078
1156 for (nextmover = GET_MAP_OB (m, nx, ny); nextmover != NULL; nextmover = nextmover->above) 1079 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1157 { 1080 {
1158 if (nextmover->type == PLAYERMOVER) 1081 if (nextmover->type == PLAYERMOVER)
1159 nextmover->speed_left = -.99; 1082 nextmover->speed_left = -.99f;
1083
1160 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1084 if (QUERY_FLAG (nextmover, FLAG_ALIVE))
1161 {
1162 op->speed_left = -1.1; /* wait until the next thing gets out of the way */ 1085 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1163 }
1164 } 1086 }
1165 1087
1166 if (victim->type == PLAYER) 1088 if (victim->type == PLAYER)
1167 { 1089 {
1168 /* only level >=1 movers move people */ 1090 /* only level >=1 movers move people */
… …
1172 * is cleared, otherwise the player will get stuck in 1094 * is cleared, otherwise the player will get stuck in
1173 * place. This can happen if the player used a spell to 1095 * place. This can happen if the player used a spell to
1174 * get to this space. 1096 * get to this space.
1175 */ 1097 */
1176 victim->contr->fire_on = 0; 1098 victim->contr->fire_on = 0;
1177 victim->speed_left = -FABS (victim->speed); 1099 victim->speed_left = 0.f;
1178 move_player (victim, dir); 1100 move_player (victim, dir);
1179 } 1101 }
1180 else 1102 else
1181 return; 1103 return;
1182 } 1104 }
… …
1186 if (!op->stats.maxsp && op->attacktype) 1108 if (!op->stats.maxsp && op->attacktype)
1187 op->stats.maxsp = 2; 1109 op->stats.maxsp = 2;
1188 1110
1189 if (op->attacktype) 1111 if (op->attacktype)
1190 { /* flag to paralyze the player */ 1112 { /* flag to paralyze the player */
1191
1192 victim->speed_left = -FABS (op->stats.maxsp * victim->speed / op->speed); 1113 victim->speed_left = max (-5.f, -FABS (op->stats.maxsp * victim->speed / op->speed));
1193 /* Not sure why, but for some chars on metalforge, they
1194 * would sometimes get -inf speed_left, and from the
1195 * description, it could only happen here, so just put
1196 * a lower sanity limit. My only guess is that the
1197 * mover has 0 speed.
1198 */
1199 if (victim->speed_left < -5.0)
1200 victim->speed_left = -5.0;
1201 } 1114 }
1202 } 1115 }
1203 } 1116 }
1204} 1117}
1205 1118
… …
1215{ 1128{
1216 object *tmp; 1129 object *tmp;
1217 1130
1218 if (!op->other_arch) 1131 if (!op->other_arch)
1219 { 1132 {
1220 LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? op->map->path : "nullmap"); 1133 LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? &op->map->path : "nullmap");
1221 return; 1134 return;
1222 } 1135 }
1223 1136
1224 if (op->above == NULL) 1137 if (op->above == NULL)
1225 return; 1138 return;
1139
1226 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 1140 for (tmp = op->above; tmp; tmp = tmp->above)
1227 { 1141 {
1228 if (strcmp (op->other_arch->name, tmp->arch->name) == 0) 1142 if (op->other_arch->name == tmp->arch->name)
1229 { 1143 {
1230 if (op->level <= 0) 1144 if (op->level <= 0)
1231 tmp->destroy (); 1145 tmp->destroy ();
1232 else 1146 else
1233 { 1147 {
… …
1290 } 1204 }
1291 else 1205 else
1292 { 1206 {
1293 if (creator->other_arch == NULL) 1207 if (creator->other_arch == NULL)
1294 { 1208 {
1295 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n", &creator->name, creator->map->path, 1209 LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1296 creator->x, creator->y); 1210 &creator->name, &creator->map->path, creator->x, creator->y);
1297 return; 1211 return;
1298 } 1212 }
1299 1213
1300 new_ob = object_create_arch (creator->other_arch); 1214 new_ob = object_create_arch (creator->other_arch);
1301 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1215 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
… …
1324 with a specific code as the slaying field. 1238 with a specific code as the slaying field.
1325 At that time, it writes the contents of its own message 1239 At that time, it writes the contents of its own message
1326 field to the player. The marker will decrement hp to 1240 field to the player. The marker will decrement hp to
1327 0 and then delete itself every time it grants a mark. 1241 0 and then delete itself every time it grants a mark.
1328 unless hp was zero to start with, in which case it is infinite.*/ 1242 unless hp was zero to start with, in which case it is infinite.*/
1329
1330void 1243void
1331move_marker (object *op) 1244move_marker (object *op)
1332{ 1245{
1333 if (object *tmp = op->ms ().player ()) 1246 if (object *tmp = op->ms ().player ())
1334 { 1247 {
1335 object *tmp2; 1248 object *tmp2;
1336 1249
1337 /* remove an old force with a slaying field == op->name */ 1250 /* remove an old force with a slaying field == op->name */
1338 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below) 1251 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1339 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->name)) 1252 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->name)
1340 { 1253 {
1341 tmp2->destroy (); 1254 tmp2->destroy ();
1342 break; 1255 break;
1343 } 1256 }
1344 1257
1345 /* cycle through his inventory to look for the MARK we want to 1258 /* cycle through his inventory to look for the MARK we want to
1346 * place 1259 * place
1347 */ 1260 */
1348 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below) 1261 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1349 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying)) 1262 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
1350 break; 1263 break;
1351 1264
1352 /* if we didn't find our own MARK */ 1265 /* if we didn't find our own MARK */
1353 if (tmp2 == NULL) 1266 if (!tmp2)
1354 { 1267 {
1355 object *force = get_archetype (FORCE_NAME); 1268 object *force = get_archetype (FORCE_NAME);
1356 1269
1357 force->speed = 0;
1358 if (op->stats.food) 1270 if (op->stats.food)
1359 { 1271 {
1360 force->speed = 0.01; 1272 force->set_speed (0.01);
1361 force->speed_left = -op->stats.food; 1273 force->speed_left = -op->stats.food;
1362 } 1274 }
1363 update_ob_speed (force); 1275 else
1276 force->set_speed (0);
1277
1364 /* put in the lock code */ 1278 /* put in the lock code */
1365 force->slaying = op->slaying; 1279 force->slaying = op->slaying;
1366 1280
1367 if (op->lore) 1281 if (op->lore)
1368 force->lore = op->lore; 1282 force->lore = op->lore;
… …
1383 } 1297 }
1384 } 1298 }
1385 } 1299 }
1386} 1300}
1387 1301
1388int 1302void
1389process_object (object *op) 1303process_object (object *op)
1390{ 1304{
1391 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 1305 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
1392 return 0; 1306 return;
1393 1307
1394 if (INVOKE_OBJECT (TICK, op)) 1308 if (INVOKE_OBJECT (TICK, op))
1395 return 0; 1309 return;
1396 1310
1397 if (QUERY_FLAG (op, FLAG_MONSTER)) 1311 if (QUERY_FLAG (op, FLAG_MONSTER))
1398 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1312 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED))
1399 return 1; 1313 return;
1400 1314
1401 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1315 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0)
1402 { 1316 {
1403 if (op->type == PLAYER)
1404 animate_object (op, op->facing);
1405 else
1406 animate_object (op, op->direction); 1317 animate_object (op, op->contr ? op->facing : op->direction);
1407 1318
1408 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1319 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1409 make_sure_seen (op); 1320 make_sure_seen (op);
1410 } 1321 }
1411 1322
1323 if (op->flag [FLAG_GENERATOR]
1324 || op->flag [FLAG_CHANGING]
1325 || op->flag [FLAG_IS_USED_UP])
1326 {
1412 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1327 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
1413 { 1328 {
1414 change_object (op); 1329 change_object (op);
1415 return 1; 1330 return;
1416 } 1331 }
1417 1332
1418 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1333 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY))
1419 generate_monster (op); 1334 generate_monster (op);
1420 1335
1421 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1336 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0)
1422 { 1337 {
1423 if (QUERY_FLAG (op, FLAG_APPLIED)) 1338 if (QUERY_FLAG (op, FLAG_APPLIED))
1424 remove_force (op); 1339 remove_force (op);
1425 else 1340 else
1426 { 1341 {
1427 /* IF necessary, delete the item from the players inventory */ 1342 /* If necessary, delete the item from the players inventory */
1428 object *pl = op->in_player (); 1343 object *pl = op->in_player ();
1429 1344
1430 if (pl) 1345 if (pl)
1431 esrv_del_item (pl->contr, op->count); 1346 esrv_del_item (pl->contr, op->count);
1432 1347
1433 op->remove (); 1348 op->remove ();
1434 1349
1435 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1350 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1436 make_sure_not_seen (op); 1351 make_sure_not_seen (op);
1437 1352
1438 op->destroy (); 1353 op->destroy ();
1439 } 1354 }
1440 1355
1441 return 1; 1356 return;
1357 }
1442 } 1358 }
1443 1359
1444 switch (op->type) 1360 switch (op->type)
1445 { 1361 {
1446 case SPELL_EFFECT: 1362 case SPELL_EFFECT:
1447 move_spell_effect (op); 1363 move_spell_effect (op);
1448 return 1; 1364 break;
1449 1365
1450 case ROD: 1366 case ROD:
1451 case HORN: 1367 case HORN:
1452 regenerate_rod (op); 1368 regenerate_rod (op);
1453 return 1; 1369 break;
1454 1370
1455 case FORCE: 1371 case FORCE:
1456 case POTION_EFFECT: 1372 case POTION_EFFECT:
1457 remove_force (op); 1373 remove_force (op);
1458 return 1; 1374 break;
1459 1375
1460 case BLINDNESS: 1376 case BLINDNESS:
1461 remove_blindness (op); 1377 remove_blindness (op);
1462 return 0; 1378 break;
1463 1379
1464 case POISONING: 1380 case POISONING:
1465 poison_more (op); 1381 poison_more (op);
1466 return 0; 1382 break;
1467 1383
1468 case DISEASE: 1384 case DISEASE:
1469 move_disease (op); 1385 move_disease (op);
1470 return 0; 1386 break;
1471 1387
1472 case SYMPTOM: 1388 case SYMPTOM:
1473 move_symptom (op); 1389 move_symptom (op);
1474 return 0; 1390 break;
1475 1391
1476 case THROWN_OBJ: 1392 case THROWN_OBJ:
1477 case ARROW: 1393 case ARROW:
1478 move_arrow (op); 1394 move_arrow (op);
1479 return 0; 1395 break;
1480 1396
1481 case DOOR: 1397 case DOOR:
1482 remove_door (op); 1398 remove_door (op);
1483 return 0; 1399 break;
1484 1400
1485 case LOCKED_DOOR: 1401 case LOCKED_DOOR:
1486 remove_door2 (op); 1402 remove_door2 (op);
1487 return 0; 1403 break;
1488 1404
1489 case TELEPORTER: 1405 case TELEPORTER:
1490 move_teleporter (op); 1406 move_teleporter (op);
1491 return 0; 1407 break;
1492 1408
1493 case GOLEM: 1409 case GOLEM:
1494 move_golem (op); 1410 move_golem (op);
1495 return 0; 1411 break;
1496 1412
1497 case EARTHWALL: 1413 case EARTHWALL:
1498 hit_player (op, 2, op, AT_PHYSICAL, 1); 1414 hit_player (op, 2, op, AT_PHYSICAL, 1);
1499 return 0; 1415 break;
1500 1416
1501 case FIREWALL: 1417 case FIREWALL:
1502 move_firewall (op); 1418 move_firewall (op);
1503 if (op->stats.maxsp) 1419 if (op->stats.maxsp)
1504 animate_turning (op); 1420 animate_turning (op);
1505 return 0; 1421 break;
1506 1422
1507 case MOOD_FLOOR: 1423 case MOOD_FLOOR:
1508 do_mood_floor (op); 1424 do_mood_floor (op);
1509 return 0; 1425 break;
1510 1426
1511 case GATE: 1427 case GATE:
1512 move_gate (op); 1428 move_gate (op);
1513 return 0; 1429 break;
1514 1430
1515 case TIMED_GATE: 1431 case TIMED_GATE:
1516 move_timed_gate (op); 1432 move_timed_gate (op);
1517 return 0; 1433 break;
1518 1434
1519 case TRIGGER: 1435 case TRIGGER:
1520 case TRIGGER_BUTTON: 1436 case TRIGGER_BUTTON:
1521 case TRIGGER_PEDESTAL: 1437 case TRIGGER_PEDESTAL:
1522 case TRIGGER_ALTAR: 1438 case TRIGGER_ALTAR:
1523 animate_trigger (op); 1439 animate_trigger (op);
1524 return 0; 1440 break;
1525 1441
1526 case DETECTOR: 1442 case DETECTOR:
1527 move_detector (op); 1443 move_detector (op);
1528 1444
1529 case DIRECTOR: 1445 case DIRECTOR:
1530 if (op->stats.maxsp) 1446 if (op->stats.maxsp)
1531 animate_turning (op); 1447 animate_turning (op);
1532 return 0; 1448 break;
1533 1449
1534 case HOLE: 1450 case HOLE:
1535 move_hole (op); 1451 move_hole (op);
1536 return 0; 1452 break;
1537 1453
1538 case DEEP_SWAMP: 1454 case DEEP_SWAMP:
1539 move_deep_swamp (op); 1455 move_deep_swamp (op);
1540 return 0; 1456 break;
1541 1457
1542 case RUNE: 1458 case RUNE:
1543 case TRAP: 1459 case TRAP:
1544 move_rune (op); 1460 move_rune (op);
1545 return 0; 1461 break;
1546 1462
1547 case PLAYERMOVER: 1463 case PLAYERMOVER:
1548 move_player_mover (op); 1464 move_player_mover (op);
1549 return 0; 1465 break;
1550 1466
1551 case CREATOR: 1467 case CREATOR:
1552 move_creator (op); 1468 move_creator (op);
1553 return 0; 1469 break;
1554 1470
1555 case MARKER: 1471 case MARKER:
1556 move_marker (op); 1472 move_marker (op);
1557 return 0; 1473 break;
1558 1474
1559 case PLAYER_CHANGER: 1475 case PLAYER_CHANGER:
1560 move_player_changer (op); 1476 move_player_changer (op);
1561 return 0; 1477 break;
1562 1478
1563 case PEACEMAKER: 1479 case PEACEMAKER:
1564 move_peacemaker (op); 1480 move_peacemaker (op);
1565 return 0; 1481 break;
1566 }
1567 1482
1568 return 0; 1483 case PLAYER:
1484 // players have their own speed-management, so undo the --speed_left
1485 ++op->speed_left;
1486 break;
1487 }
1569} 1488}
1489

Diff Legend

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