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.18 by root, Wed Dec 13 03:28:42 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) 95 if (!gen->map)
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; 96 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 (HAS_RANDOM_ITEMS (head))
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 == NULL)
150 {
151 //LOG(llevError,"Generator without other_arch: %s\n",gen->name);
152 return;
153 }
154 /* Code below assumes the generator is on a map, as it tries
155 * to place the monster on the map. So if the generator
156 * isn't on a map, complain and exit.
157 */
158 if (gen->map == NULL)
159 {
160 //LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
161 return;
162 }
163 i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9);
164 if (i == -1)
165 return;
166 while (at != NULL)
167 {
168 op = arch_to_object (at);
169 op->x = gen->x + freearr_x[i] + at->clone.x;
170 op->y = gen->y + freearr_y[i] + at->clone.y;
171
172 if (head != NULL)
173 op->head = head, prev->more = op;
174
175 if (rndm (0, 9))
176 generate_artifact (op, gen->map->difficulty);
177 insert_ob_in_map (op, gen->map, gen, 0);
178 if (QUERY_FLAG (op, FLAG_FREED))
179 return;
180 if (HAS_RANDOM_ITEMS (op))
181 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0);
182 if (head == NULL)
183 head = op;
184 prev = op;
185 at = at->more;
186 }
187}
188
189void
190generate_monster (object *gen)
191{
192 97
193 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1)) 98 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
194 return; 99 return;
100
101 object *op;
102
195 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 103 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
196 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 }
197 else 120 else
198 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 }
199 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 ();
200} 147}
201 148
202void 149void
203remove_force (object *op) 150remove_force (object *op)
204{ 151{
205 if (--op->duration > 0) 152 if (--op->duration > 0)
206 return; 153 return;
207 154
155 if (op->env)
208 switch (op->subtype) 156 switch (op->subtype)
209 { 157 {
210 case FORCE_CONFUSION: 158 case FORCE_CONFUSION:
211 if (op->env != NULL)
212 {
213 CLEAR_FLAG (op->env, FLAG_CONFUSED); 159 CLEAR_FLAG (op->env, FLAG_CONFUSED);
214 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");
215 }
216 161
217 default: 162 default:
218 if (op->env != NULL)
219 {
220 CLEAR_FLAG (op, FLAG_APPLIED); 163 CLEAR_FLAG (op, FLAG_APPLIED);
221 change_abil (op->env, op); 164 change_abil (op->env, op);
222 fix_player (op->env); 165 op->env->update_stats ();
223 }
224 } 166 }
225 167
226 op->destroy (); 168 op->destroy ();
227} 169}
228 170
229void 171void
… …
232 if (--op->stats.food > 0) 174 if (--op->stats.food > 0)
233 return; 175 return;
234 176
235 CLEAR_FLAG (op, FLAG_APPLIED); 177 CLEAR_FLAG (op, FLAG_APPLIED);
236 178
237 if (op->env != NULL) 179 if (op->env)
238 { 180 {
239 change_abil (op->env, op); 181 change_abil (op->env, op);
240 fix_player (op->env); 182 op->env->update_stats ();
241 } 183 }
242 184
243 op->destroy (); 185 op->destroy ();
244} 186}
245 187
… …
252 return; 194 return;
253 } 195 }
254 196
255 if (op->stats.food == 1) 197 if (op->stats.food == 1)
256 { 198 {
257 /* 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
258 * will not do anything. 200 * will not do anything.
259 */ 201 */
260 if (op->env->type == PLAYER) 202 if (op->env->type == PLAYER)
261 { 203 {
262 CLEAR_FLAG (op, FLAG_APPLIED); 204 CLEAR_FLAG (op, FLAG_APPLIED);
263 fix_player (op->env); 205 op->env->update_stats ();
264 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now."); 206 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
265 } 207 }
266 208
267 op->destroy (); 209 op->destroy ();
268 return; 210 return;
… …
271 if (op->env->type == PLAYER) 213 if (op->env->type == PLAYER)
272 { 214 {
273 op->env->stats.food--; 215 op->env->stats.food--;
274 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...");
275 } 217 }
218
276 (void) hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 219 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
277} 220}
278 221
279 222
280void 223void
281move_gate (object *op) 224move_gate (object *op)
282{ /* 1 = going down, 0 = goind up */ 225{ /* 1 = going down, 0 = going up */
283 object *tmp; 226 object *tmp;
284 227
285 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))
286 { 229 {
287 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));
… …
295 { /* Reached bottom, let's stop */ 238 { /* Reached bottom, let's stop */
296 op->stats.wc = 0; 239 op->stats.wc = 0;
297 if (op->arch->clone.speed) 240 if (op->arch->clone.speed)
298 op->value = 0; 241 op->value = 0;
299 else 242 else
300 {
301 op->speed = 0; 243 op->set_speed (0);
302 update_ob_speed (op);
303 } 244 }
304 } 245
305 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 246 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
306 { 247 {
307 op->move_block = 0; 248 op->move_block = 0;
308 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 249 CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
309 update_all_los (op->map, op->x, op->y); 250 update_all_los (op->map, op->x, op->y);
310 } 251 }
252
311 SET_ANIMATION (op, op->stats.wc); 253 SET_ANIMATION (op, op->stats.wc);
312 update_object (op, UP_OBJ_CHANGE); 254 update_object (op, UP_OBJ_CHANGE);
313 return; 255 return;
314 } 256 }
315 257
… …
332 if (tmp == NULL) 274 if (tmp == NULL)
333 { 275 {
334 if (op->arch->clone.speed) 276 if (op->arch->clone.speed)
335 op->value = 1; 277 op->value = 1;
336 else 278 else
337 {
338 op->speed = 0; 279 op->set_speed (0);
339 update_ob_speed (op); /* Reached top, let's stop */ 280
340 }
341 return; 281 return;
342 } 282 }
343 } 283 }
344 284
345 if (op->stats.food) 285 if (op->stats.food)
… …
362 */ 302 */
363 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 303 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2)
364 { 304 {
365 /* Halfway or further, check blocks */ 305 /* Halfway or further, check blocks */
366 /* First, get the top object on the square. */ 306 /* First, get the top object on the square. */
367 for (tmp = op->above; tmp != NULL && tmp->above != NULL; tmp = tmp->above); 307 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
308 ;
368 309
369 if (tmp != NULL) 310 if (tmp)
370 { 311 {
371 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 312 if (QUERY_FLAG (tmp, FLAG_ALIVE))
372 { 313 {
373 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
374 if (tmp->type == PLAYER) 316 if (tmp->type == PLAYER)
375 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);
376 } 318 }
377 else 319 else
378 /* If the object is not alive, and the object either can 320 /* If the object is not alive, and the object either can
… …
436 } 378 }
437 if (--op->stats.hp <= 0) 379 if (--op->stats.hp <= 0)
438 { /* keep gate down */ 380 { /* keep gate down */
439 move_gate (op); 381 move_gate (op);
440 if (op->value != v) 382 if (op->value != v)
441 { /* ready ? */
442 op->speed = 0; 383 op->set_speed (0);
443 update_ob_speed (op);
444 }
445 } 384 }
446} 385}
447 386
448/* slaying: name of the thing the detector is to look for 387/* slaying: name of the thing the detector is to look for
449 * speed: frequency of 'glances' 388 * speed: frequency of 'glances'
… …
459 int last = op->value; 398 int last = op->value;
460 int detected; 399 int detected;
461 400
462 detected = 0; 401 detected = 0;
463 402
464 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above) 403 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above)
465 { 404 {
466 object *tmp2; 405 object *tmp2;
467 406
468 if (op->stats.hp) 407 if (op->stats.hp)
469 { 408 {
470 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below) 409 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
471 { 410 {
472 if (op->slaying && !strcmp (op->slaying, tmp->name)) 411 if (op->slaying && op->slaying == tmp->name)
473 detected = 1; 412 detected = 1;
413
474 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying)) 414 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
475 detected = 1; 415 detected = 1;
476 } 416 }
477 } 417 }
418
478 if (op->slaying && !strcmp (op->slaying, tmp->name)) 419 if (op->slaying && op->slaying == tmp->name)
479 {
480 detected = 1; 420 detected = 1;
481 }
482 else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying) 421 else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying)
483 detected = 1; 422 detected = 1;
484 } 423 }
485 424
486 /* the detector sets the button if detection is found */ 425 /* the detector sets the button if detection is found */
… …
536 if (op->value) 475 if (op->value)
537 { /* We're opening */ 476 { /* We're opening */
538 if (--op->stats.wc <= 0) 477 if (--op->stats.wc <= 0)
539 { /* Opened, let's stop */ 478 { /* Opened, let's stop */
540 op->stats.wc = 0; 479 op->stats.wc = 0;
541 op->speed = 0; 480 op->set_speed (0);
542 update_ob_speed (op);
543 481
544 /* Hard coding this makes sense for holes I suppose */ 482 /* Hard coding this makes sense for holes I suppose */
545 op->move_on = MOVE_WALK; 483 op->move_on = MOVE_WALK;
546 for (tmp = op->above; tmp != NULL; tmp = next) 484 for (tmp = op->above; tmp != NULL; tmp = next)
547 { 485 {
548 next = tmp->above; 486 next = tmp->above;
549 move_apply (op, tmp, tmp); 487 move_apply (op, tmp, tmp);
550 } 488 }
551 } 489 }
490
552 SET_ANIMATION (op, op->stats.wc); 491 SET_ANIMATION (op, op->stats.wc);
553 update_object (op, UP_OBJ_FACE); 492 update_object (op, UP_OBJ_FACE);
554 return; 493 return;
555 } 494 }
556 /* We're closing */ 495 /* We're closing */
557 op->move_on = 0; 496 op->move_on = 0;
558 497
559 op->stats.wc++; 498 op->stats.wc++;
560 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 499 if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
561 op->stats.wc = NUM_ANIMATIONS (op) - 1; 500 op->stats.wc = NUM_ANIMATIONS (op) - 1;
501
562 SET_ANIMATION (op, op->stats.wc); 502 SET_ANIMATION (op, op->stats.wc);
563 update_object (op, UP_OBJ_FACE); 503 update_object (op, UP_OBJ_FACE);
564 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 504 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
565 {
566 op->speed = 0;
567 update_ob_speed (op); /* closed, let's stop */ 505 op->set_speed (0); /* closed, let's stop */
568 return;
569 }
570} 506}
571 507
572 508
573/* 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
574 * 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
… …
600 op->destroy (); 536 op->destroy ();
601 return payload; 537 return payload;
602 } 538 }
603 539
604 case ARROW: 540 case ARROW:
605 if (op->speed >= MIN_ACTIVE_SPEED) 541 if (op->has_active_speed ())
606 op = fix_stopped_arrow (op); 542 op = fix_stopped_arrow (op);
607 return op; 543 return op;
608 544
609 default: 545 default:
610 return op; 546 return op;
… …
619void 555void
620fix_stopped_item (object *op, maptile *map, object *originator) 556fix_stopped_item (object *op, maptile *map, object *originator)
621{ 557{
622 if (map == NULL) 558 if (map == NULL)
623 return; 559 return;
560
624 if (QUERY_FLAG (op, FLAG_REMOVED)) 561 if (QUERY_FLAG (op, FLAG_REMOVED))
625 insert_ob_in_map (op, map, originator, 0); 562 insert_ob_in_map (op, map, originator, 0);
626 else if (op->type == ARROW) 563 else if (op->type == ARROW)
627 merge_ob (op, NULL); /* only some arrows actually need this */ 564 merge_ob (op, NULL); /* only some arrows actually need this */
628} 565}
629 566
630
631object * 567object *
632fix_stopped_arrow (object *op) 568fix_stopped_arrow (object *op)
633{ 569{
634 if (rndm (0, 99) < op->stats.food) 570 if (rndm (0, 99) < op->stats.food)
635 { 571 {
636 /* Small chance of breaking */ 572 /* Small chance of breaking */
637 op->destroy (); 573 op->destroy ();
638 return NULL; 574 return NULL;
639 } 575 }
640 576
577 op->set_speed (0);
641 op->direction = 0; 578 op->direction = 0;
642 op->move_on = 0; 579 op->move_on = 0;
643 op->move_type = 0; 580 op->move_type = 0;
644 op->speed = 0; 581 op->skill = 0; // really?
645 update_ob_speed (op); 582
583 // restore original wc, dam, attacktype and slaying
646 op->stats.wc = op->stats.sp; 584 op->stats.wc = op->stats.sp;
647 op->stats.dam = op->stats.hp; 585 op->stats.dam = op->stats.hp;
648 op->attacktype = op->stats.grace; 586 op->attacktype = op->stats.grace;
649 op->slaying = 0;
650 op->skill = 0;
651 587
652 if (op->spellarg != NULL) 588 if (op->spellarg)
653 { 589 {
654 op->slaying = op->spellarg; 590 op->slaying = op->spellarg;
655 free (op->spellarg); 591 free (op->spellarg);
656 op->spellarg = NULL; 592 op->spellarg = 0;
657 } 593 }
658 else 594 else
659 op->slaying = NULL; 595 op->slaying = 0;
660 596
661 /* 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 */
662 op->spellarg = NULL; 598 op->spellarg = NULL;
663 op->stats.sp = 0; 599 op->stats.sp = 0;
664 op->stats.hp = 0; 600 op->stats.hp = 0;
665 op->stats.grace = 0; 601 op->stats.grace = 0;
666 op->level = 0; 602 op->level = 0;
667 op->face = op->arch->clone.face; 603 op->face = op->arch->clone.face;
668 op->owner = NULL; /* So that stopped arrows will be saved */ 604 op->owner = NULL; /* So that stopped arrows will be saved */
669 update_object (op, UP_OBJ_FACE); 605 update_object (op, UP_OBJ_CHANGE);
670 return op; 606 return op;
671} 607}
672 608
673/* stop_arrow() - what to do when a non-living flying object 609/* stop_arrow() - what to do when a non-living flying object
674 * 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
675 * here too. -b.t. 611 * here too. -b.t.
676 * 612 *
677 * 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
678 * from maps or inventories), or NULL if was destroyed. 614 * from maps or inventories), or NULL if was destroyed.
679 */ 615 */
680
681static void 616static void
682stop_arrow (object *op) 617stop_arrow (object *op)
683{ 618{
684 if (INVOKE_OBJECT (STOP, op)) 619 if (INVOKE_OBJECT (STOP, op))
685 return; 620 return;
… …
694 op->destroy (); 629 op->destroy ();
695 } 630 }
696 else 631 else
697 { 632 {
698 op = fix_stopped_arrow (op); 633 op = fix_stopped_arrow (op);
634
699 if (op) 635 if (op)
700 merge_ob (op, NULL); 636 merge_ob (op, 0);
701 } 637 }
702} 638}
703 639
704/* 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.
705 */ 641 */
706
707void 642void
708move_arrow (object *op) 643move_arrow (object *op)
709{ 644{
710 object *tmp; 645 object *tmp;
711 sint16 new_x, new_y; 646 sint16 new_x, new_y;
… …
766 } 701 }
767 702
768 /* only need to look for living creatures if this flag is set */ 703 /* only need to look for living creatures if this flag is set */
769 if (mflags & P_IS_ALIVE) 704 if (mflags & P_IS_ALIVE)
770 { 705 {
771 for (tmp = get_map_ob (m, new_x, new_y); tmp != NULL; tmp = tmp->above) 706 for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above)
772 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 707 if (QUERY_FLAG (tmp, FLAG_ALIVE))
773 break; 708 break;
774 709
775 /* Not really fair, but don't let monsters hit themselves with 710 /* Not really fair, but don't let monsters hit themselves with
776 * their own arrow - this can be because they fire it then 711 * their own arrow - this can be because they fire it then
… …
782 * as below. (Note that for living creatures there is a small 717 * as below. (Note that for living creatures there is a small
783 * chance that reflect_missile fails.) 718 * chance that reflect_missile fails.)
784 */ 719 */
785 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))
786 { 721 {
787 int number = op->face->number; 722 int number = op->face;
788 723
789 op->direction = absdir (op->direction + 4); 724 op->direction = absdir (op->direction + 4);
790 op->state = 0; 725 update_turn_face (op);
791
792 if (GET_ANIM_ID (op))
793 {
794 number += 4;
795
796 if (number > GET_ANIMATION (op, 8))
797 number -= 8;
798
799 op->face = &new_faces[number];
800 }
801
802 was_reflected = 1; /* skip normal movement calculations */ 726 was_reflected = 1; /* skip normal movement calculations */
803 } 727 }
804 else 728 else
805 { 729 {
806 /* Attack the object. */ 730 /* Attack the object. */
… …
908 * Modified this routine to allow held objects. b.t. */ 832 * Modified this routine to allow held objects. b.t. */
909 833
910void 834void
911change_object (object *op) 835change_object (object *op)
912{ /* Doesn`t handle linked objs yet */ 836{ /* Doesn`t handle linked objs yet */
913 object *tmp, *env, *pl;
914 int i, j; 837 int i, j;
915 838
916 if (op->other_arch == NULL) 839 if (op->other_arch == NULL)
917 { 840 {
918 LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name); 841 LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name);
… …
925 if (op->stats.food-- > 0) 848 if (op->stats.food-- > 0)
926 return; 849 return;
927 else 850 else
928 op->stats.food = 1; /* so 1 other_arch is made */ 851 op->stats.food = 1; /* so 1 other_arch is made */
929 } 852 }
853
854 object *pl = op->in_player ();
930 env = op->env; 855 object *env = op->env;
856
931 op->remove (); 857 op->remove ();
932 for (i = 0; i < NROFNEWOBJS (op); i++) 858 for (i = 0; i < NROFNEWOBJS (op); i++)
933 { 859 {
934 tmp = arch_to_object (op->other_arch); 860 object *tmp = arch_to_object (op->other_arch);
861
935 if (op->type == LAMP) 862 if (op->type == LAMP)
936 tmp->stats.food = op->stats.food - 1; 863 tmp->stats.food = op->stats.food - 1;
864
937 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 865 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
938 if (env) 866 if (env)
939 { 867 {
940 tmp->x = env->x, tmp->y = env->y; 868 tmp->x = env->x, tmp->y = env->y;
941 tmp = insert_ob_in_ob (tmp, env); 869 tmp = insert_ob_in_ob (tmp, env);
870
942 /* If this object is the players inventory, we need to tell the 871 /* If this object is the players inventory, we need to tell the
943 * client of the change. Insert_ob_in_map takes care of the 872 * client of the change. Insert_ob_in_map takes care of the
944 * updating the client, so we don't need to do that below. 873 * updating the client, so we don't need to do that below.
945 */ 874 */
946 if ((pl = is_player_inv (env)) != NULL) 875 if (pl)
947 { 876 {
948 esrv_del_item (pl->contr, op->count); 877 esrv_del_item (pl->contr, op->count);
949 esrv_send_item (pl, tmp); 878 esrv_send_item (pl, tmp);
950 } 879 }
951 } 880 }
… …
975 * there is an old multipart teleporter in which the other parts 904 * there is an old multipart teleporter in which the other parts
976 * 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
977 * function - in fact, as written below, part N would get called 906 * function - in fact, as written below, part N would get called
978 * N times without the speed check. 907 * N times without the speed check.
979 */ 908 */
980 if (op->more && FABS (op->more->speed) < MIN_ACTIVE_SPEED) 909 if (op->more && !op->more->has_active_speed ())
981 move_teleporter (op->more); 910 move_teleporter (op->more);
982 911
983 if (op->head) 912 if (op->head)
984 head = op->head; 913 head = op->head;
985 914
… …
996 if (tmp->type == PLAYER) 925 if (tmp->type == PLAYER)
997 { 926 {
998 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 927 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
999 return; 928 return;
1000 929
1001 enter_exit (tmp, head); 930 tmp->enter_exit (head);
1002 } 931 }
1003 else 932 else
1004 /* Currently only players can transfer maps */ 933 /* Currently only players can transfer maps */
1005 return; 934 return;
1006 } 935 }
… …
1031/* This object will teleport someone to a different map 960/* This object will teleport someone to a different map
1032 and will also apply changes to the player from its inventory. 961 and will also apply changes to the player from its inventory.
1033 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
1034 can't be generalized. 963 can't be generalized.
1035*/ 964*/
1036
1037void 965void
1038move_player_changer (object *op) 966move_player_changer (object *op)
1039{ 967{
1040 object *player; 968 object *player;
1041 object *walk; 969 object *walk;
1042 char c;
1043 970
1044 if (!op->above || !EXIT_PATH (op)) 971 if (!op->above || !EXIT_PATH (op))
1045 return; 972 return;
1046 973
1047 /* This isn't all that great - means that the player_mover 974 /* This isn't all that great - means that the player_mover
1048 * needs to be on top. 975 * needs to be on top.
1049 */ 976 */
1050 if (op->above->type == PLAYER) 977 if (op->above->type == PLAYER)
1051 { 978 {
1052 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 979 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
1053 return; 980 return;
981
1054 player = op->above; 982 player = op->above;
1055 983
1056 for (walk = op->inv; walk != NULL; walk = walk->below) 984 for (walk = op->inv; walk; walk = walk->below)
1057 apply_changes_to_player (player, walk); 985 apply_changes_to_player (player, walk);
1058 986
1059 fix_player (player); 987 player->update_stats ();
1060 988
1061 esrv_send_inventory (op->above, op->above); 989 esrv_send_inventory (op->above, op->above);
1062 esrv_update_item (UPD_FACE, op->above, op->above); 990 esrv_update_item (UPD_FACE, op->above, op->above);
1063 991
1064 /* update players death & WoR home-position */ 992 /* update players death & WoR home-position */
1065 sscanf (EXIT_PATH (op), "%c", &c); 993 if (*EXIT_PATH (op) == '/')
1066 if (c == '/')
1067 { 994 {
1068 strcpy (player->contr->savebed_map, EXIT_PATH (op)); 995 player->contr->savebed_map = EXIT_PATH (op);
1069 player->contr->bed_x = EXIT_X (op); 996 player->contr->bed_x = EXIT_X (op);
1070 player->contr->bed_y = EXIT_Y (op); 997 player->contr->bed_y = EXIT_Y (op);
1071 } 998 }
1072 else 999 else
1073 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));
1074 1001
1075 enter_exit (op->above, op); 1002 op->above->enter_exit (op);
1076 save_player (player, 1);
1077 } 1003 }
1078} 1004}
1079 1005
1080/* firewalls fire other spells. 1006/* firewalls fire other spells.
1081 * The direction of the wall is stored in op->stats.sp. 1007 * The direction of the wall is stored in op->stats.sp.
… …
1088 1014
1089 if (!op->map) 1015 if (!op->map)
1090 return; /* dm has created a firewall in his inventory */ 1016 return; /* dm has created a firewall in his inventory */
1091 1017
1092 spell = op->inv; 1018 spell = op->inv;
1019
1093 if (!spell || spell->type != SPELL) 1020 if (!spell || spell->type != SPELL)
1094 spell = &op->other_arch->clone; 1021 spell = &op->other_arch->clone;
1022
1095 if (!spell) 1023 if (!spell)
1096 { 1024 {
1097 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);
1098 return; 1026 return;
1099 } 1027 }
1100 1028
1101 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);
1102} 1030}
1103
1104 1031
1105/* move_player_mover: this function takes a "player mover" as an 1032/* move_player_mover: this function takes a "player mover" as an
1106 * argument, and performs the function of a player mover, which is: 1033 * argument, and performs the function of a player mover, which is:
1107 * 1034 *
1108 * a player mover finds any players that are sitting on it. It 1035 * a player mover finds any players that are sitting on it. It
… …
1112 * it'll paralyze the victim for hp*his speed/op->speed 1039 * it'll paralyze the victim for hp*his speed/op->speed
1113 */ 1040 */
1114void 1041void
1115move_player_mover (object *op) 1042move_player_mover (object *op)
1116{ 1043{
1117 object *victim, *nextmover;
1118 int dir = op->stats.sp; 1044 int dir = op->stats.sp;
1119 sint16 nx, ny; 1045 sint16 nx, ny;
1120 maptile *m; 1046 maptile *m;
1121 1047
1122 /* 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 */
1123 if (!dir) 1049 if (!dir)
1124 dir = rndm (1, 8); 1050 dir = rndm (1, 8);
1125 1051
1126 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)
1127 { 1053 {
1128 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1054 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&
1129 (victim->move_type & op->move_type || !victim->move_type)) 1055 (victim->move_type & op->move_type || !victim->move_type))
1130 { 1056 {
1131 1057
… …
1141 nx = op->x + freearr_x[dir]; 1067 nx = op->x + freearr_x[dir];
1142 ny = op->y + freearr_y[dir]; 1068 ny = op->y + freearr_y[dir];
1143 m = op->map; 1069 m = op->map;
1144 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)
1145 { 1071 {
1146 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);
1147 return; 1073 return;
1148 } 1074 }
1149 1075
1150 if (should_director_abort (op, victim)) 1076 if (should_director_abort (op, victim))
1151 return; 1077 return;
1152 1078
1153 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)
1154 { 1080 {
1155 if (nextmover->type == PLAYERMOVER) 1081 if (nextmover->type == PLAYERMOVER)
1156 nextmover->speed_left = -.99; 1082 nextmover->speed_left = -.99f;
1083
1157 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1084 if (QUERY_FLAG (nextmover, FLAG_ALIVE))
1158 {
1159 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 */
1160 }
1161 } 1086 }
1162 1087
1163 if (victim->type == PLAYER) 1088 if (victim->type == PLAYER)
1164 { 1089 {
1165 /* only level >=1 movers move people */ 1090 /* only level >=1 movers move people */
… …
1169 * is cleared, otherwise the player will get stuck in 1094 * is cleared, otherwise the player will get stuck in
1170 * place. This can happen if the player used a spell to 1095 * place. This can happen if the player used a spell to
1171 * get to this space. 1096 * get to this space.
1172 */ 1097 */
1173 victim->contr->fire_on = 0; 1098 victim->contr->fire_on = 0;
1174 victim->speed_left = -FABS (victim->speed); 1099 victim->speed_left = 0.f;
1175 move_player (victim, dir); 1100 move_player (victim, dir);
1176 } 1101 }
1177 else 1102 else
1178 return; 1103 return;
1179 } 1104 }
… …
1183 if (!op->stats.maxsp && op->attacktype) 1108 if (!op->stats.maxsp && op->attacktype)
1184 op->stats.maxsp = 2; 1109 op->stats.maxsp = 2;
1185 1110
1186 if (op->attacktype) 1111 if (op->attacktype)
1187 { /* flag to paralyze the player */ 1112 { /* flag to paralyze the player */
1188
1189 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));
1190 /* Not sure why, but for some chars on metalforge, they
1191 * would sometimes get -inf speed_left, and from the
1192 * description, it could only happen here, so just put
1193 * a lower sanity limit. My only guess is that the
1194 * mover has 0 speed.
1195 */
1196 if (victim->speed_left < -5.0)
1197 victim->speed_left = -5.0;
1198 } 1114 }
1199 } 1115 }
1200 } 1116 }
1201} 1117}
1202 1118
… …
1212{ 1128{
1213 object *tmp; 1129 object *tmp;
1214 1130
1215 if (!op->other_arch) 1131 if (!op->other_arch)
1216 { 1132 {
1217 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");
1218 return; 1134 return;
1219 } 1135 }
1220 1136
1221 if (op->above == NULL) 1137 if (op->above == NULL)
1222 return; 1138 return;
1139
1223 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 1140 for (tmp = op->above; tmp; tmp = tmp->above)
1224 { 1141 {
1225 if (strcmp (op->other_arch->name, tmp->arch->name) == 0) 1142 if (op->other_arch->name == tmp->arch->name)
1226 { 1143 {
1227 if (op->level <= 0) 1144 if (op->level <= 0)
1228 tmp->destroy (); 1145 tmp->destroy ();
1229 else 1146 else
1230 { 1147 {
… …
1287 } 1204 }
1288 else 1205 else
1289 { 1206 {
1290 if (creator->other_arch == NULL) 1207 if (creator->other_arch == NULL)
1291 { 1208 {
1292 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",
1293 creator->x, creator->y); 1210 &creator->name, &creator->map->path, creator->x, creator->y);
1294 return; 1211 return;
1295 } 1212 }
1296 1213
1297 new_ob = object_create_arch (creator->other_arch); 1214 new_ob = object_create_arch (creator->other_arch);
1298 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1215 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
… …
1321 with a specific code as the slaying field. 1238 with a specific code as the slaying field.
1322 At that time, it writes the contents of its own message 1239 At that time, it writes the contents of its own message
1323 field to the player. The marker will decrement hp to 1240 field to the player. The marker will decrement hp to
1324 0 and then delete itself every time it grants a mark. 1241 0 and then delete itself every time it grants a mark.
1325 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.*/
1326
1327void 1243void
1328move_marker (object *op) 1244move_marker (object *op)
1329{ 1245{
1246 if (object *tmp = op->ms ().player ())
1247 {
1330 object *tmp, *tmp2; 1248 object *tmp2;
1331 1249
1332 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1333 {
1334 if (tmp->type == PLAYER)
1335 { /* we've got someone to MARK */
1336
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 != NULL; tmp2 = tmp2->below) 1251 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1252 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->name)
1339 { 1253 {
1340 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->name))
1341 break;
1342 }
1343
1344 if (tmp2)
1345 tmp2->destroy (); 1254 tmp2->destroy ();
1255 break;
1256 }
1346 1257
1347 /* 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
1348 * place 1259 * place
1349 */ 1260 */
1350 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1261 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1351 {
1352 if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying)) 1262 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
1353 break; 1263 break;
1354 }
1355 1264
1356 /* if we didn't find our own MARK */ 1265 /* if we didn't find our own MARK */
1357 if (tmp2 == NULL) 1266 if (!tmp2)
1358 { 1267 {
1359 object *force = get_archetype (FORCE_NAME); 1268 object *force = get_archetype (FORCE_NAME);
1360 1269
1361 force->speed = 0;
1362 if (op->stats.food) 1270 if (op->stats.food)
1271 {
1272 force->set_speed (0.01);
1273 force->speed_left = -op->stats.food;
1274 }
1275 else
1276 force->set_speed (0);
1277
1278 /* put in the lock code */
1279 force->slaying = op->slaying;
1280
1281 if (op->lore)
1282 force->lore = op->lore;
1283
1284 insert_ob_in_ob (force, tmp);
1285 if (op->msg)
1286 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1287
1288 if (op->stats.hp > 0)
1289 {
1290 op->stats.hp--;
1291 if (op->stats.hp == 0)
1363 { 1292 {
1364 force->speed = 0.01; 1293 /* marker expires--granted mark number limit */
1365 force->speed_left = -op->stats.food; 1294 op->destroy ();
1295 return;
1366 } 1296 }
1367 update_ob_speed (force);
1368 /* put in the lock code */
1369 force->slaying = op->slaying;
1370
1371 if (op->lore)
1372 force->lore = op->lore;
1373
1374 insert_ob_in_ob (force, tmp);
1375 if (op->msg)
1376 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1377
1378 if (op->stats.hp > 0)
1379 {
1380 op->stats.hp--;
1381 if (op->stats.hp == 0)
1382 {
1383 /* marker expires--granted mark number limit */
1384 op->destroy ();
1385 return;
1386 }
1387 } 1297 }
1388 } /* if tmp2 == NULL */ 1298 }
1389 } /* if tmp->type == PLAYER */ 1299 }
1390 } /* For all objects on this space */
1391} 1300}
1392 1301
1393int 1302void
1394process_object (object *op) 1303process_object (object *op)
1395{ 1304{
1396 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 1305 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
1397 return 0; 1306 return;
1398 1307
1399 if (INVOKE_OBJECT (TICK, op)) 1308 if (INVOKE_OBJECT (TICK, op))
1400 return 0; 1309 return;
1401 1310
1402 if (QUERY_FLAG (op, FLAG_MONSTER)) 1311 if (QUERY_FLAG (op, FLAG_MONSTER))
1403 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1312 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED))
1404 return 1; 1313 return;
1405 1314
1406 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1315 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0)
1407 { 1316 {
1408 if (op->type == PLAYER)
1409 animate_object (op, op->facing);
1410 else
1411 animate_object (op, op->direction); 1317 animate_object (op, op->contr ? op->facing : op->direction);
1412 1318
1413 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1319 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1414 make_sure_seen (op); 1320 make_sure_seen (op);
1415 } 1321 }
1416 1322
1323 if (op->flag [FLAG_GENERATOR]
1324 || op->flag [FLAG_CHANGING]
1325 || op->flag [FLAG_IS_USED_UP])
1326 {
1417 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1327 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
1418 { 1328 {
1419 change_object (op); 1329 change_object (op);
1420 return 1; 1330 return;
1421 } 1331 }
1422 1332
1423 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1333 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY))
1424 generate_monster (op); 1334 generate_monster (op);
1425 1335
1426 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)
1427 { 1337 {
1428 if (QUERY_FLAG (op, FLAG_APPLIED)) 1338 if (QUERY_FLAG (op, FLAG_APPLIED))
1429 remove_force (op); 1339 remove_force (op);
1430 else 1340 else
1431 { 1341 {
1432 /* IF necessary, delete the item from the players inventory */ 1342 /* If necessary, delete the item from the players inventory */
1433 object *pl = is_player_inv (op); 1343 object *pl = op->in_player ();
1434 1344
1435 if (pl) 1345 if (pl)
1436 esrv_del_item (pl->contr, op->count); 1346 esrv_del_item (pl->contr, op->count);
1437 1347
1438 op->remove (); 1348 op->remove ();
1439 1349
1440 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1350 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1441 make_sure_not_seen (op); 1351 make_sure_not_seen (op);
1442 1352
1443 op->destroy (); 1353 op->destroy ();
1444 } 1354 }
1445 1355
1446 return 1; 1356 return;
1357 }
1447 } 1358 }
1448 1359
1449 switch (op->type) 1360 switch (op->type)
1450 { 1361 {
1451 case SPELL_EFFECT: 1362 case SPELL_EFFECT:
1452 move_spell_effect (op); 1363 move_spell_effect (op);
1453 return 1; 1364 break;
1454 1365
1455 case ROD: 1366 case ROD:
1456 case HORN: 1367 case HORN:
1457 regenerate_rod (op); 1368 regenerate_rod (op);
1458 return 1; 1369 break;
1459 1370
1460 case FORCE: 1371 case FORCE:
1461 case POTION_EFFECT: 1372 case POTION_EFFECT:
1462 remove_force (op); 1373 remove_force (op);
1463 return 1; 1374 break;
1464 1375
1465 case BLINDNESS: 1376 case BLINDNESS:
1466 remove_blindness (op); 1377 remove_blindness (op);
1467 return 0; 1378 break;
1468 1379
1469 case POISONING: 1380 case POISONING:
1470 poison_more (op); 1381 poison_more (op);
1471 return 0; 1382 break;
1472 1383
1473 case DISEASE: 1384 case DISEASE:
1474 move_disease (op); 1385 move_disease (op);
1475 return 0; 1386 break;
1476 1387
1477 case SYMPTOM: 1388 case SYMPTOM:
1478 move_symptom (op); 1389 move_symptom (op);
1479 return 0; 1390 break;
1480 1391
1481 case THROWN_OBJ: 1392 case THROWN_OBJ:
1482 case ARROW: 1393 case ARROW:
1483 move_arrow (op); 1394 move_arrow (op);
1484 return 0; 1395 break;
1485
1486 case LIGHTNING: /* It now moves twice as fast */
1487 move_bolt (op);
1488 return 0;
1489 1396
1490 case DOOR: 1397 case DOOR:
1491 remove_door (op); 1398 remove_door (op);
1492 return 0; 1399 break;
1493 1400
1494 case LOCKED_DOOR: 1401 case LOCKED_DOOR:
1495 remove_door2 (op); 1402 remove_door2 (op);
1496 return 0; 1403 break;
1497 1404
1498 case TELEPORTER: 1405 case TELEPORTER:
1499 move_teleporter (op); 1406 move_teleporter (op);
1500 return 0; 1407 break;
1501 1408
1502 case GOLEM: 1409 case GOLEM:
1503 move_golem (op); 1410 move_golem (op);
1504 return 0; 1411 break;
1505 1412
1506 case EARTHWALL: 1413 case EARTHWALL:
1507 hit_player (op, 2, op, AT_PHYSICAL, 1); 1414 hit_player (op, 2, op, AT_PHYSICAL, 1);
1508 return 0; 1415 break;
1509 1416
1510 case FIREWALL: 1417 case FIREWALL:
1511 move_firewall (op); 1418 move_firewall (op);
1512 if (op->stats.maxsp) 1419 if (op->stats.maxsp)
1513 animate_turning (op); 1420 animate_turning (op);
1514 return 0; 1421 break;
1515 1422
1516 case MOOD_FLOOR: 1423 case MOOD_FLOOR:
1517 do_mood_floor (op); 1424 do_mood_floor (op);
1518 return 0; 1425 break;
1519 1426
1520 case GATE: 1427 case GATE:
1521 move_gate (op); 1428 move_gate (op);
1522 return 0; 1429 break;
1523 1430
1524 case TIMED_GATE: 1431 case TIMED_GATE:
1525 move_timed_gate (op); 1432 move_timed_gate (op);
1526 return 0; 1433 break;
1527 1434
1528 case TRIGGER: 1435 case TRIGGER:
1529 case TRIGGER_BUTTON: 1436 case TRIGGER_BUTTON:
1530 case TRIGGER_PEDESTAL: 1437 case TRIGGER_PEDESTAL:
1531 case TRIGGER_ALTAR: 1438 case TRIGGER_ALTAR:
1532 animate_trigger (op); 1439 animate_trigger (op);
1533 return 0; 1440 break;
1534 1441
1535 case DETECTOR: 1442 case DETECTOR:
1536 move_detector (op); 1443 move_detector (op);
1537 1444
1538 case DIRECTOR: 1445 case DIRECTOR:
1539 if (op->stats.maxsp) 1446 if (op->stats.maxsp)
1540 animate_turning (op); 1447 animate_turning (op);
1541 return 0; 1448 break;
1542 1449
1543 case HOLE: 1450 case HOLE:
1544 move_hole (op); 1451 move_hole (op);
1545 return 0; 1452 break;
1546 1453
1547 case DEEP_SWAMP: 1454 case DEEP_SWAMP:
1548 move_deep_swamp (op); 1455 move_deep_swamp (op);
1549 return 0; 1456 break;
1550 1457
1551 case RUNE: 1458 case RUNE:
1552 case TRAP: 1459 case TRAP:
1553 move_rune (op); 1460 move_rune (op);
1554 return 0; 1461 break;
1555 1462
1556 case PLAYERMOVER: 1463 case PLAYERMOVER:
1557 move_player_mover (op); 1464 move_player_mover (op);
1558 return 0; 1465 break;
1559 1466
1560 case CREATOR: 1467 case CREATOR:
1561 move_creator (op); 1468 move_creator (op);
1562 return 0; 1469 break;
1563 1470
1564 case MARKER: 1471 case MARKER:
1565 move_marker (op); 1472 move_marker (op);
1566 return 0; 1473 break;
1567 1474
1568 case PLAYER_CHANGER: 1475 case PLAYER_CHANGER:
1569 move_player_changer (op); 1476 move_player_changer (op);
1570 return 0; 1477 break;
1571 1478
1572 case PEACEMAKER: 1479 case PEACEMAKER:
1573 move_peacemaker (op); 1480 move_peacemaker (op);
1574 return 0; 1481 break;
1575 }
1576 1482
1577 return 0; 1483 case PLAYER:
1484 // players have their own speed-management, so undo the --speed_left
1485 ++op->speed_left;
1486 break;
1487 }
1578} 1488}
1489

Diff Legend

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