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.75 by root, Sun May 4 08:25:33 2008 UTC vs.
Revision 1.128 by root, Wed Dec 5 19:03:27 2018 UTC

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

Diff Legend

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