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

Diff Legend

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