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.67 by root, Tue Sep 4 08:42:58 2007 UTC vs.
Revision 1.128 by root, Wed Dec 5 19:03:27 2018 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2017,2018 Marc Alexander Lehmann / 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 * Crossfire TRT 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 <crossfire@schmorp.de> 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
26 * collected in this file. 28 * collected in this file.
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)
38{ 40{
39 int i; 41 for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
42 {
40 object *tmp; 43 object *tmp;
41 44 mapxy pos (op);
42 for (i = 1; i < 9; i += 2) 45 pos.move (i);
43 if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL) 46 if (pos.normalise ()
47 && (tmp = present (DOOR, pos.m, pos.x, pos.y)))
44 { 48 {
45 tmp->set_speed (0.1f); 49 tmp->set_speed (0.1f);
46 tmp->speed_left = -0.2f; 50 tmp->speed_left = -0.2f;
47 } 51 }
52 }
48 53
49 if (op->other_arch) 54 if (op->other_arch)
50 { 55 {
51 tmp = arch_to_object (op->other_arch); 56 object *tmp = op->other_arch->instance ();
52 tmp->x = op->x; 57 tmp->x = op->x;
53 tmp->y = op->y; 58 tmp->y = op->y;
54 tmp->map = op->map; 59 tmp->map = op->map;
55 tmp->level = op->level; 60 tmp->level = op->level;
56 insert_ob_in_map (tmp, op->map, op, 0); 61 insert_ob_in_map (tmp, op->map, op, 0);
57 } 62 }
58 63
59 op->destroy (); 64 op->drop_and_destroy ();
60} 65}
61 66
62void 67void
63remove_door2 (object *op) 68remove_door2 (object *op)
64{ 69{
65 int i; 70 int i;
66 object *tmp; 71 object *tmp;
67 72
68 for (i = 1; i < 9; i += 2) 73 for (i = 1; i < 9; i += 2)
69 { 74 {
70 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));
71 if (tmp && tmp->slaying == op->slaying) 76 if (tmp && tmp->slaying == op->slaying)
72 { /* same key both doors */ 77 { /* same key both doors */
73 tmp->set_speed (0.1f); 78 tmp->set_speed (0.1f);
74 tmp->speed_left = -0.2f; 79 tmp->speed_left = -0.2f;
75 } 80 }
76 } 81 }
77 82
78 if (op->other_arch) 83 if (op->other_arch)
79 { 84 {
80 tmp = arch_to_object (op->other_arch); 85 tmp = op->other_arch->instance ();
81 tmp->x = op->x; 86 tmp->x = op->x;
82 tmp->y = op->y; 87 tmp->y = op->y;
83 tmp->map = op->map; 88 tmp->map = op->map;
84 tmp->level = op->level; 89 tmp->level = op->level;
85 insert_ob_in_map (tmp, op->map, op, 0); 90 insert_ob_in_map (tmp, op->map, op, 0);
86 } 91 }
87 92
88 op->destroy (); 93 op->drop_and_destroy ();
89} 94}
90 95
91void 96static void
92generate_monster (object *gen) 97generate_monster (object *gen)
93{ 98{
94 if (!gen->map) 99 if (!gen->map)
95 return; 100 return;
96 101
97 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1)) 102 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
98 return; 103 return;
99 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
100 object *op; 110 object *op;
101 int dir; 111 int dir;
102 112
103 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 113 if (gen->flag [FLAG_CONTENT_ON_GEN])
104 { 114 {
105 // either copy one item from the inventory... 115 // either copy one item from the inventory...
106 if (!gen->inv) 116 if (!gen->inv)
107 return; 117 return;
108 118
… …
114 124
115 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1); 125 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
116 if (dir < 0) 126 if (dir < 0)
117 return; 127 return;
118 128
119 op = object_create_clone (op); 129 op = op->deep_clone ();
120 130
121 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 131 op->clr_flag (FLAG_IS_A_TEMPLATE);
122 unflag_inv (op, FLAG_IS_A_TEMPLATE); 132 unflag_inv (op, FLAG_IS_A_TEMPLATE);
123 } 133 }
124 else if (gen->other_arch) 134 else if (gen->other_arch)
125 { 135 {
126 // ...or use other_arch 136 // ...or use other_arch
127 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);
128 if (dir < 0) 138 if (dir < 0)
129 return; 139 return;
130 140
131 op = arch_to_object (gen->other_arch); 141 op = gen->other_arch->instance ();
132 } 142 }
133 else 143 else
134 return; 144 return;
135 145
136 op->expand_tail (); 146 op->expand_tail ();
… …
149 } 159 }
150 160
151 op->destroy (); 161 op->destroy ();
152} 162}
153 163
154void 164static void
155remove_force (object *op) 165remove_force (object *op)
156{ 166{
157 if (--op->duration > 0) 167 if (--op->duration > 0)
158 return; 168 return;
159 169
160 if (op->env) 170 if (op->env)
161 switch (op->subtype) 171 switch (op->subtype)
162 { 172 {
163 case FORCE_CONFUSION: 173 case FORCE_CONFUSION:
164 CLEAR_FLAG (op->env, FLAG_CONFUSED); 174 op->env->clr_flag (FLAG_CONFUSED);
165 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");
166 176
167 default: 177 default:
168 CLEAR_FLAG (op, FLAG_APPLIED); 178 op->clr_flag (FLAG_APPLIED);
169 change_abil (op->env, op); 179 change_abil (op->env, op);
170 op->env->update_stats (); 180 op->env->update_stats ();
171 } 181 }
172 182
173 op->destroy (); 183 op->destroy ();
174} 184}
175 185
176void 186static void
177remove_blindness (object *op) 187remove_blindness (object *op)
178{ 188{
179 if (--op->stats.food > 0) 189 if (--op->stats.food > 0)
180 return; 190 return;
181 191
182 CLEAR_FLAG (op, FLAG_APPLIED); 192 op->clr_flag (FLAG_APPLIED);
183 193
184 if (op->env) 194 if (op->env)
185 { 195 {
186 change_abil (op->env, op); 196 change_abil (op->env, op);
187 op->env->update_stats (); 197 op->env->update_stats ();
188 } 198 }
189 199
190 op->destroy (); 200 op->destroy ();
191} 201}
192 202
193void 203static void
194poison_more (object *op) 204poison_more (object *op)
195{ 205{
196 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)
197 { 207 {
198 op->destroy (); 208 op->destroy ();
199 return; 209 return;
200 } 210 }
201 211
… …
204 /* 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
205 * will not do anything. 215 * will not do anything.
206 */ 216 */
207 if (op->env->type == PLAYER) 217 if (op->env->type == PLAYER)
208 { 218 {
209 CLEAR_FLAG (op, FLAG_APPLIED); 219 op->clr_flag (FLAG_APPLIED);
210 op->env->update_stats (); 220 op->env->update_stats ();
211 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.");
212 } 222 }
213 223
214 op->destroy (); 224 op->destroy ();
… …
223 233
224 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 234 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
225} 235}
226 236
227 237
228void 238static void
229move_gate (object *op) 239move_gate (object *op)
230{ /* 1 = going down, 0 = going up */ 240{ /* 1 = going down, 0 = going up */
231 object *tmp; 241 object *tmp;
232 242
233 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 243 if (uint32_t (op->stats.wc) >= op->anim_frames ())
234 { 244 {
235 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 ());
236 op->stats.wc = 0; 246 op->stats.wc = 0;
237 } 247 }
238 248
239 /* We're going down */
240 if (op->value) 249 if (op->value)
241 { 250 {
251 /* We're going down */
242 if (--op->stats.wc <= 0) 252 if (--op->stats.wc <= 0)
243 { /* Reached bottom, let's stop */ 253 { /* Reached bottom, let's stop */
244 op->stats.wc = 0; 254 op->stats.wc = 0;
245 if (op->arch->speed) 255 if (op->arch->has_active_speed ())
246 op->value = 0; 256 op->value = 0;
247 else 257 else
248 op->set_speed (0); 258 op->set_speed (0);
249 } 259 }
250 260
251 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 261 if (op->stats.wc < op->anim_frames () / 2 + 1)
252 { 262 {
253 op->move_block = 0; 263 op->move_block = 0;
254 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 264 op->clr_flag (FLAG_BLOCKSVIEW);
255 update_all_los (op->map, op->x, op->y); 265 update_all_los (op->map, op->x, op->y);
256 } 266 }
257
258 SET_ANIMATION (op, op->stats.wc);
259 update_object (op, UP_OBJ_CHANGE);
260 return;
261 }
262
263 /* We're going up */
264
265 /* First, lets see if we are already at the top */
266 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
267 {
268
269 /* Check to make sure that only non pickable and non rollable
270 * objects are above the gate. If so, we finish closing the gate,
271 * otherwise, we fall through to the code below which should lower
272 * the gate slightly.
273 */
274
275 for (tmp = op->above; tmp; tmp = tmp->above)
276 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
277 break;
278
279 if (!tmp)
280 {
281 if (op->arch->speed)
282 op->value = 1;
283 else
284 op->set_speed (0);
285
286 return;
287 }
288 }
289
290 if (op->stats.food)
291 { /* The gate is going temporarily down */
292 if (--op->stats.wc <= 0)
293 { /* Gone all the way down? */
294 op->stats.food = 0; /* Then let's try again */
295 op->stats.wc = 0;
296 }
297 } 267 }
298 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
299 { /* The gate is still going up */ 305 { /* The gate is still going up */
300 op->stats.wc++; 306 op->stats.wc++;
307 min_it (op->stats.wc, op->anim_frames () - 1);
301 308
302 if ((int) op->stats.wc >= (NUM_ANIMATIONS (op)))
303 op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1;
304
305 /* 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.
306 * 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
307 */ 311 */
308 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 312 if (op->stats.wc >= op->anim_frames () / 2)
309 { 313 {
310 /* Halfway or further, check blocks */ 314 /* Halfway or further, check blocks */
311 /* First, get the top object on the square. */ 315 /* First, get the top object on the square. */
312 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 316 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
313 ; 317 ;
314 318
315 if (tmp) 319 if (tmp)
316 {
317 if (QUERY_FLAG (tmp, FLAG_ALIVE))
318 { 320 {
319 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 321 if (tmp->flag [FLAG_ALIVE])
320 op->play_sound (sound_find ("blocked_gate"));
321
322 if (tmp->type == PLAYER)
323 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
324 }
325 /* If the object is not alive, and the object either can
326 * be picked up or the object rolls, move the object
327 * off the gate.
328 */
329 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
330 {
331 /* If it has speed, it should move itself, otherwise: */
332 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
333
334 /* If there is a free spot, move the object someplace */
335 if (i != -1)
336 { 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 {
341 mapxy pos (tmp);
342 pos.move (i);
343 if (pos.normalise ())
337 tmp->remove (); 344 tmp->move_to (pos);
338 tmp->x += freearr_x[i], tmp->y += freearr_y[i]; 345 }
339 insert_ob_in_map (tmp, op->map, op, 0);
340 } 346 }
341 } 347 }
342 }
343 348
344 /* See if there is still anything blocking the gate */ 349 /* See if there is still anything blocking the gate */
345 for (tmp = op->above; tmp; tmp = tmp->above) 350 for (tmp = op->above; tmp; tmp = tmp->above)
346 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])
347 break; 352 break;
348 353
349 /* IF there is, start putting the gate down */ 354 /* IF there is, start putting the gate down */
350 if (tmp) 355 if (tmp)
351 op->stats.food = 1; 356 op->stats.food = 1;
352 else 357 else
353 { 358 {
354 op->move_block = MOVE_ALL; 359 op->move_block = MOVE_ALL;
355 360
356 if (!op->arch->stats.ac) 361 if (!op->arch->stats.ac)
357 SET_FLAG (op, FLAG_BLOCKSVIEW); 362 op->set_flag (FLAG_BLOCKSVIEW);
363
358 update_all_los (op->map, op->x, op->y); 364 update_all_los (op->map, op->x, op->y);
359 } 365 }
360 } /* gate is halfway up */ 366 } /* gate is halfway up */
361
362 SET_ANIMATION (op, op->stats.wc);
363 update_object (op, UP_OBJ_CHANGE);
364 } /* gate is going up */ 367 } /* gate is going up */
368 }
369
370 op->update_anim_frame (op->stats.wc);
365} 371}
366 372
367/* hp : how long door is open/closed 373/* hp : how long door is open/closed
368 * maxhp : initial value for hp 374 * maxhp : initial value for hp
369 * sp : 1 = open, 0 = close 375 * sp : 1 = open, 0 = close
370 */ 376 */
371void 377static void
372move_timed_gate (object *op) 378move_timed_gate (object *op)
373{ 379{
374 int v = op->value; 380 int v = op->value;
375 381
376 if (op->stats.sp) 382 if (op->stats.sp)
… …
395 * speed: frequency of 'glances' 401 * speed: frequency of 'glances'
396 * connected: connected value of detector 402 * connected: connected value of detector
397 * sp: 1 if detection sets buttons 403 * sp: 1 if detection sets buttons
398 * -1 if detection unsets buttons 404 * -1 if detection unsets buttons
399 */ 405 */
400 406static void
401void
402move_detector (object *op) 407move_detector (object *op)
403{ 408{
404 object *tmp; 409 object *tmp;
405 int last = op->value; 410 int last = op->value;
406 int detected; 411 int detected;
… …
433 if (op->stats.sp == 1) 438 if (op->stats.sp == 1)
434 { 439 {
435 if (detected && last == 0) 440 if (detected && last == 0)
436 { 441 {
437 op->value = 1; 442 op->value = 1;
438 push_button (op); 443 push_button (op, tmp);
439 } 444 }
440 445
441 if (!detected && last == 1) 446 if (!detected && last == 1)
442 { 447 {
443 op->value = 0; 448 op->value = 0;
444 push_button (op); 449 push_button (op, tmp);
445 } 450 }
446 } 451 }
447 else 452 else
448 { /* in this case, we unset buttons */ 453 { /* in this case, we unset buttons */
449 if (detected && last == 1) 454 if (detected && last == 1)
450 { 455 {
451 op->value = 0; 456 op->value = 0;
452 push_button (op); 457 push_button (op, tmp);
453 } 458 }
454 459
455 if (!detected && last == 0) 460 if (!detected && last == 0)
456 { 461 {
457 op->value = 1; 462 op->value = 1;
458 push_button (op); 463 push_button (op, tmp);
459 } 464 }
460 } 465 }
461} 466}
462 467
463void 468void
464animate_trigger (object *op) 469animate_trigger (object *op)
465{ 470{
466 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 471 if (uint32_t (++op->stats.wc) >= op->anim_frames ())
467 { 472 {
468 op->stats.wc = 0; 473 op->stats.wc = 0;
469 check_trigger (op, NULL); 474 check_trigger (op, NULL);
470 } 475 }
471 else 476 else
472 { 477 op->update_anim_frame (op->stats.wc);
473 SET_ANIMATION (op, op->stats.wc);
474 update_object (op, UP_OBJ_FACE);
475 }
476} 478}
477 479
478void 480static void
479move_hole (object *op) 481move_hole (object *op)
480{ /* 1 = opening, 0 = closing */ 482{ /* 1 = opening, 0 = closing */
481 object *next, *tmp;
482
483 if (op->value) 483 if (op->value)
484 { /* We're opening */ 484 {
485 /* We're opening */
486 op->stats.wc--;
485 if (--op->stats.wc <= 0) 487 if (op->stats.wc <= 0)
486 { /* Opened, let's stop */ 488 { /* Opened, let's stop */
487 op->stats.wc = 0; 489 op->stats.wc = 0;
488 op->set_speed (0); 490 op->set_speed (0);
489 491
490 /* Hard coding this makes sense for holes I suppose */ 492 /* Hard coding this makes sense for holes I suppose */
491 op->move_on = MOVE_WALK; 493 op->move_on = MOVE_WALK;
492 for (tmp = op->above; tmp != NULL; tmp = next) 494 for (object *next, *tmp = op->above; tmp; tmp = next)
493 { 495 {
494 next = tmp->above; 496 next = tmp->above;
495 move_apply (op, tmp, tmp); 497 move_apply (op, tmp, tmp);
496 } 498 }
497 } 499 }
498 500 }
499 SET_ANIMATION (op, op->stats.wc); 501 else
500 update_object (op, UP_OBJ_FACE);
501 return;
502 } 502 {
503
504 /* We're closing */ 503 /* We're closing */
505 op->move_on = 0; 504 op->move_on = 0;
506 505
507 op->stats.wc++; 506 op->stats.wc++;
508 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 507 if (op->stats.wc >= op->anim_frames ())
509 op->stats.wc = NUM_ANIMATIONS (op) - 1; 508 {
510 509 op->stats.wc = op->anim_frames () - 1;
511 SET_ANIMATION (op, op->stats.wc);
512 update_object (op, UP_OBJ_FACE);
513 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
514 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);
515} 515}
516 516
517 517
518/* 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
519 * 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
… …
539 { 539 {
540 object *payload = op->inv; 540 object *payload = op->inv;
541 541
542 if (payload == NULL) 542 if (payload == NULL)
543 return NULL; 543 return NULL;
544
544 payload->remove (); 545 payload->remove ();
545 op->destroy (); 546 op->destroy ();
546 return payload; 547 return payload;
547 } 548 }
548 549
… …
565fix_stopped_item (object *op, maptile *map, object *originator) 566fix_stopped_item (object *op, maptile *map, object *originator)
566{ 567{
567 if (map == NULL) 568 if (map == NULL)
568 return; 569 return;
569 570
570 if (QUERY_FLAG (op, FLAG_REMOVED)) 571 if (op->flag [FLAG_REMOVED])
571 insert_ob_in_map (op, map, originator, 0); 572 insert_ob_in_map (op, map, originator, 0);
572 else if (op->type == ARROW) 573 else if (op->type == ARROW)
573 merge_ob (op, NULL); /* only some arrows actually need this */ 574 merge_ob (op, NULL); /* only some arrows actually need this */
574} 575}
575 576
… …
591 592
592 // restore original wc, dam, attacktype and slaying 593 // restore original wc, dam, attacktype and slaying
593 op->stats.wc = op->stats.sp; 594 op->stats.wc = op->stats.sp;
594 op->stats.dam = op->stats.hp; 595 op->stats.dam = op->stats.hp;
595 op->attacktype = op->stats.grace; 596 op->attacktype = op->stats.grace;
597 op->slaying = op->custom_name;
596 598
597 if (op->spellarg)
598 {
599 op->slaying = op->spellarg;
600 free (op->spellarg);
601 op->spellarg = 0;
602 }
603 else
604 op->slaying = 0;
605
606 /* 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 */
607 op->spellarg = NULL; 600 op->custom_name = 0;
608 op->stats.sp = 0; 601 op->stats.sp = 0;
609 op->stats.hp = 0; 602 op->stats.hp = 0;
610 op->stats.grace = 0; 603 op->stats.grace = 0;
611 op->level = 0; 604 op->level = 0;
612 op->face = op->arch->face; 605 op->face = op->arch->face;
613 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
614 update_object (op, UP_OBJ_CHANGE); 610 update_object (op, UP_OBJ_CHANGE);
611
615 return op; 612 return op;
616} 613}
617 614
618/* stop_arrow() - what to do when a non-living flying object 615/* stop_arrow() - what to do when a non-living flying object
619 * 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
… …
628 if (INVOKE_OBJECT (STOP, op)) 625 if (INVOKE_OBJECT (STOP, op))
629 return; 626 return;
630 627
631 if (op->inv) 628 if (op->inv)
632 { 629 {
630 // replace this by straightforward drop to ground?
633 object *payload = op->inv; 631 object *payload = op->inv;
634 632
635 payload->remove ();
636 payload->owner = 0; 633 payload->owner = 0;
637 insert_ob_in_map (payload, op->map, payload, 0); 634 insert_ob_in_map (payload, op->map, payload, 0);
638 op->destroy (); 635 op->destroy ();
639 } 636 }
640 else 637 else
… …
644 if (op) 641 if (op)
645 merge_ob (op, 0); 642 merge_ob (op, 0);
646 } 643 }
647} 644}
648 645
649/* 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.
650 */ 647 */
651void 648void
652move_arrow (object *op) 649move_arrow (object *op)
653{ 650{
654 int was_reflected; 651 int was_reflected;
655 652
656 if (!op->map) 653 if (!op->map)
657 { 654 {
658 LOG (llevError, "BUG: Arrow had no map.\n"); 655 LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
659 op->destroy (); 656 op->destroy ();
660 return; 657 return;
661 } 658 }
662 659
663 /* we need to stop thrown objects at some point. Like here. */ 660 /* we need to stop thrown objects at some point. Like here. */
… …
669 * 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,
670 * 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
671 * 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,
672 * and it is easy enough to clean it up here. 669 * and it is easy enough to clean it up here.
673 */ 670 */
674 if (op->inv == NULL) 671 if (!op->inv)
675 { 672 {
676 op->destroy (); 673 op->destroy ();
677 return; 674 return;
678 } 675 }
679 676
… …
682 stop_arrow (op); 679 stop_arrow (op);
683 return; 680 return;
684 } 681 }
685 } 682 }
686 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
687 /* 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
688 values look rediculous. */ 690 values look ridiculous. */
689 if (op->speed < 0.5 && op->type == ARROW) 691 if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
690 { 692 {
691 stop_arrow (op); 693 stop_arrow (op);
692 return; 694 return;
693 } 695 }
694 696
… …
707 if (pos->flags () & P_IS_ALIVE) 709 if (pos->flags () & P_IS_ALIVE)
708 { 710 {
709 object *tmp; 711 object *tmp;
710 712
711 for (tmp = pos->bot; tmp; tmp = tmp->above) 713 for (tmp = pos->bot; tmp; tmp = tmp->above)
712 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 714 if (tmp->flag [FLAG_ALIVE] && tmp != op->owner)
713 break; 715 {
714
715 /* Not really fair, but don't let monsters hit themselves with 716 /* Not really fair, but don't let monsters hit themselves with
716 * their own arrow - this can be because they fire it then 717 * their own arrow - this can be because they fire it then
717 * move into it. 718 * move into it.
718 */ 719 */
719 if (tmp && tmp != op->owner) 720
720 {
721 /* Found living object, but it is reflecting the missile. Update 721 /* Found living object, but it is reflecting the missile. Update
722 * as below. (Note that for living creatures there is a small 722 * as below. (Note that for living creatures there is a small
723 * chance that reflect_missile fails.) 723 * chance that reflect_missile fails.)
724 */ 724 */
725 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))
726 { 726 {
727 int number = op->face;
728
729 op->direction = absdir (op->direction + 4); 727 op->direction = absdir (op->direction + 4);
730 update_turn_face (op); 728 update_turn_face (op);
731 was_reflected = 1; /* skip normal movement calculations */ 729 was_reflected = 1; /* skip normal movement calculations */
732 } 730 }
733 else 731 else
734 { 732 {
735 /* Attack the object. */ 733 /* Attack the object. */
736 op = hit_with_arrow (op, tmp); 734 op = hit_with_arrow (op, tmp);
737 735
738 if (!op) 736 if (!op)
739 return; 737 return;
740 } 738 }
741 } /* if this is not hitting its owner */ 739
742 } /* if there is something alive on this space */ 740 break;
741 }
742 }
743 743
744 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block)) 744 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
745 { 745 {
746 int retry = 0; 746 int retry = 0;
747 747
… …
749 * 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
750 * on a wall but has reflecting - the arrow won't reflect. 750 * on a wall but has reflecting - the arrow won't reflect.
751 * 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
752 * place, so I don't consider that a problem. 752 * place, so I don't consider that a problem.
753 */ 753 */
754 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 754 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
755 { 755 {
756 stop_arrow (op); 756 stop_arrow (op);
757 return; 757 return;
758 } 758 }
759 else 759 else
… …
808 return; 808 return;
809 } 809 }
810 810
811 /* update object image for new facing */ 811 /* update object image for new facing */
812 /* many thrown objects *don't* have more than one face */ 812 /* many thrown objects *don't* have more than one face */
813 if (GET_ANIM_ID (op)) 813 if (op->has_anim ())
814 SET_ANIMATION (op, op->direction); 814 op->set_anim_frame (op->direction);
815 } /* object is reflected */ 815 } /* object is reflected */
816 } /* object ran into a wall */ 816 } /* object ran into a wall */
817 817
818 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
819 * about 17 squares. Tune as needed.
820 */
821 op->speed -= 0.05;
822
823 /* Move the arrow. */ 818 /* Move the arrow. */
824 op->move_to (pos); 819 op->move_to (pos);
825} 820}
826 821
827void 822static void
828change_object (object *op) 823change_object (object *op)
829{ /* Doesn`t handle linked objs yet */ 824{ /* Doesn`t handle linked objs yet */
830 int i, j;
831
832 if (!op->other_arch) 825 if (!op->other_arch)
833 { 826 {
834 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 ());
835 return; 828 return;
836 } 829 }
837 830
838 /* In non-living items only change when food value is 0 */ 831 /* In non-living items only change when food value is 0 */
839 if (!QUERY_FLAG (op, FLAG_ALIVE)) 832 if (!op->flag [FLAG_ALIVE])
840 { 833 {
841 if (op->stats.food-- > 0) 834 if (op->stats.food-- > 0)
842 return; 835 return;
843 836
844 op->stats.food = 1; /* so 1 other_arch is made */ 837 op->stats.food = 1; /* so 1 other_arch is made */
845 } 838 }
846 839
847 object *env = op->env; 840 object *env = op->env;
848 841
849 op->remove (); 842 op->remove ();
850 for (i = 0; i < op->stats.food; i++) 843 for (int i = 0; i < op->stats.food; i++)
851 { 844 {
852 object *tmp = arch_to_object (op->other_arch); 845 object *tmp = op->other_arch->instance ();
853
854 if (op->type == LAMP)
855 tmp->stats.food = op->stats.food - 1;
856 846
857 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 847 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
848
858 if (env) 849 if (env)
859 {
860 tmp = env->insert (tmp); 850 env->insert (tmp);
861
862 /* If this object is the players inventory, we need to tell the
863 * client of the change. Insert_ob_in_map takes care of the
864 * updating the client, so we don't need to do that below.
865 */
866 if (object *pl = op->in_player ())
867 {
868 esrv_del_item (pl->contr, op->count);
869 esrv_send_item (pl, tmp);
870 }
871 }
872 else 851 else
873 { 852 {
874 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
875 if (j < 0) /* No free spot */ 855 if (j < 0) /* No free spot */
876 tmp->destroy (); 856 tmp->destroy ();
877 else 857 else
878 { 858 {
879 mapxy pos (op); pos.move (j); 859 mapxy pos (op); pos.move (j);
… …
904 884
905 if (op->head) 885 if (op->head)
906 head = op->head; 886 head = op->head;
907 887
908 for (tmp = op->above; tmp; tmp = tmp->above) 888 for (tmp = op->above; tmp; tmp = tmp->above)
909 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 889 if (!tmp->flag [FLAG_IS_FLOOR])
910 break; 890 break;
911 891
912 /* If nothing above us to move, nothing to do */ 892 /* If nothing above us to move, nothing to do */
913 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 893 if (!tmp || tmp->flag [FLAG_WIZPASS])
914 return; 894 return;
915 895
916 if (EXIT_PATH (head)) 896 if (EXIT_PATH (head))
917 { 897 {
918 if (tmp->type == PLAYER) 898 if (tmp->type == PLAYER)
… …
943 else 923 else
944 { 924 {
945 /* Random teleporter */ 925 /* Random teleporter */
946 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 926 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
947 return; 927 return;
928
948 teleport (head, TELEPORTER, tmp); 929 teleport (head, TELEPORTER, tmp);
949 } 930 }
950} 931}
951 932
952/* This object will teleport someone to a different map 933/* This object will teleport someone to a different map
953 and will also apply changes to the player from its inventory. 934 and will also apply changes to the player from its inventory.
954 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
955 can't be generalized. 936 can't be generalized.
956*/ 937*/
957void 938static void
958move_player_changer (object *op) 939move_player_changer (object *op)
959{ 940{
960 object *player;
961 object *walk;
962
963 if (!op->above || !EXIT_PATH (op)) 941 if (!op->above || !EXIT_PATH (op))
964 return; 942 return;
965 943
966 /* This isn't all that great - means that the player_mover 944 /* This isn't all that great - means that the player_mover
967 * needs to be on top. 945 * needs to be on top.
968 */ 946 */
969 if (op->above->type == PLAYER) 947 if (op->above->type == PLAYER)
970 { 948 {
949 object *player = op->above;
950
971 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 951 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
972 return; 952 return;
973 953
974 player = op->above;
975
976 for (walk = op->inv; walk; walk = walk->below) 954 for (object *walk = op->inv; walk; walk = walk->below)
977 apply_changes_to_player (player, walk); 955 apply_changes_to_player (player, walk);
978 956
979 player->update_stats (); 957 player->update_stats ();
980 958
981 esrv_send_inventory (op->above, op->above); 959 esrv_send_inventory (op->above, op->above);
… …
1019 } 997 }
1020 998
1021 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);
1022} 1000}
1023 1001
1024/* move_player_mover: this function takes a "player mover" as an 1002/* move_player_mover: this function takes a "player mover" as an
1025 * argument, and performs the function of a player mover, which is: 1003 * argument, and performs the function of a player mover, which is:
1026 * 1004 *
1027 * 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
1028 * 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.
1029 * 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,
1030 * 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,
1031 * it'll paralyze the victim for hp*his speed/op->speed 1009 * it'll paralyze the victim for hp*his speed/op->speed
1032 */ 1010 */
1033void 1011static void
1034move_player_mover (object *op) 1012move_player_mover (object *op)
1035{ 1013{
1036 int dir = op->stats.sp; 1014 int dir = 0;
1037 sint16 nx, ny;
1038 maptile *m;
1039
1040 /* Determine direction now for random movers so we do the right thing */
1041 if (!dir)
1042 dir = rndm (1, 8);
1043 1015
1044 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1016 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1045 { 1017 {
1046 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1018 if (victim->flag [FLAG_ALIVE]
1019 && !victim->flag [FLAG_WIZPASS]
1047 (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)
1048 { 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 }
1049 1041
1050 if (victim->head) 1042 if (victim->head)
1051 victim = victim->head; 1043 victim = victim->head;
1052 1044
1053 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1054 {
1055 op->remove ();
1056 return;
1057 }
1058
1059 nx = op->x + freearr_x[dir];
1060 ny = op->y + freearr_y[dir];
1061 m = op->map;
1062 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1063 {
1064 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1065 return;
1066 }
1067
1068 if (should_director_abort (op, victim)) 1045 if (should_director_abort (op, victim))
1069 return; 1046 return;
1070 1047
1071 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)
1072 { 1049 {
1073 if (nextmover->type == PLAYERMOVER) 1050 if (nextmover->type == PLAYERMOVER)
1074 nextmover->speed_left = -.99f; 1051 nextmover->speed_left = -.99f;
1075 1052
1076 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1053 if (nextmover->flag [FLAG_ALIVE])
1077 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 */
1078 } 1055 }
1079 1056
1080 if (victim->type == PLAYER) 1057 if (victim->type == PLAYER)
1081 { 1058 {
1082 /* only level >=1 movers move people */ 1059 /* only level >=1 movers move people */
1083 if (op->level) 1060 if (op->level)
1084 { 1061 {
1085 /* 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
1086 * is cleared, otherwise the player will get stuck in 1063 * is cleared, otherwise the player will get stuck in
1087 * place. This can happen if the player used a spell to 1064 * place. This can happen if the player used a spell to
1088 * get to this space. 1065 * get to this space.
1089 */ 1066 */
1090 victim->contr->fire_on = 0; 1067 victim->contr->fire_on = 0;
1091 victim->speed_left = 1.f; 1068 victim->speed_left = 1.f;
1092 move_player (victim, dir); 1069 move_player (victim, dir);
1093 } 1070 }
1094 else 1071 else
1095 return; 1072 return;
1096 } 1073 }
1097 else 1074 else
1098 move_object (victim, dir); 1075 victim->move (dir);
1099 1076
1100 if (!op->stats.maxsp && op->attacktype) 1077 if (!op->stats.maxsp && op->attacktype)
1101 op->stats.maxsp = 2; 1078 op->stats.maxsp = 2;
1102 1079
1103 if (op->attacktype) 1080 if (op->attacktype)
1104 { /* flag to paralyze the player */ 1081 { /* flag to paralyze the player */
1105 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);
1106 } 1083 }
1107 } 1084 }
1108 } 1085 }
1109} 1086}
1110 1087
… …
1148 break; 1125 break;
1149 } 1126 }
1150 } 1127 }
1151} 1128}
1152 1129
1153/* move_creator (by peterm) 1130/* move_creator (by peterm)
1154 * 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.
1155 * connected: what will trigger it 1132 * connected: what will trigger it
1156 * hp: how many times it may create before stopping 1133 * hp: how many times it may create before stopping
1157 * 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
1158 * everytime it's triggered 1135 * everytime it's triggered
… …
1166void 1143void
1167move_creator (object *creator) 1144move_creator (object *creator)
1168{ 1145{
1169 object *new_ob; 1146 object *new_ob;
1170 1147
1171 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1148 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1172 { 1149 {
1173 creator->stats.hp = -1; 1150 creator->stats.hp = -1;
1174 return; 1151 return;
1175 } 1152 }
1176 1153
1177 if (creator->inv != NULL) 1154 if (creator->inv)
1178 { 1155 {
1179 object *ob; 1156 object *ob;
1180 int i; 1157 int i;
1181 object *ob_to_copy; 1158 object *ob_to_copy;
1182 1159
1183 /* select random object from inventory to copy */ 1160 /* select random object from inventory to copy */
1184 ob_to_copy = creator->inv; 1161 ob_to_copy = creator->inv;
1185 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++)
1186 { 1163 {
1187 if (rndm (0, i) == 0) 1164 if (rndm (0, i) == 0)
1188 { 1165 {
1189 ob_to_copy = ob; 1166 ob_to_copy = ob;
1190 } 1167 }
1191 } 1168 }
1192 new_ob = object_create_clone (ob_to_copy); 1169
1193 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1170 new_ob = ob_to_copy->deep_clone ();
1171 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1194 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1172 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1195 } 1173 }
1196 else 1174 else
1197 { 1175 {
1198 if (creator->other_arch == NULL) 1176 if (!creator->other_arch)
1199 { 1177 {
1200 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",
1201 &creator->name, &creator->map->path, creator->x, creator->y); 1179 &creator->name, &creator->map->path, creator->x, creator->y);
1202 return; 1180 return;
1203 } 1181 }
… …
1205 new_ob = object_create_arch (creator->other_arch); 1183 new_ob = object_create_arch (creator->other_arch);
1206 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1184 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1207 } 1185 }
1208 1186
1209 /* Make sure this multipart object fits */ 1187 /* Make sure this multipart object fits */
1210 if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y)) 1188 if (new_ob->arch->more && new_ob->blocked (creator->map, creator->x, creator->y))
1211 { 1189 {
1212 new_ob->destroy (); 1190 new_ob->destroy ();
1213 return; 1191 return;
1214 } 1192 }
1215 1193
1216 // for now lets try to identify everything generated here, it mostly 1194 // for now lets try to identify everything generated here, it mostly
1217 // 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
1218 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1196 if (new_ob->need_identify ())
1197 new_ob->set_flag (FLAG_IDENTIFIED);
1219 1198
1220 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);
1221 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1200 if (new_ob->flag [FLAG_FREED])
1222 return; 1201 return;
1223 1202
1224 if (creator->slaying) 1203 if (creator->slaying)
1225 {
1226 new_ob->name = new_ob->title = creator->slaying; 1204 new_ob->name = new_ob->title = creator->slaying;
1227 }
1228} 1205}
1229 1206
1230/* move_marker --peterm@soda.csua.berkeley.edu 1207/* move_marker --peterm@soda.csua.berkeley.edu
1231 when moved, a marker will search for a player sitting above 1208 when moved, a marker will search for a player sitting above
1232 it, and insert an invisible, weightless force into him 1209 it, and insert an invisible, weightless force into him
… …
1242 { 1219 {
1243 /* remove an old force with a slaying field == op->name */ 1220 /* remove an old force with a slaying field == op->name */
1244 if (object *force = tmp->force_find (op->name)) 1221 if (object *force = tmp->force_find (op->name))
1245 force->destroy (); 1222 force->destroy ();
1246 1223
1247 if (!tmp->force_find (op->slaying)) 1224 if (op->slaying && !tmp->force_find (op->slaying))
1248 { 1225 {
1249 tmp->force_add (op->slaying, op->stats.food); 1226 tmp->force_add (op->slaying, op->stats.food);
1250 1227
1251 if (op->msg) 1228 if (op->msg)
1252 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg); 1229 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
… …
1264 } 1241 }
1265 } 1242 }
1266 } 1243 }
1267} 1244}
1268 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
1269void 1292void
1270process_object (object *op) 1293process_object (object *op)
1271{ 1294{
1272 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1295 if (ecb_expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1273 return; 1296 return;
1274 1297
1275 if (expect_false (INVOKE_OBJECT (TICK, op))) 1298 if (ecb_expect_false (INVOKE_OBJECT (TICK, op)))
1276 return; 1299 return;
1277 1300
1278 if (QUERY_FLAG (op, FLAG_MONSTER)) 1301 if (op->flag [FLAG_MONSTER])
1279 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1302 if (move_monster (op) || op->flag [FLAG_FREED])
1280 return; 1303 return;
1281 1304
1282 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1305 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1283 { 1306 {
1284 animate_object (op, op->contr ? op->facing : op->direction); 1307 animate_object (op, op->contr ? op->facing : op->direction);
1285 1308
1286 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1309 if (op->flag [FLAG_SEE_ANYWHERE])
1287 make_sure_seen (op); 1310 make_sure_seen (op);
1288 } 1311 }
1289 1312
1290 if (expect_false ( 1313 if (ecb_expect_false (
1291 op->flag [FLAG_GENERATOR] 1314 op->flag [FLAG_GENERATOR]
1292 || op->flag [FLAG_CHANGING] 1315 || op->flag [FLAG_CHANGING]
1293 || op->flag [FLAG_IS_USED_UP] 1316 || op->flag [FLAG_IS_USED_UP]
1294 )) 1317 ))
1295 { 1318 {
1296 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1319 if (op->flag [FLAG_CHANGING] && !op->state)
1297 { 1320 {
1298 change_object (op); 1321 change_object (op);
1299 return; 1322 return;
1300 } 1323 }
1301 1324
1302 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1325 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1303 generate_monster (op); 1326 generate_monster (op);
1304 1327
1305 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1328 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1306 { 1329 {
1307 if (QUERY_FLAG (op, FLAG_APPLIED)) 1330 if (op->flag [FLAG_APPLIED])
1308 remove_force (op); 1331 remove_force (op);
1309 else 1332 else
1310 { 1333 {
1311 /* If necessary, delete the item from the players inventory */ 1334 op->remove (); // TODO: really necessary?
1312 if (object *pl = op->in_player ())
1313 esrv_del_item (pl->contr, op->count);
1314 1335
1315 op->remove ();
1316
1317 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1336 if (op->flag [FLAG_SEE_ANYWHERE])
1318 make_sure_not_seen (op); 1337 make_sure_not_seen (op);
1319 1338
1320 op->destroy (); 1339 op->drop_and_destroy ();
1321 } 1340 }
1322 1341
1323 return; 1342 return;
1324 } 1343 }
1325 } 1344 }
… …
1449 1468
1450 case PLAYER: 1469 case PLAYER:
1451 // players have their own speed-management, so undo the --speed_left 1470 // players have their own speed-management, so undo the --speed_left
1452 ++op->speed_left; 1471 ++op->speed_left;
1453 break; 1472 break;
1454 }
1455}
1456 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