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

Diff Legend

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