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.88 by elmex, Tue Jan 13 12:17:01 2009 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);
… …
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->drop_and_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
… …
106 return; 108 return;
107 109
108 object *op; 110 object *op;
109 int dir; 111 int dir;
110 112
111 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 113 if (gen->flag [FLAG_CONTENT_ON_GEN])
112 { 114 {
113 // either copy one item from the inventory... 115 // either copy one item from the inventory...
114 if (!gen->inv) 116 if (!gen->inv)
115 return; 117 return;
116 118
… …
124 if (dir < 0) 126 if (dir < 0)
125 return; 127 return;
126 128
127 op = op->deep_clone (); 129 op = op->deep_clone ();
128 130
129 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 131 op->clr_flag (FLAG_IS_A_TEMPLATE);
130 unflag_inv (op, FLAG_IS_A_TEMPLATE); 132 unflag_inv (op, FLAG_IS_A_TEMPLATE);
131 } 133 }
132 else if (gen->other_arch) 134 else if (gen->other_arch)
133 { 135 {
134 // ...or use other_arch 136 // ...or use other_arch
135 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);
136 if (dir < 0) 138 if (dir < 0)
137 return; 139 return;
138 140
139 op = arch_to_object (gen->other_arch); 141 op = gen->other_arch->instance ();
140 } 142 }
141 else 143 else
142 return; 144 return;
143 145
144 op->expand_tail (); 146 op->expand_tail ();
… …
157 } 159 }
158 160
159 op->destroy (); 161 op->destroy ();
160} 162}
161 163
162void 164static void
163remove_force (object *op) 165remove_force (object *op)
164{ 166{
165 if (--op->duration > 0) 167 if (--op->duration > 0)
166 return; 168 return;
167 169
168 if (op->env) 170 if (op->env)
169 switch (op->subtype) 171 switch (op->subtype)
170 { 172 {
171 case FORCE_CONFUSION: 173 case FORCE_CONFUSION:
172 CLEAR_FLAG (op->env, FLAG_CONFUSED); 174 op->env->clr_flag (FLAG_CONFUSED);
173 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");
174 176
175 default: 177 default:
176 CLEAR_FLAG (op, FLAG_APPLIED); 178 op->clr_flag (FLAG_APPLIED);
177 change_abil (op->env, op); 179 change_abil (op->env, op);
178 op->env->update_stats (); 180 op->env->update_stats ();
179 } 181 }
180 182
181 op->destroy (); 183 op->destroy ();
182} 184}
183 185
184void 186static void
185remove_blindness (object *op) 187remove_blindness (object *op)
186{ 188{
187 if (--op->stats.food > 0) 189 if (--op->stats.food > 0)
188 return; 190 return;
189 191
190 CLEAR_FLAG (op, FLAG_APPLIED); 192 op->clr_flag (FLAG_APPLIED);
191 193
192 if (op->env) 194 if (op->env)
193 { 195 {
194 change_abil (op->env, op); 196 change_abil (op->env, op);
195 op->env->update_stats (); 197 op->env->update_stats ();
196 } 198 }
197 199
198 op->destroy (); 200 op->destroy ();
199} 201}
200 202
201void 203static void
202poison_more (object *op) 204poison_more (object *op)
203{ 205{
204 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)
205 { 207 {
206 op->destroy (); 208 op->destroy ();
207 return; 209 return;
208 } 210 }
209 211
… …
212 /* 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
213 * will not do anything. 215 * will not do anything.
214 */ 216 */
215 if (op->env->type == PLAYER) 217 if (op->env->type == PLAYER)
216 { 218 {
217 CLEAR_FLAG (op, FLAG_APPLIED); 219 op->clr_flag (FLAG_APPLIED);
218 op->env->update_stats (); 220 op->env->update_stats ();
219 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.");
220 } 222 }
221 223
222 op->destroy (); 224 op->destroy ();
… …
231 233
232 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 234 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
233} 235}
234 236
235 237
236void 238static void
237move_gate (object *op) 239move_gate (object *op)
238{ /* 1 = going down, 0 = going up */ 240{ /* 1 = going down, 0 = going up */
239 object *tmp; 241 object *tmp;
240 242
241 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 243 if (uint32_t (op->stats.wc) >= op->anim_frames ())
242 { 244 {
243 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 ());
244 op->stats.wc = 0; 246 op->stats.wc = 0;
245 } 247 }
246 248
247 /* We're going down */
248 if (op->value) 249 if (op->value)
249 { 250 {
251 /* We're going down */
250 if (--op->stats.wc <= 0) 252 if (--op->stats.wc <= 0)
251 { /* Reached bottom, let's stop */ 253 { /* Reached bottom, let's stop */
252 op->stats.wc = 0; 254 op->stats.wc = 0;
253 if (op->arch->speed) 255 if (op->arch->has_active_speed ())
254 op->value = 0; 256 op->value = 0;
255 else 257 else
256 op->set_speed (0); 258 op->set_speed (0);
257 } 259 }
258 260
259 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 261 if (op->stats.wc < op->anim_frames () / 2 + 1)
260 { 262 {
261 op->move_block = 0; 263 op->move_block = 0;
262 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 264 op->clr_flag (FLAG_BLOCKSVIEW);
263 update_all_los (op->map, op->x, op->y); 265 update_all_los (op->map, op->x, op->y);
264 } 266 }
265
266 SET_ANIMATION (op, op->stats.wc);
267 update_object (op, UP_OBJ_CHANGE);
268 return;
269 }
270
271 /* We're going up */
272
273 /* First, lets see if we are already at the top */
274 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
275 {
276
277 /* Check to make sure that only non pickable and non rollable
278 * objects are above the gate. If so, we finish closing the gate,
279 * otherwise, we fall through to the code below which should lower
280 * the gate slightly.
281 */
282
283 for (tmp = op->above; tmp; tmp = tmp->above)
284 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
285 break;
286
287 if (!tmp)
288 {
289 if (op->arch->speed)
290 op->value = 1;
291 else
292 op->set_speed (0);
293
294 return;
295 }
296 }
297
298 if (op->stats.food)
299 { /* The gate is going temporarily down */
300 if (--op->stats.wc <= 0)
301 { /* Gone all the way down? */
302 op->stats.food = 0; /* Then let's try again */
303 op->stats.wc = 0;
304 }
305 } 267 }
306 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
307 { /* The gate is still going up */ 305 { /* The gate is still going up */
308 op->stats.wc++; 306 op->stats.wc++;
307 min_it (op->stats.wc, op->anim_frames () - 1);
309 308
310 if (op->stats.wc >= NUM_ANIMATIONS (op))
311 op->stats.wc = NUM_ANIMATIONS (op) - 1;
312
313 /* 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.
314 * 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
315 */ 311 */
316 if (op->stats.wc >= NUM_ANIMATIONS (op) / 2) 312 if (op->stats.wc >= op->anim_frames () / 2)
317 { 313 {
318 /* Halfway or further, check blocks */ 314 /* Halfway or further, check blocks */
319 /* First, get the top object on the square. */ 315 /* First, get the top object on the square. */
320 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 316 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
321 ; 317 ;
322 318
323 if (tmp) 319 if (tmp)
324 {
325 if (QUERY_FLAG (tmp, FLAG_ALIVE))
326 { 320 {
327 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 321 if (tmp->flag [FLAG_ALIVE])
328 op->play_sound (sound_find ("blocked_gate"));
329
330 if (tmp->type == PLAYER)
331 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
332 }
333 /* If the object is not alive, and the object either can
334 * be picked up or the object rolls, move the object
335 * off the gate.
336 */
337 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
338 {
339 /* If it has speed, it should move itself, otherwise: */
340 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
341
342 /* If there is a free spot, move the object someplace */
343 if (i > 0)
344 { 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 {
345 mapxy pos (tmp); 341 mapxy pos (tmp);
346 pos.move (i); 342 pos.move (i);
347 if (pos.normalise ()) 343 if (pos.normalise ())
348 tmp->move_to (pos); 344 tmp->move_to (pos);
345 }
349 } 346 }
350 } 347 }
351 }
352 348
353 /* See if there is still anything blocking the gate */ 349 /* See if there is still anything blocking the gate */
354 for (tmp = op->above; tmp; tmp = tmp->above) 350 for (tmp = op->above; tmp; tmp = tmp->above)
355 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])
356 break; 352 break;
357 353
358 /* IF there is, start putting the gate down */ 354 /* IF there is, start putting the gate down */
359 if (tmp) 355 if (tmp)
360 op->stats.food = 1; 356 op->stats.food = 1;
361 else 357 else
362 { 358 {
363 op->move_block = MOVE_ALL; 359 op->move_block = MOVE_ALL;
364 360
365 if (!op->arch->stats.ac) 361 if (!op->arch->stats.ac)
366 SET_FLAG (op, FLAG_BLOCKSVIEW); 362 op->set_flag (FLAG_BLOCKSVIEW);
363
367 update_all_los (op->map, op->x, op->y); 364 update_all_los (op->map, op->x, op->y);
368 } 365 }
369 } /* gate is halfway up */ 366 } /* gate is halfway up */
370
371 SET_ANIMATION (op, op->stats.wc);
372 update_object (op, UP_OBJ_CHANGE);
373 } /* gate is going up */ 367 } /* gate is going up */
368 }
369
370 op->update_anim_frame (op->stats.wc);
374} 371}
375 372
376/* hp : how long door is open/closed 373/* hp : how long door is open/closed
377 * maxhp : initial value for hp 374 * maxhp : initial value for hp
378 * sp : 1 = open, 0 = close 375 * sp : 1 = open, 0 = close
379 */ 376 */
380void 377static void
381move_timed_gate (object *op) 378move_timed_gate (object *op)
382{ 379{
383 int v = op->value; 380 int v = op->value;
384 381
385 if (op->stats.sp) 382 if (op->stats.sp)
… …
404 * speed: frequency of 'glances' 401 * speed: frequency of 'glances'
405 * connected: connected value of detector 402 * connected: connected value of detector
406 * sp: 1 if detection sets buttons 403 * sp: 1 if detection sets buttons
407 * -1 if detection unsets buttons 404 * -1 if detection unsets buttons
408 */ 405 */
409 406static void
410void
411move_detector (object *op) 407move_detector (object *op)
412{ 408{
413 object *tmp; 409 object *tmp;
414 int last = op->value; 410 int last = op->value;
415 int detected; 411 int detected;
… …
470} 466}
471 467
472void 468void
473animate_trigger (object *op) 469animate_trigger (object *op)
474{ 470{
475 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 471 if (uint32_t (++op->stats.wc) >= op->anim_frames ())
476 { 472 {
477 op->stats.wc = 0; 473 op->stats.wc = 0;
478 check_trigger (op, NULL); 474 check_trigger (op, NULL);
479 } 475 }
480 else 476 else
481 { 477 op->update_anim_frame (op->stats.wc);
482 SET_ANIMATION (op, op->stats.wc);
483 update_object (op, UP_OBJ_FACE);
484 }
485} 478}
486 479
487void 480static void
488move_hole (object *op) 481move_hole (object *op)
489{ /* 1 = opening, 0 = closing */ 482{ /* 1 = opening, 0 = closing */
490 if (op->value) 483 if (op->value)
491 { /* We're opening */ 484 {
485 /* We're opening */
486 op->stats.wc--;
492 if (--op->stats.wc <= 0) 487 if (op->stats.wc <= 0)
493 { /* Opened, let's stop */ 488 { /* Opened, let's stop */
494 op->stats.wc = 0; 489 op->stats.wc = 0;
495 op->set_speed (0); 490 op->set_speed (0);
496 491
497 /* Hard coding this makes sense for holes I suppose */ 492 /* Hard coding this makes sense for holes I suppose */
… …
500 { 495 {
501 next = tmp->above; 496 next = tmp->above;
502 move_apply (op, tmp, tmp); 497 move_apply (op, tmp, tmp);
503 } 498 }
504 } 499 }
505 500 }
506 SET_ANIMATION (op, op->stats.wc); 501 else
507 update_object (op, UP_OBJ_FACE);
508 return;
509 } 502 {
510
511 /* We're closing */ 503 /* We're closing */
512 op->move_on = 0; 504 op->move_on = 0;
513 505
514 op->stats.wc++; 506 op->stats.wc++;
515 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 507 if (op->stats.wc >= op->anim_frames ())
516 op->stats.wc = NUM_ANIMATIONS (op) - 1; 508 {
517 509 op->stats.wc = op->anim_frames () - 1;
518 SET_ANIMATION (op, op->stats.wc);
519 update_object (op, UP_OBJ_FACE);
520 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
521 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);
522} 515}
523 516
524 517
525/* 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
526 * 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
… …
573fix_stopped_item (object *op, maptile *map, object *originator) 566fix_stopped_item (object *op, maptile *map, object *originator)
574{ 567{
575 if (map == NULL) 568 if (map == NULL)
576 return; 569 return;
577 570
578 if (QUERY_FLAG (op, FLAG_REMOVED)) 571 if (op->flag [FLAG_REMOVED])
579 insert_ob_in_map (op, map, originator, 0); 572 insert_ob_in_map (op, map, originator, 0);
580 else if (op->type == ARROW) 573 else if (op->type == ARROW)
581 merge_ob (op, NULL); /* only some arrows actually need this */ 574 merge_ob (op, NULL); /* only some arrows actually need this */
582} 575}
583 576
… …
599 592
600 // restore original wc, dam, attacktype and slaying 593 // restore original wc, dam, attacktype and slaying
601 op->stats.wc = op->stats.sp; 594 op->stats.wc = op->stats.sp;
602 op->stats.dam = op->stats.hp; 595 op->stats.dam = op->stats.hp;
603 op->attacktype = op->stats.grace; 596 op->attacktype = op->stats.grace;
597 op->slaying = op->custom_name;
604 598
605 if (op->spellarg)
606 {
607 op->slaying = op->spellarg;
608 free (op->spellarg);
609 op->spellarg = 0;
610 }
611 else
612 op->slaying = 0;
613
614 /* 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 */
615 op->spellarg = NULL; 600 op->custom_name = 0;
616 op->stats.sp = 0; 601 op->stats.sp = 0;
617 op->stats.hp = 0; 602 op->stats.hp = 0;
618 op->stats.grace = 0; 603 op->stats.grace = 0;
619 op->level = 0; 604 op->level = 0;
620 op->face = op->arch->face; 605 op->face = op->arch->face;
621 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
622 update_object (op, UP_OBJ_CHANGE); 610 update_object (op, UP_OBJ_CHANGE);
611
623 return op; 612 return op;
624} 613}
625 614
626/* stop_arrow() - what to do when a non-living flying object 615/* stop_arrow() - what to do when a non-living flying object
627 * 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
… …
652 if (op) 641 if (op)
653 merge_ob (op, 0); 642 merge_ob (op, 0);
654 } 643 }
655} 644}
656 645
657/* 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.
658 */ 647 */
659void 648void
660move_arrow (object *op) 649move_arrow (object *op)
661{ 650{
662 int was_reflected; 651 int was_reflected;
663 652
664 if (!op->map) 653 if (!op->map)
665 { 654 {
666 LOG (llevError, "BUG: Arrow had no map.\n"); 655 LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
667 op->destroy (); 656 op->destroy ();
668 return; 657 return;
669 } 658 }
670 659
671 /* we need to stop thrown objects at some point. Like here. */ 660 /* we need to stop thrown objects at some point. Like here. */
… …
690 stop_arrow (op); 679 stop_arrow (op);
691 return; 680 return;
692 } 681 }
693 } 682 }
694 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
695 /* 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
696 values look rediculous. */ 690 values look ridiculous. */
697 if (op->speed < 0.5 && op->type == ARROW) 691 if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
698 { 692 {
699 stop_arrow (op); 693 stop_arrow (op);
700 return; 694 return;
701 } 695 }
702 696
… …
715 if (pos->flags () & P_IS_ALIVE) 709 if (pos->flags () & P_IS_ALIVE)
716 { 710 {
717 object *tmp; 711 object *tmp;
718 712
719 for (tmp = pos->bot; tmp; tmp = tmp->above) 713 for (tmp = pos->bot; tmp; tmp = tmp->above)
720 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 714 if (tmp->flag [FLAG_ALIVE] && tmp != op->owner)
721 break; 715 {
722
723 /* Not really fair, but don't let monsters hit themselves with 716 /* Not really fair, but don't let monsters hit themselves with
724 * their own arrow - this can be because they fire it then 717 * their own arrow - this can be because they fire it then
725 * move into it. 718 * move into it.
726 */ 719 */
727 if (tmp && tmp != op->owner) 720
728 {
729 /* Found living object, but it is reflecting the missile. Update 721 /* Found living object, but it is reflecting the missile. Update
730 * as below. (Note that for living creatures there is a small 722 * as below. (Note that for living creatures there is a small
731 * chance that reflect_missile fails.) 723 * chance that reflect_missile fails.)
732 */ 724 */
733 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))
734 { 726 {
735 int number = op->face;
736
737 op->direction = absdir (op->direction + 4); 727 op->direction = absdir (op->direction + 4);
738 update_turn_face (op); 728 update_turn_face (op);
739 was_reflected = 1; /* skip normal movement calculations */ 729 was_reflected = 1; /* skip normal movement calculations */
740 } 730 }
741 else 731 else
742 { 732 {
743 /* Attack the object. */ 733 /* Attack the object. */
744 op = hit_with_arrow (op, tmp); 734 op = hit_with_arrow (op, tmp);
745 735
746 if (!op) 736 if (!op)
747 return; 737 return;
748 } 738 }
749 } /* if this is not hitting its owner */ 739
750 } /* if there is something alive on this space */ 740 break;
741 }
742 }
751 743
752 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block)) 744 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
753 { 745 {
754 int retry = 0; 746 int retry = 0;
755 747
… …
757 * 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
758 * on a wall but has reflecting - the arrow won't reflect. 750 * on a wall but has reflecting - the arrow won't reflect.
759 * 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
760 * place, so I don't consider that a problem. 752 * place, so I don't consider that a problem.
761 */ 753 */
762 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 754 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
763 { 755 {
764 stop_arrow (op); 756 stop_arrow (op);
765 return; 757 return;
766 } 758 }
767 else 759 else
… …
816 return; 808 return;
817 } 809 }
818 810
819 /* update object image for new facing */ 811 /* update object image for new facing */
820 /* many thrown objects *don't* have more than one face */ 812 /* many thrown objects *don't* have more than one face */
821 if (GET_ANIM_ID (op)) 813 if (op->has_anim ())
822 SET_ANIMATION (op, op->direction); 814 op->set_anim_frame (op->direction);
823 } /* object is reflected */ 815 } /* object is reflected */
824 } /* object ran into a wall */ 816 } /* object ran into a wall */
825 817
826 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
827 * about 17 squares. Tune as needed.
828 */
829 op->speed -= 0.05;
830
831 /* Move the arrow. */ 818 /* Move the arrow. */
832 op->move_to (pos); 819 op->move_to (pos);
833} 820}
834 821
835void 822static void
836change_object (object *op) 823change_object (object *op)
837{ /* Doesn`t handle linked objs yet */ 824{ /* Doesn`t handle linked objs yet */
838 int i, j;
839
840 if (!op->other_arch) 825 if (!op->other_arch)
841 { 826 {
842 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 ());
843 return; 828 return;
844 } 829 }
845 830
846 /* In non-living items only change when food value is 0 */ 831 /* In non-living items only change when food value is 0 */
847 if (!QUERY_FLAG (op, FLAG_ALIVE)) 832 if (!op->flag [FLAG_ALIVE])
848 { 833 {
849 if (op->stats.food-- > 0) 834 if (op->stats.food-- > 0)
850 return; 835 return;
851 836
852 op->stats.food = 1; /* so 1 other_arch is made */ 837 op->stats.food = 1; /* so 1 other_arch is made */
853 } 838 }
854 839
855 object *env = op->env; 840 object *env = op->env;
856 841
857 op->remove (); 842 op->remove ();
858 for (i = 0; i < op->stats.food; i++) 843 for (int i = 0; i < op->stats.food; i++)
859 { 844 {
860 object *tmp = arch_to_object (op->other_arch); 845 object *tmp = op->other_arch->instance ();
861 846
862 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 847 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
863 848
864 if (env) 849 if (env)
865 env->insert (tmp); 850 env->insert (tmp);
866 else 851 else
867 { 852 {
868 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
869 if (j < 0) /* No free spot */ 855 if (j < 0) /* No free spot */
870 tmp->destroy (); 856 tmp->destroy ();
871 else 857 else
872 { 858 {
873 mapxy pos (op); pos.move (j); 859 mapxy pos (op); pos.move (j);
… …
898 884
899 if (op->head) 885 if (op->head)
900 head = op->head; 886 head = op->head;
901 887
902 for (tmp = op->above; tmp; tmp = tmp->above) 888 for (tmp = op->above; tmp; tmp = tmp->above)
903 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 889 if (!tmp->flag [FLAG_IS_FLOOR])
904 break; 890 break;
905 891
906 /* If nothing above us to move, nothing to do */ 892 /* If nothing above us to move, nothing to do */
907 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 893 if (!tmp || tmp->flag [FLAG_WIZPASS])
908 return; 894 return;
909 895
910 if (EXIT_PATH (head)) 896 if (EXIT_PATH (head))
911 { 897 {
912 if (tmp->type == PLAYER) 898 if (tmp->type == PLAYER)
… …
947/* This object will teleport someone to a different map 933/* This object will teleport someone to a different map
948 and will also apply changes to the player from its inventory. 934 and will also apply changes to the player from its inventory.
949 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
950 can't be generalized. 936 can't be generalized.
951*/ 937*/
952void 938static void
953move_player_changer (object *op) 939move_player_changer (object *op)
954{ 940{
955 object *player;
956 object *walk;
957
958 if (!op->above || !EXIT_PATH (op)) 941 if (!op->above || !EXIT_PATH (op))
959 return; 942 return;
960 943
961 /* This isn't all that great - means that the player_mover 944 /* This isn't all that great - means that the player_mover
962 * needs to be on top. 945 * needs to be on top.
963 */ 946 */
964 if (op->above->type == PLAYER) 947 if (op->above->type == PLAYER)
965 { 948 {
949 object *player = op->above;
950
966 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 951 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
967 return; 952 return;
968 953
969 player = op->above;
970
971 for (walk = op->inv; walk; walk = walk->below) 954 for (object *walk = op->inv; walk; walk = walk->below)
972 apply_changes_to_player (player, walk); 955 apply_changes_to_player (player, walk);
973 956
974 player->update_stats (); 957 player->update_stats ();
975 958
976 esrv_send_inventory (op->above, op->above); 959 esrv_send_inventory (op->above, op->above);
… …
1014 } 997 }
1015 998
1016 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);
1017} 1000}
1018 1001
1019/* move_player_mover: this function takes a "player mover" as an 1002/* move_player_mover: this function takes a "player mover" as an
1020 * argument, and performs the function of a player mover, which is: 1003 * argument, and performs the function of a player mover, which is:
1021 * 1004 *
1022 * 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
1023 * 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.
1024 * 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,
1025 * 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,
1026 * it'll paralyze the victim for hp*his speed/op->speed 1009 * it'll paralyze the victim for hp*his speed/op->speed
1027 */ 1010 */
1028void 1011static void
1029move_player_mover (object *op) 1012move_player_mover (object *op)
1030{ 1013{
1031 int dir = op->stats.sp; 1014 int dir = 0;
1032 sint16 nx, ny;
1033 maptile *m;
1034
1035 /* Determine direction now for random movers so we do the right thing */
1036 if (!dir)
1037 dir = rndm (1, 8);
1038 1015
1039 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1016 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1040 { 1017 {
1041 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1018 if (victim->flag [FLAG_ALIVE]
1019 && !victim->flag [FLAG_WIZPASS]
1042 (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)
1043 { 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 }
1044 1041
1045 if (victim->head) 1042 if (victim->head)
1046 victim = victim->head; 1043 victim = victim->head;
1047 1044
1048 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1049 {
1050 op->remove ();
1051 return;
1052 }
1053
1054 nx = op->x + freearr_x[dir];
1055 ny = op->y + freearr_y[dir];
1056 m = op->map;
1057 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1058 {
1059 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1060 return;
1061 }
1062
1063 if (should_director_abort (op, victim)) 1045 if (should_director_abort (op, victim))
1064 return; 1046 return;
1065 1047
1066 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)
1067 { 1049 {
1068 if (nextmover->type == PLAYERMOVER) 1050 if (nextmover->type == PLAYERMOVER)
1069 nextmover->speed_left = -.99f; 1051 nextmover->speed_left = -.99f;
1070 1052
1071 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1053 if (nextmover->flag [FLAG_ALIVE])
1072 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 */
1073 } 1055 }
1074 1056
1075 if (victim->type == PLAYER) 1057 if (victim->type == PLAYER)
1076 { 1058 {
1077 /* only level >=1 movers move people */ 1059 /* only level >=1 movers move people */
1078 if (op->level) 1060 if (op->level)
1079 { 1061 {
1080 /* 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
1081 * is cleared, otherwise the player will get stuck in 1063 * is cleared, otherwise the player will get stuck in
1082 * place. This can happen if the player used a spell to 1064 * place. This can happen if the player used a spell to
1083 * get to this space. 1065 * get to this space.
1084 */ 1066 */
1085 victim->contr->fire_on = 0; 1067 victim->contr->fire_on = 0;
1086 victim->speed_left = 1.f; 1068 victim->speed_left = 1.f;
1087 move_player (victim, dir); 1069 move_player (victim, dir);
1088 } 1070 }
1089 else 1071 else
1090 return; 1072 return;
1091 } 1073 }
1092 else 1074 else
1093 move_object (victim, dir); 1075 victim->move (dir);
1094 1076
1095 if (!op->stats.maxsp && op->attacktype) 1077 if (!op->stats.maxsp && op->attacktype)
1096 op->stats.maxsp = 2; 1078 op->stats.maxsp = 2;
1097 1079
1098 if (op->attacktype) 1080 if (op->attacktype)
1099 { /* flag to paralyze the player */ 1081 { /* flag to paralyze the player */
1100 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);
1101 } 1083 }
1102 } 1084 }
1103 } 1085 }
1104} 1086}
1105 1087
… …
1143 break; 1125 break;
1144 } 1126 }
1145 } 1127 }
1146} 1128}
1147 1129
1148/* move_creator (by peterm) 1130/* move_creator (by peterm)
1149 * 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.
1150 * connected: what will trigger it 1132 * connected: what will trigger it
1151 * hp: how many times it may create before stopping 1133 * hp: how many times it may create before stopping
1152 * 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
1153 * everytime it's triggered 1135 * everytime it's triggered
… …
1161void 1143void
1162move_creator (object *creator) 1144move_creator (object *creator)
1163{ 1145{
1164 object *new_ob; 1146 object *new_ob;
1165 1147
1166 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1148 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1167 { 1149 {
1168 creator->stats.hp = -1; 1150 creator->stats.hp = -1;
1169 return; 1151 return;
1170 } 1152 }
1171 1153
… …
1175 int i; 1157 int i;
1176 object *ob_to_copy; 1158 object *ob_to_copy;
1177 1159
1178 /* select random object from inventory to copy */ 1160 /* select random object from inventory to copy */
1179 ob_to_copy = creator->inv; 1161 ob_to_copy = creator->inv;
1180 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++)
1181 { 1163 {
1182 if (rndm (0, i) == 0) 1164 if (rndm (0, i) == 0)
1183 { 1165 {
1184 ob_to_copy = ob; 1166 ob_to_copy = ob;
1185 } 1167 }
1186 } 1168 }
1169
1187 new_ob = ob_to_copy->deep_clone (); 1170 new_ob = ob_to_copy->deep_clone ();
1188 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1171 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1189 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1172 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1190 } 1173 }
1191 else 1174 else
1192 { 1175 {
1193 if (!creator->other_arch) 1176 if (!creator->other_arch)
… …
1208 return; 1191 return;
1209 } 1192 }
1210 1193
1211 // for now lets try to identify everything generated here, it mostly 1194 // for now lets try to identify everything generated here, it mostly
1212 // 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
1213 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1196 if (new_ob->need_identify ())
1197 new_ob->set_flag (FLAG_IDENTIFIED);
1214 1198
1215 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);
1216 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1200 if (new_ob->flag [FLAG_FREED])
1217 return; 1201 return;
1218 1202
1219 if (creator->slaying) 1203 if (creator->slaying)
1220 new_ob->name = new_ob->title = creator->slaying; 1204 new_ob->name = new_ob->title = creator->slaying;
1221} 1205}
… …
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);
… …
1259 } 1243 }
1260} 1244}
1261 1245
1262// mapscript objects activate themselves (only) then their timer fires 1246// mapscript objects activate themselves (only) then their timer fires
1263// TODO: maybe they should simply trigger the link like any other object? 1247// TODO: maybe they should simply trigger the link like any other object?
1264void 1248static void
1265move_mapscript (object *op) 1249move_mapscript (object *op)
1266{ 1250{
1267 op->set_speed (0); 1251 op->set_speed (0);
1268 cfperl_mapscript_activate (op, true, op, 0); 1252 cfperl_mapscript_activate (op, true, op, 0);
1269} 1253}
1270 1254
1255static void
1271void move_lamp (object *op) 1256move_lamp (object *op)
1272{ 1257{
1273 // if the lamp/torch is off, we should disable it. 1258 // if the lamp/torch is off, we should disable it.
1274 if (!op->glow_radius) 1259 if (!op->glow_radius)
1275 { 1260 {
1276 op->set_speed (0); 1261 op->set_speed (0);
1277 return; 1262 return;
1278 } 1263 }
1279 else 1264 else
1280 { 1265 {
1281 // check whether the face might needs to be updated 1266 // check whether the face might need to be updated
1282 // (currently this is needed to have already switched on torches 1267 // (currently this is needed to have already switched on torches
1283 // on maps, as they just set the glow_radius in the archetype) 1268 // on maps, as they just set the glow_radius in the archetype)
1284 if (op->other_arch 1269 if (op->other_arch
1285 && ( 1270 && (
1271 (op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
1286 op->flag [FLAG_ANIMATE] 1272 || (op->flag [FLAG_ANIMATE]
1287 ? (op->animation_id != op->other_arch->animation_id) 1273 ? (op->animation_id != op->other_arch->animation_id)
1288 : (op->face != op->other_arch->face) 1274 : (op->face != op->other_arch->face))
1289 )) 1275 ))
1290 get_animation_from_arch (op, op->other_arch); 1276 get_animation_from_arch (op, op->other_arch);
1291 } 1277 }
1292 1278
1293 // lamps and torches auf maps don't use up their fuel 1279 // lamps and torches on maps don't use up their fuel
1294 if (op->is_on_map ()) 1280 if (op->is_on_map ())
1295 return; 1281 return;
1296 1282
1297 if (op->stats.food > 0) 1283 if (op->stats.food > 0)
1298 { 1284 {
… …
1304} 1290}
1305 1291
1306void 1292void
1307process_object (object *op) 1293process_object (object *op)
1308{ 1294{
1309 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1295 if (ecb_expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1310 return; 1296 return;
1311 1297
1312 if (expect_false (INVOKE_OBJECT (TICK, op))) 1298 if (ecb_expect_false (INVOKE_OBJECT (TICK, op)))
1313 return; 1299 return;
1314 1300
1315 if (QUERY_FLAG (op, FLAG_MONSTER)) 1301 if (op->flag [FLAG_MONSTER])
1316 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1302 if (move_monster (op) || op->flag [FLAG_FREED])
1317 return; 1303 return;
1318 1304
1319 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1305 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1320 { 1306 {
1321 animate_object (op, op->contr ? op->facing : op->direction); 1307 animate_object (op, op->contr ? op->facing : op->direction);
1322 1308
1323 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1309 if (op->flag [FLAG_SEE_ANYWHERE])
1324 make_sure_seen (op); 1310 make_sure_seen (op);
1325 } 1311 }
1326 1312
1327 if (expect_false ( 1313 if (ecb_expect_false (
1328 op->flag [FLAG_GENERATOR] 1314 op->flag [FLAG_GENERATOR]
1329 || op->flag [FLAG_CHANGING] 1315 || op->flag [FLAG_CHANGING]
1330 || op->flag [FLAG_IS_USED_UP] 1316 || op->flag [FLAG_IS_USED_UP]
1331 )) 1317 ))
1332 { 1318 {
1333 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1319 if (op->flag [FLAG_CHANGING] && !op->state)
1334 { 1320 {
1335 change_object (op); 1321 change_object (op);
1336 return; 1322 return;
1337 } 1323 }
1338 1324
1339 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1325 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1340 generate_monster (op); 1326 generate_monster (op);
1341 1327
1342 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1328 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1343 { 1329 {
1344 if (QUERY_FLAG (op, FLAG_APPLIED)) 1330 if (op->flag [FLAG_APPLIED])
1345 remove_force (op); 1331 remove_force (op);
1346 else 1332 else
1347 { 1333 {
1348 op->remove (); // TODO: really necessary? 1334 op->remove (); // TODO: really necessary?
1349 1335
1350 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1336 if (op->flag [FLAG_SEE_ANYWHERE])
1351 make_sure_not_seen (op); 1337 make_sure_not_seen (op);
1352 1338
1353 op->drop_and_destroy (); 1339 op->drop_and_destroy ();
1354 } 1340 }
1355 1341
… …
1491 1477
1492 case LAMP: 1478 case LAMP:
1493 case TORCH: 1479 case TORCH:
1494 move_lamp (op); 1480 move_lamp (op);
1495 break; 1481 break;
1496 }
1497}
1498 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