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.43 by root, Sat Apr 21 16:56:32 2007 UTC vs.
Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * 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 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 23 */
24 24
25/* 25/*
26 * Routines that is executed from objects based on their speed have been 26 * Routines that is executed from objects based on their speed have been
27 * collected in this file. 27 * collected in this file.
… …
35 * so those will be removed shortly (in a cascade like fashion.) 35 * so those will be removed shortly (in a cascade like fashion.)
36 */ 36 */
37void 37void
38remove_door (object *op) 38remove_door (object *op)
39{ 39{
40 int i; 40 for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
41 {
41 object *tmp; 42 object *tmp;
42 43 mapxy pos (op);
43 for (i = 1; i < 9; i += 2) 44 pos.move (i);
44 if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL) 45 if (pos.normalise ()
46 && (tmp = present (DOOR, pos.m, pos.x, pos.y)))
45 { 47 {
46 tmp->set_speed (0.1); 48 tmp->set_speed (0.1f);
47 tmp->speed_left = -0.2; 49 tmp->speed_left = -0.2f;
48 } 50 }
51 }
49 52
50 if (op->other_arch) 53 if (op->other_arch)
51 { 54 {
52 tmp = arch_to_object (op->other_arch); 55 object *tmp = op->other_arch->instance ();
53 tmp->x = op->x; 56 tmp->x = op->x;
54 tmp->y = op->y; 57 tmp->y = op->y;
55 tmp->map = op->map; 58 tmp->map = op->map;
56 tmp->level = op->level; 59 tmp->level = op->level;
57 insert_ob_in_map (tmp, op->map, op, 0); 60 insert_ob_in_map (tmp, op->map, op, 0);
58 } 61 }
59 62
60 op->destroy (); 63 op->drop_and_destroy ();
61} 64}
62 65
63void 66void
64remove_door2 (object *op) 67remove_door2 (object *op)
65{ 68{
… …
69 for (i = 1; i < 9; i += 2) 72 for (i = 1; i < 9; i += 2)
70 { 73 {
71 tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]); 74 tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);
72 if (tmp && tmp->slaying == op->slaying) 75 if (tmp && tmp->slaying == op->slaying)
73 { /* same key both doors */ 76 { /* same key both doors */
74 tmp->set_speed (0.1); 77 tmp->set_speed (0.1f);
75 tmp->speed_left = -0.2; 78 tmp->speed_left = -0.2f;
76 } 79 }
77 } 80 }
78 81
79 if (op->other_arch) 82 if (op->other_arch)
80 { 83 {
81 tmp = arch_to_object (op->other_arch); 84 tmp = op->other_arch->instance ();
82 tmp->x = op->x; 85 tmp->x = op->x;
83 tmp->y = op->y; 86 tmp->y = op->y;
84 tmp->map = op->map; 87 tmp->map = op->map;
85 tmp->level = op->level; 88 tmp->level = op->level;
86 insert_ob_in_map (tmp, op->map, op, 0); 89 insert_ob_in_map (tmp, op->map, op, 0);
87 } 90 }
88 91
89 op->destroy (); 92 op->drop_and_destroy ();
90} 93}
91 94
92/* Will generate a monster according to content 95static void
93 * of generator.
94 */
95void
96generate_monster_inv (object *gen) 96generate_monster (object *gen)
97{ 97{
98 int i;
99 object *op, *head = NULL;
100
101 int qty = 0;
102
103 /* Code below assumes the generator is on a map, as it tries
104 * to place the monster on the map. So if the generator
105 * isn't on a map, complain and exit.
106 */
107 if (gen->map == NULL)
108 {
109 //LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
110 return;
111 }
112
113 /*First count numer of objects in inv */
114 for (op = gen->inv; op; op = op->below)
115 qty++;
116
117 if (!qty)
118 {
119 LOG (llevError, "Generator (%s) has no inventory in generate_monster_inv?\n", &gen->name);
120 return; /*No inventory */
121 }
122 qty = rndm (0, qty - 1);
123 for (op = gen->inv; qty; qty--)
124 op = op->below;
125
126 i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);
127 if (i == -1)
128 return;
129
130 head = object_create_clone (op);
131 CLEAR_FLAG (head, FLAG_IS_A_TEMPLATE);
132 unflag_inv (head, FLAG_IS_A_TEMPLATE);
133 if (rndm (0, 9))
134 generate_artifact (head, gen->map->difficulty);
135
136 insert_ob_in_map_at (head, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]);
137 if (QUERY_FLAG (head, FLAG_FREED))
138 return;
139
140 if (head->has_random_items ())
141 create_treasure (head->randomitems, head, GT_APPLY, gen->map->difficulty, 0);
142}
143
144void
145generate_monster_arch (object *gen)
146{
147 int i;
148 object *op, *head = NULL, *prev = NULL;
149 archetype *at = gen->other_arch;
150
151 if (!gen->other_arch)
152 return;
153
154 /* Code below assumes the generator is on a map, as it tries
155 * to place the monster on the map. So if the generator
156 * isn't on a map, complain and exit.
157 */
158 if (!gen->map) 98 if (!gen->map)
159 return; 99 return;
160 100
161 i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9); 101 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
162 if (i == -1)
163 return; 102 return;
164 103
165 while (at) 104 // sleeping generators won't generate, this will make monsters like
105 // centipedes not generate more centipedes when being asleep.
106 if (gen->flag [FLAG_SLEEP])
107 return;
108
109 object *op;
110 int dir;
111
112 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
113 {
114 // either copy one item from the inventory...
115 if (!gen->inv)
116 return;
117
118 // first select one item from the inventory
119 int index = 0;
120 for (object *tmp = gen->inv; tmp; tmp = tmp->below)
121 if (!rndm (++index))
122 op = tmp;
123
124 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
125 if (dir < 0)
126 return;
127
128 op = op->deep_clone ();
129
130 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);
131 unflag_inv (op, FLAG_IS_A_TEMPLATE);
166 { 132 }
167 op = arch_to_object (at); 133 else if (gen->other_arch)
168 op->x = gen->x + freearr_x[i] + at->clone.x; 134 {
169 op->y = gen->y + freearr_y[i] + at->clone.y; 135 // ...or use other_arch
136 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
137 if (dir < 0)
138 return;
170 139
171 if (head) 140 op = gen->other_arch->instance ();
172 op->head = head, prev->more = op; 141 }
142 else
143 return;
173 144
145 op->expand_tail ();
146
147 mapxy pos (gen); pos.move (dir);
148
149 if (pos.insert (op, gen))
150 {
174 if (rndm (0, 9)) 151 if (rndm (0, 9))
175 generate_artifact (op, gen->map->difficulty); 152 generate_artifact (op, gen->map->difficulty);
176 153
177 insert_ob_in_map (op, gen->map, gen, 0);
178 if (QUERY_FLAG (op, FLAG_FREED))
179 return;
180
181 if (op->has_random_items ()) 154 if (op->has_random_items ())
182 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0); 155 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);
183 156
184 if (head == NULL)
185 head = op;
186
187 prev = op;
188 at = at->more;
189 }
190}
191
192void
193generate_monster (object *gen)
194{
195
196 if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
197 return; 157 return;
158 }
198 159
199 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 160 op->destroy ();
200 generate_monster_inv (gen);
201 else
202 generate_monster_arch (gen);
203
204} 161}
205 162
206void 163static void
207remove_force (object *op) 164remove_force (object *op)
208{ 165{
209 if (--op->duration > 0) 166 if (--op->duration > 0)
210 return; 167 return;
211 168
… …
223 } 180 }
224 181
225 op->destroy (); 182 op->destroy ();
226} 183}
227 184
228void 185static void
229remove_blindness (object *op) 186remove_blindness (object *op)
230{ 187{
231 if (--op->stats.food > 0) 188 if (--op->stats.food > 0)
232 return; 189 return;
233 190
… …
240 } 197 }
241 198
242 op->destroy (); 199 op->destroy ();
243} 200}
244 201
245void 202static void
246poison_more (object *op) 203poison_more (object *op)
247{ 204{
248 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0) 205 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0)
249 { 206 {
250 op->destroy (); 207 op->destroy ();
… …
275 232
276 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 233 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
277} 234}
278 235
279 236
280void 237static void
281move_gate (object *op) 238move_gate (object *op)
282{ /* 1 = going down, 0 = goind up */ 239{ /* 1 = going down, 0 = going up */
283 object *tmp; 240 object *tmp;
284 241
285 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 242 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
286 { 243 {
287 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op)); 244 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op));
… …
292 if (op->value) 249 if (op->value)
293 { 250 {
294 if (--op->stats.wc <= 0) 251 if (--op->stats.wc <= 0)
295 { /* Reached bottom, let's stop */ 252 { /* Reached bottom, let's stop */
296 op->stats.wc = 0; 253 op->stats.wc = 0;
297 if (op->arch->clone.speed) 254 if (op->arch->has_active_speed ())
298 op->value = 0; 255 op->value = 0;
299 else 256 else
300 op->set_speed (0); 257 op->set_speed (0);
301 } 258 }
302 259
… …
322 * 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,
323 * otherwise, we fall through to the code below which should lower 280 * otherwise, we fall through to the code below which should lower
324 * the gate slightly. 281 * the gate slightly.
325 */ 282 */
326 283
327 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 284 for (tmp = op->above; tmp; tmp = tmp->above)
328 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 285 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
329 break; 286 break;
330 287
331 if (tmp == NULL) 288 if (!tmp)
332 { 289 {
333 if (op->arch->clone.speed) 290 if (op->arch->has_active_speed ())
334 op->value = 1; 291 op->value = 1;
335 else 292 else
336 op->set_speed (0); 293 op->set_speed (0);
337 294
338 return; 295 return;
… …
349 } 306 }
350 else 307 else
351 { /* The gate is still going up */ 308 { /* The gate is still going up */
352 op->stats.wc++; 309 op->stats.wc++;
353 310
354 if ((int) op->stats.wc >= (NUM_ANIMATIONS (op))) 311 if (op->stats.wc >= NUM_ANIMATIONS (op))
355 op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1; 312 op->stats.wc = NUM_ANIMATIONS (op) - 1;
356 313
357 /* If there is something on top of the gate, we try to roll it off. 314 /* If there is something on top of the gate, we try to roll it off.
358 * If a player/monster, we don't roll, we just hit them with damage 315 * If a player/monster, we don't roll, we just hit them with damage
359 */ 316 */
360 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 317 if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
361 { 318 {
362 /* Halfway or further, check blocks */ 319 /* Halfway or further, check blocks */
363 /* First, get the top object on the square. */ 320 /* First, get the top object on the square. */
364 for (tmp = op->above; tmp != NULL && tmp->above != NULL; tmp = tmp->above); 321 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
322 ;
365 323
366 if (tmp != NULL) 324 if (tmp)
367 { 325 {
368 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 326 if (QUERY_FLAG (tmp, FLAG_ALIVE))
369 { 327 {
370 hit_player (tmp, random_roll (1, 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);
329 op->play_sound (sound_find ("blocked_gate"));
330
371 if (tmp->type == PLAYER) 331 if (tmp->type == PLAYER)
372 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name); 332 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
373 } 333 }
374 else
375 /* If the object is not alive, and the object either can 334 /* If the object is not alive, and the object either can
376 * be picked up or the object rolls, move the object 335 * be picked up or the object rolls, move the object
377 * off the gate. 336 * off the gate.
378 */ 337 */
379 if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL))) 338 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
380 { 339 {
381 /* If it has speed, it should move itself, otherwise: */ 340 /* If it has speed, it should move itself, otherwise: */
382 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9); 341 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
383 342
384 /* If there is a free spot, move the object someplace */ 343 /* If there is a free spot, move the object someplace */
385 if (i != -1) 344 if (i > 0)
386 { 345 {
346 mapxy pos (tmp);
347 pos.move (i);
348 if (pos.normalise ())
387 tmp->remove (); 349 tmp->move_to (pos);
388 tmp->x += freearr_x[i], tmp->y += freearr_y[i];
389 insert_ob_in_map (tmp, op->map, op, 0);
390 } 350 }
391 } 351 }
392 } 352 }
393 353
394 /* See if there is still anything blocking the gate */ 354 /* See if there is still anything blocking the gate */
395 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 355 for (tmp = op->above; tmp; tmp = tmp->above)
396 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 356 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
397 break; 357 break;
398 358
399 /* IF there is, start putting the gate down */ 359 /* IF there is, start putting the gate down */
400 if (tmp) 360 if (tmp)
401 {
402 op->stats.food = 1; 361 op->stats.food = 1;
403 }
404 else 362 else
405 { 363 {
406 op->move_block = MOVE_ALL; 364 op->move_block = MOVE_ALL;
365
407 if (!op->arch->clone.stats.ac) 366 if (!op->arch->stats.ac)
408 SET_FLAG (op, FLAG_BLOCKSVIEW); 367 SET_FLAG (op, FLAG_BLOCKSVIEW);
409 update_all_los (op->map, op->x, op->y); 368 update_all_los (op->map, op->x, op->y);
410 } 369 }
411 } /* gate is halfway up */ 370 } /* gate is halfway up */
412 371
… …
417 376
418/* hp : how long door is open/closed 377/* hp : how long door is open/closed
419 * maxhp : initial value for hp 378 * maxhp : initial value for hp
420 * sp : 1 = open, 0 = close 379 * sp : 1 = open, 0 = close
421 */ 380 */
422void 381static void
423move_timed_gate (object *op) 382move_timed_gate (object *op)
424{ 383{
425 int v = op->value; 384 int v = op->value;
426 385
427 if (op->stats.sp) 386 if (op->stats.sp)
428 { 387 {
429 move_gate (op); 388 move_gate (op);
389
430 if (op->value != v) /* change direction ? */ 390 if (op->value != v) /* change direction ? */
431 op->stats.sp = 0; 391 op->stats.sp = 0;
432 return; 392 return;
433 } 393 }
394
434 if (--op->stats.hp <= 0) 395 if (--op->stats.hp <= 0)
435 { /* keep gate down */ 396 { /* keep gate down */
436 move_gate (op); 397 move_gate (op);
398
437 if (op->value != v) 399 if (op->value != v)
438 op->set_speed (0); 400 op->set_speed (0);
439 } 401 }
440} 402}
441 403
… …
443 * speed: frequency of 'glances' 405 * speed: frequency of 'glances'
444 * connected: connected value of detector 406 * connected: connected value of detector
445 * sp: 1 if detection sets buttons 407 * sp: 1 if detection sets buttons
446 * -1 if detection unsets buttons 408 * -1 if detection unsets buttons
447 */ 409 */
448 410static void
449void
450move_detector (object *op) 411move_detector (object *op)
451{ 412{
452 object *tmp; 413 object *tmp;
453 int last = op->value; 414 int last = op->value;
454 int detected; 415 int detected;
455 416
456 detected = 0; 417 detected = 0;
457 418
458 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above) 419 for (tmp = op->ms ().bot; tmp && !detected; tmp = tmp->above)
459 { 420 {
460 object *tmp2; 421 object *tmp2;
461 422
462 if (op->stats.hp) 423 if (op->stats.hp)
463 { 424 {
… …
481 if (op->stats.sp == 1) 442 if (op->stats.sp == 1)
482 { 443 {
483 if (detected && last == 0) 444 if (detected && last == 0)
484 { 445 {
485 op->value = 1; 446 op->value = 1;
486 push_button (op); 447 push_button (op, tmp);
487 } 448 }
449
488 if (!detected && last == 1) 450 if (!detected && last == 1)
489 { 451 {
490 op->value = 0; 452 op->value = 0;
491 push_button (op); 453 push_button (op, tmp);
492 } 454 }
493 } 455 }
494 else 456 else
495 { /* in this case, we unset buttons */ 457 { /* in this case, we unset buttons */
496 if (detected && last == 1) 458 if (detected && last == 1)
497 { 459 {
498 op->value = 0; 460 op->value = 0;
499 push_button (op); 461 push_button (op, tmp);
500 } 462 }
463
501 if (!detected && last == 0) 464 if (!detected && last == 0)
502 { 465 {
503 op->value = 1; 466 op->value = 1;
504 push_button (op); 467 push_button (op, tmp);
505 } 468 }
506 } 469 }
507} 470}
508
509 471
510void 472void
511animate_trigger (object *op) 473animate_trigger (object *op)
512{ 474{
513 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 475 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
… …
520 SET_ANIMATION (op, op->stats.wc); 482 SET_ANIMATION (op, op->stats.wc);
521 update_object (op, UP_OBJ_FACE); 483 update_object (op, UP_OBJ_FACE);
522 } 484 }
523} 485}
524 486
525void 487static void
526move_hole (object *op) 488move_hole (object *op)
527{ /* 1 = opening, 0 = closing */ 489{ /* 1 = opening, 0 = closing */
528 object *next, *tmp;
529
530 if (op->value) 490 if (op->value)
531 { /* We're opening */ 491 { /* We're opening */
532 if (--op->stats.wc <= 0) 492 if (--op->stats.wc <= 0)
533 { /* Opened, let's stop */ 493 { /* Opened, let's stop */
534 op->stats.wc = 0; 494 op->stats.wc = 0;
535 op->set_speed (0); 495 op->set_speed (0);
536 496
537 /* Hard coding this makes sense for holes I suppose */ 497 /* Hard coding this makes sense for holes I suppose */
538 op->move_on = MOVE_WALK; 498 op->move_on = MOVE_WALK;
539 for (tmp = op->above; tmp != NULL; tmp = next) 499 for (object *next, *tmp = op->above; tmp; tmp = next)
540 { 500 {
541 next = tmp->above; 501 next = tmp->above;
542 move_apply (op, tmp, tmp); 502 move_apply (op, tmp, tmp);
543 } 503 }
544 } 504 }
545 505
546 SET_ANIMATION (op, op->stats.wc); 506 SET_ANIMATION (op, op->stats.wc);
547 update_object (op, UP_OBJ_FACE); 507 update_object (op, UP_OBJ_FACE);
548 return; 508 return;
549 } 509 }
510
550 /* We're closing */ 511 /* We're closing */
551 op->move_on = 0; 512 op->move_on = 0;
552 513
553 op->stats.wc++; 514 op->stats.wc++;
554 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 515 if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
… …
585 { 546 {
586 object *payload = op->inv; 547 object *payload = op->inv;
587 548
588 if (payload == NULL) 549 if (payload == NULL)
589 return NULL; 550 return NULL;
551
590 payload->remove (); 552 payload->remove ();
591 op->destroy (); 553 op->destroy ();
592 return payload; 554 return payload;
593 } 555 }
594 556
… …
629 return NULL; 591 return NULL;
630 } 592 }
631 593
632 op->set_speed (0); 594 op->set_speed (0);
633 op->direction = 0; 595 op->direction = 0;
634 op->move_on = 0; 596 op->move_on = 0;
635 op->move_type = 0; 597 op->move_type = 0;
598 op->skill = 0; // really?
599
600 // restore original wc, dam, attacktype and slaying
636 op->stats.wc = op->stats.sp; 601 op->stats.wc = op->stats.sp;
637 op->stats.dam = op->stats.hp; 602 op->stats.dam = op->stats.hp;
638 op->attacktype = op->stats.grace; 603 op->attacktype = op->stats.grace;
639 op->slaying = 0; 604 op->slaying = op->custom_name;
640 op->skill = 0;
641 605
642 if (op->spellarg != NULL)
643 {
644 op->slaying = op->spellarg;
645 free (op->spellarg);
646 op->spellarg = NULL;
647 }
648 else
649 op->slaying = NULL;
650
651 /* 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 */
652 op->spellarg = NULL; 607 op->custom_name = 0;
653 op->stats.sp = 0; 608 op->stats.sp = 0;
654 op->stats.hp = 0; 609 op->stats.hp = 0;
655 op->stats.grace = 0; 610 op->stats.grace = 0;
656 op->level = 0; 611 op->level = 0;
657 op->face = op->arch->clone.face; 612 op->face = op->arch->face;
658 op->owner = NULL; /* So that stopped arrows will be saved */ 613 op->owner = 0;
614
659 update_object (op, UP_OBJ_CHANGE); 615 update_object (op, UP_OBJ_CHANGE);
616
660 return op; 617 return op;
661} 618}
662 619
663/* stop_arrow() - what to do when a non-living flying object 620/* stop_arrow() - what to do when a non-living flying object
664 * has to stop. Sept 96 - I added in thrown object code in 621 * has to stop. Sept 96 - I added in thrown object code in
… …
673 if (INVOKE_OBJECT (STOP, op)) 630 if (INVOKE_OBJECT (STOP, op))
674 return; 631 return;
675 632
676 if (op->inv) 633 if (op->inv)
677 { 634 {
635 // replace this by straightforward drop to ground?
678 object *payload = op->inv; 636 object *payload = op->inv;
679 637
680 payload->remove ();
681 payload->owner = 0; 638 payload->owner = 0;
682 insert_ob_in_map (payload, op->map, payload, 0); 639 insert_ob_in_map (payload, op->map, payload, 0);
683 op->destroy (); 640 op->destroy ();
684 } 641 }
685 else 642 else
686 { 643 {
687 op = fix_stopped_arrow (op); 644 op = fix_stopped_arrow (op);
645
688 if (op) 646 if (op)
689 merge_ob (op, NULL); 647 merge_ob (op, 0);
690 } 648 }
691} 649}
692 650
693/* Move an arrow along its course. op is the arrow or thrown object. 651/* Move an arrow along its course. op is the arrow or thrown object.
694 */ 652 */
695void 653void
696move_arrow (object *op) 654move_arrow (object *op)
697{ 655{
698 object *tmp;
699 sint16 new_x, new_y;
700 int was_reflected, mflags; 656 int was_reflected;
701 maptile *m;
702 657
703 if (op->map == NULL) 658 if (!op->map)
704 { 659 {
705 LOG (llevError, "BUG: Arrow had no map.\n"); 660 LOG (llevError, "BUG: Arrow had no map.\n");
706 op->destroy (); 661 op->destroy ();
707 return; 662 return;
708 } 663 }
… …
716 * is if the player throws a bomb - the bomb explodes on its own, 671 * is if the player throws a bomb - the bomb explodes on its own,
717 * but this object sticks around. We could handle the cleanup in the 672 * but this object sticks around. We could handle the cleanup in the
718 * bomb code, but there are potential other cases where that could happen, 673 * bomb code, but there are potential other cases where that could happen,
719 * and it is easy enough to clean it up here. 674 * and it is easy enough to clean it up here.
720 */ 675 */
721 if (op->inv == NULL) 676 if (!op->inv)
722 { 677 {
723 op->destroy (); 678 op->destroy ();
724 return; 679 return;
725 } 680 }
726 681
… …
738 stop_arrow (op); 693 stop_arrow (op);
739 return; 694 return;
740 } 695 }
741 696
742 /* Calculate target map square */ 697 /* Calculate target map square */
743 new_x = op->x + DIRX (op);
744 new_y = op->y + DIRY (op);
745 was_reflected = 0; 698 was_reflected = 0;
746 699
747 m = op->map; 700 mapxy pos (op); pos.move (op->direction);
748 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
749 701
750 if (mflags & P_OUT_OF_MAP) 702 if (!pos.normalise ())
751 { 703 {
752 stop_arrow (op); 704 stop_arrow (op);
753 return; 705 return;
754 } 706 }
755 707
756 /* only need to look for living creatures if this flag is set */ 708 /* only need to look for living creatures if this flag is set */
757 if (mflags & P_IS_ALIVE) 709 if (pos->flags () & P_IS_ALIVE)
758 { 710 {
759 for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above) 711 object *tmp;
712
713 for (tmp = pos->bot; tmp; tmp = tmp->above)
760 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 714 if (QUERY_FLAG (tmp, FLAG_ALIVE))
761 break; 715 break;
762 716
763 /* Not really fair, but don't let monsters hit themselves with 717 /* Not really fair, but don't let monsters hit themselves with
764 * their own arrow - this can be because they fire it then 718 * their own arrow - this can be because they fire it then
… …
787 return; 741 return;
788 } 742 }
789 } /* if this is not hitting its owner */ 743 } /* if this is not hitting its owner */
790 } /* if there is something alive on this space */ 744 } /* if there is something alive on this space */
791 745
792 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 746 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
793 { 747 {
794 int retry = 0; 748 int retry = 0;
795 749
796 /* if the object doesn't reflect, stop the arrow from moving 750 /* if the object doesn't reflect, stop the arrow from moving
797 * note that this code will now catch cases where a monster is 751 * note that this code will now catch cases where a monster is
… …
810 if (op->direction & 1) 764 if (op->direction & 1)
811 { 765 {
812 op->direction = absdir (op->direction + 4); 766 op->direction = absdir (op->direction + 4);
813 retry = 1; 767 retry = 1;
814 } 768 }
769
815 /* There were two blocks with identical code - 770 /* There were two blocks with identical code -
816 * use this retry here to make this one block 771 * use this retry here to make this one block
817 * that did the same thing. 772 * that did the same thing.
818 */ 773 */
819 while (retry < 2) 774 while (retry < 2)
820 { 775 {
821 int left, right, mflags;
822 maptile *m1;
823 sint16 x1, y1;
824
825 retry++; 776 retry++;
826 777
827 /* Need to check for P_OUT_OF_MAP: if the arrow is tavelling 778 /* Need to check for P_OUT_OF_MAP: if the arrow is travelling
828 * over a corner in a tiled map, it is possible that 779 * over a corner in a tiled map, it is possible that
829 * op->direction is within an adjacent map but either 780 * op->direction is within an adjacent map but either
830 * op->direction-1 or op->direction+1 does not exist. 781 * op->direction-1 or op->direction+1 does not exist.
831 */ 782 */
832 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)], 783 mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
833 op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1); 784 bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
834 left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
835 785
836 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)], 786 mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
837 op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1); 787 bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
838 right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
839 788
840 if (left == right) 789 if (left == right)
841 op->direction = absdir (op->direction + 4); 790 op->direction = absdir (op->direction + 4);
842 else if (left) 791 else if (left)
843 op->direction = absdir (op->direction + 2); 792 op->direction = absdir (op->direction + 2);
844 else if (right) 793 else if (right)
845 op->direction = absdir (op->direction - 2); 794 op->direction = absdir (op->direction - 2);
846 795
847 mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
848
849 /* If this space is not out of the map and not blocked, valid space - 796 /* If this space is not out of the map and not blocked, valid space -
850 * don't need to retry again. 797 * don't need to retry again.
851 */ 798 */
852 if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1))) 799 mapxy pos3 (pos); pos3.move (op->direction);
800 if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
853 break; 801 break;
854
855 } 802 }
803
856 /* Couldn't find a direction to move the arrow to - just 804 /* Couldn't find a direction to move the arrow to - just
857 * top it from moving. 805 * stop it from moving.
858 */ 806 */
859 if (retry == 2) 807 if (retry == 2)
860 { 808 {
861 stop_arrow (op); 809 stop_arrow (op);
862 return; 810 return;
863 } 811 }
812
864 /* update object image for new facing */ 813 /* update object image for new facing */
865 /* many thrown objects *don't* have more than one face */ 814 /* many thrown objects *don't* have more than one face */
866 if (GET_ANIM_ID (op)) 815 if (op->has_anim ())
867 SET_ANIMATION (op, op->direction); 816 op->set_anim_frame (op->direction);
868 } /* object is reflected */ 817 } /* object is reflected */
869 } /* object ran into a wall */ 818 } /* object ran into a wall */
870
871 /* Move the arrow. */
872 op->remove ();
873 op->x = new_x;
874 op->y = new_y;
875 819
876 /* decrease the speed as it flies. 0.05 means a standard bow will shoot 820 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
877 * about 17 squares. Tune as needed. 821 * about 17 squares. Tune as needed.
878 */ 822 */
879 op->speed -= 0.05; 823 op->speed -= 0.05;
880 insert_ob_in_map (op, m, op, 0);
881}
882 824
883/* This routine doesnt seem to work for "inanimate" objects that 825 /* Move the arrow. */
884 * are being carried, ie a held torch leaps from your hands!. 826 op->move_to (pos);
885 * Modified this routine to allow held objects. b.t. */ 827}
886 828
887void 829static void
888change_object (object *op) 830change_object (object *op)
889{ /* Doesn`t handle linked objs yet */ 831{ /* Doesn`t handle linked objs yet */
890 int i, j;
891
892 if (op->other_arch == NULL) 832 if (!op->other_arch)
893 { 833 {
894 LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name); 834 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
895 return; 835 return;
896 } 836 }
897 837
898 /* In non-living items only change when food value is 0 */ 838 /* In non-living items only change when food value is 0 */
899 if (!QUERY_FLAG (op, FLAG_ALIVE)) 839 if (!QUERY_FLAG (op, FLAG_ALIVE))
900 { 840 {
901 if (op->stats.food-- > 0) 841 if (op->stats.food-- > 0)
902 return; 842 return;
843
844 op->stats.food = 1; /* so 1 other_arch is made */
845 }
846
847 object *env = op->env;
848
849 op->remove ();
850 for (int i = 0; i < op->stats.food; i++)
851 {
852 object *tmp = op->other_arch->instance ();
853
854 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
855
856 if (env)
857 env->insert (tmp);
903 else 858 else
904 op->stats.food = 1; /* so 1 other_arch is made */
905 }
906
907 object *pl = op->in_player ();
908 object *env = op->env;
909
910 op->remove ();
911 for (i = 0; i < NROFNEWOBJS (op); i++)
912 {
913 object *tmp = arch_to_object (op->other_arch);
914
915 if (op->type == LAMP)
916 tmp->stats.food = op->stats.food - 1;
917
918 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
919 if (env)
920 {
921 tmp->x = env->x, tmp->y = env->y;
922 tmp = insert_ob_in_ob (tmp, env);
923
924 /* If this object is the players inventory, we need to tell the
925 * client of the change. Insert_ob_in_map takes care of the
926 * updating the client, so we don't need to do that below.
927 */
928 if (pl)
929 {
930 esrv_del_item (pl->contr, op->count);
931 esrv_send_item (pl, tmp);
932 }
933 } 859 {
934 else
935 {
936 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
937 if (j == -1) /* No free spot */ 862 if (j < 0) /* No free spot */
938 tmp->destroy (); 863 tmp->destroy ();
939 else 864 else
940 { 865 {
941 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j]; 866 mapxy pos (op); pos.move (j);
942 insert_ob_in_map (tmp, op->map, op, 0); 867
868 if (pos.normalise ())
869 pos.insert (tmp, op);
943 } 870 }
944 } 871 }
945 } 872 }
946 873
947 op->destroy (); 874 op->destroy ();
… …
963 move_teleporter (op->more); 890 move_teleporter (op->more);
964 891
965 if (op->head) 892 if (op->head)
966 head = op->head; 893 head = op->head;
967 894
968 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 895 for (tmp = op->above; tmp; tmp = tmp->above)
969 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 896 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR))
970 break; 897 break;
971 898
972 /* If nothing above us to move, nothing to do */ 899 /* If nothing above us to move, nothing to do */
973 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 900 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS))
… …
1003 else 930 else
1004 { 931 {
1005 /* Random teleporter */ 932 /* Random teleporter */
1006 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 933 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1007 return; 934 return;
935
1008 teleport (head, TELEPORTER, tmp); 936 teleport (head, TELEPORTER, tmp);
1009 } 937 }
1010} 938}
1011
1012 939
1013/* This object will teleport someone to a different map 940/* This object will teleport someone to a different map
1014 and will also apply changes to the player from its inventory. 941 and will also apply changes to the player from its inventory.
1015 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
1016 can't be generalized. 943 can't be generalized.
1017*/ 944*/
1018void 945static void
1019move_player_changer (object *op) 946move_player_changer (object *op)
1020{ 947{
1021 object *player;
1022 object *walk;
1023
1024 if (!op->above || !EXIT_PATH (op)) 948 if (!op->above || !EXIT_PATH (op))
1025 return; 949 return;
1026 950
1027 /* This isn't all that great - means that the player_mover 951 /* This isn't all that great - means that the player_mover
1028 * needs to be on top. 952 * needs to be on top.
1029 */ 953 */
1030 if (op->above->type == PLAYER) 954 if (op->above->type == PLAYER)
1031 { 955 {
956 object *player = op->above;
957
1032 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 958 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
1033 return; 959 return;
1034 960
1035 player = op->above;
1036
1037 for (walk = op->inv; walk; walk = walk->below) 961 for (object *walk = op->inv; walk; walk = walk->below)
1038 apply_changes_to_player (player, walk); 962 apply_changes_to_player (player, walk);
1039 963
1040 player->update_stats (); 964 player->update_stats ();
1041 965
1042 esrv_send_inventory (op->above, op->above); 966 esrv_send_inventory (op->above, op->above);
… …
1069 return; /* dm has created a firewall in his inventory */ 993 return; /* dm has created a firewall in his inventory */
1070 994
1071 spell = op->inv; 995 spell = op->inv;
1072 996
1073 if (!spell || spell->type != SPELL) 997 if (!spell || spell->type != SPELL)
1074 spell = &op->other_arch->clone; 998 spell = op->other_arch;
1075 999
1076 if (!spell) 1000 if (!spell)
1077 { 1001 {
1078 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y); 1002 LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);
1079 return; 1003 return;
… …
1089 * 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.
1090 * 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,
1091 * 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,
1092 * it'll paralyze the victim for hp*his speed/op->speed 1016 * it'll paralyze the victim for hp*his speed/op->speed
1093 */ 1017 */
1094void 1018static void
1095move_player_mover (object *op) 1019move_player_mover (object *op)
1096{ 1020{
1097 object *victim, *nextmover;
1098 int dir = op->stats.sp; 1021 int dir = op->stats.sp;
1099 sint16 nx, ny; 1022 sint16 nx, ny;
1100 maptile *m; 1023 maptile *m;
1101 1024
1102 /* Determine direction now for random movers so we do the right thing */ 1025 /* Determine direction now for random movers so we do the right thing */
1103 if (!dir) 1026 if (!dir)
1104 dir = rndm (1, 8); 1027 dir = rndm (1, 8);
1105 1028
1106 for (victim = GET_MAP_OB (op->map, op->x, op->y); victim != NULL; victim = victim->above) 1029 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1107 { 1030 {
1108 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1031 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&
1109 (victim->move_type & op->move_type || !victim->move_type)) 1032 (victim->move_type & op->move_type || !victim->move_type))
1110 { 1033 {
1111 1034
… …
1128 } 1051 }
1129 1052
1130 if (should_director_abort (op, victim)) 1053 if (should_director_abort (op, victim))
1131 return; 1054 return;
1132 1055
1133 for (nextmover = GET_MAP_OB (m, nx, ny); nextmover != NULL; nextmover = nextmover->above) 1056 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1134 { 1057 {
1135 if (nextmover->type == PLAYERMOVER) 1058 if (nextmover->type == PLAYERMOVER)
1136 nextmover->speed_left = -.99; 1059 nextmover->speed_left = -.99f;
1060
1137 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1061 if (QUERY_FLAG (nextmover, FLAG_ALIVE))
1138 {
1139 op->speed_left = -1.1; /* wait until the next thing gets out of the way */ 1062 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1140 }
1141 } 1063 }
1142 1064
1143 if (victim->type == PLAYER) 1065 if (victim->type == PLAYER)
1144 { 1066 {
1145 /* only level >=1 movers move people */ 1067 /* only level >=1 movers move people */
1146 if (op->level) 1068 if (op->level)
1147 { 1069 {
1148 /* Following is a bit of hack. We need to make sure it 1070 /* Following is a bit of hack. We need to make sure it
1149 * is cleared, otherwise the player will get stuck in 1071 * is cleared, otherwise the player will get stuck in
1150 * place. This can happen if the player used a spell to 1072 * place. This can happen if the player used a spell to
1151 * get to this space. 1073 * get to this space.
1152 */ 1074 */
1153 victim->contr->fire_on = 0; 1075 victim->contr->fire_on = 0;
1154 victim->speed_left = -FABS (victim->speed); 1076 victim->speed_left = 1.f;
1155 move_player (victim, dir); 1077 move_player (victim, dir);
1156 } 1078 }
1157 else 1079 else
1158 return; 1080 return;
1159 } 1081 }
1160 else 1082 else
1161 move_object (victim, dir); 1083 victim->move (dir);
1162 1084
1163 if (!op->stats.maxsp && op->attacktype) 1085 if (!op->stats.maxsp && op->attacktype)
1164 op->stats.maxsp = 2; 1086 op->stats.maxsp = 2;
1165 1087
1166 if (op->attacktype) 1088 if (op->attacktype)
1167 { /* flag to paralyze the player */ 1089 { /* flag to paralyze the player */
1168
1169 victim->speed_left = -FABS (op->stats.maxsp * victim->speed / op->speed); 1090 victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1170 /* Not sure why, but for some chars on metalforge, they
1171 * would sometimes get -inf speed_left, and from the
1172 * description, it could only happen here, so just put
1173 * a lower sanity limit. My only guess is that the
1174 * mover has 0 speed.
1175 */
1176 if (victim->speed_left < -5.0)
1177 victim->speed_left = -5.0;
1178 } 1091 }
1179 } 1092 }
1180 } 1093 }
1181} 1094}
1182 1095
… …
1201 if (op->above == NULL) 1114 if (op->above == NULL)
1202 return; 1115 return;
1203 1116
1204 for (tmp = op->above; tmp; tmp = tmp->above) 1117 for (tmp = op->above; tmp; tmp = tmp->above)
1205 { 1118 {
1206 if (op->other_arch->name == tmp->arch->name) 1119 if (op->other_arch->archname == tmp->arch->archname)
1207 { 1120 {
1208 if (op->level <= 0) 1121 if (op->level <= 0)
1209 tmp->destroy (); 1122 tmp->destroy ();
1210 else 1123 else
1211 { 1124 {
… …
1233 * has to make sure that there is in fact space for the object. 1146 * has to make sure that there is in fact space for the object.
1234 * It should really do this for small objects also, but there is 1147 * It should really do this for small objects also, but there is
1235 * more concern with large objects, most notably a part being placed 1148 * more concern with large objects, most notably a part being placed
1236 * outside of the map which would cause the server to crash 1149 * outside of the map which would cause the server to crash
1237*/ 1150*/
1238
1239void 1151void
1240move_creator (object *creator) 1152move_creator (object *creator)
1241{ 1153{
1242 object *new_ob; 1154 object *new_ob;
1243 1155
… …
1245 { 1157 {
1246 creator->stats.hp = -1; 1158 creator->stats.hp = -1;
1247 return; 1159 return;
1248 } 1160 }
1249 1161
1250 if (creator->inv != NULL) 1162 if (creator->inv)
1251 { 1163 {
1252 object *ob; 1164 object *ob;
1253 int i; 1165 int i;
1254 object *ob_to_copy; 1166 object *ob_to_copy;
1255 1167
… …
1260 if (rndm (0, i) == 0) 1172 if (rndm (0, i) == 0)
1261 { 1173 {
1262 ob_to_copy = ob; 1174 ob_to_copy = ob;
1263 } 1175 }
1264 } 1176 }
1265 new_ob = object_create_clone (ob_to_copy); 1177 new_ob = ob_to_copy->deep_clone ();
1266 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1178 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);
1267 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1179 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1268 } 1180 }
1269 else 1181 else
1270 { 1182 {
1271 if (creator->other_arch == NULL) 1183 if (!creator->other_arch)
1272 { 1184 {
1273 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",
1274 &creator->name, &creator->map->path, creator->x, creator->y); 1186 &creator->name, &creator->map->path, creator->x, creator->y);
1275 return; 1187 return;
1276 } 1188 }
… …
1278 new_ob = object_create_arch (creator->other_arch); 1190 new_ob = object_create_arch (creator->other_arch);
1279 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1191 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1280 } 1192 }
1281 1193
1282 /* Make sure this multipart object fits */ 1194 /* Make sure this multipart object fits */
1283 if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y)) 1195 if (new_ob->arch->more && new_ob->blocked (creator->map, creator->x, creator->y))
1284 { 1196 {
1285 new_ob->destroy (); 1197 new_ob->destroy ();
1286 return; 1198 return;
1287 } 1199 }
1200
1201 // for now lets try to identify everything generated here, it mostly
1202 // happens automated, so this will at least fix many identify-experience holes
1203 SET_FLAG (new_ob, FLAG_IDENTIFIED);
1288 1204
1289 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y); 1205 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1290 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1206 if (QUERY_FLAG (new_ob, FLAG_FREED))
1291 return; 1207 return;
1292 1208
1293 if (creator->slaying) 1209 if (creator->slaying)
1294 {
1295 new_ob->name = new_ob->title = creator->slaying; 1210 new_ob->name = new_ob->title = creator->slaying;
1296 }
1297} 1211}
1298 1212
1299/* move_marker --peterm@soda.csua.berkeley.edu 1213/* move_marker --peterm@soda.csua.berkeley.edu
1300 when moved, a marker will search for a player sitting above 1214 when moved, a marker will search for a player sitting above
1301 it, and insert an invisible, weightless force into him 1215 it, and insert an invisible, weightless force into him
… …
1307void 1221void
1308move_marker (object *op) 1222move_marker (object *op)
1309{ 1223{
1310 if (object *tmp = op->ms ().player ()) 1224 if (object *tmp = op->ms ().player ())
1311 { 1225 {
1312 object *tmp2;
1313
1314 /* remove an old force with a slaying field == op->name */ 1226 /* remove an old force with a slaying field == op->name */
1315 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below) 1227 if (object *force = tmp->force_find (op->name))
1316 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->name) 1228 force->destroy ();
1229
1230 if (op->slaying && !tmp->force_find (op->slaying))
1317 { 1231 {
1318 tmp2->destroy (); 1232 tmp->force_add (op->slaying, op->stats.food);
1319 break;
1320 }
1321 1233
1322 /* cycle through his inventory to look for the MARK we want to
1323 * place
1324 */
1325 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326 if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
1327 break;
1328
1329 /* if we didn't find our own MARK */
1330 if (!tmp2)
1331 {
1332 object *force = get_archetype (FORCE_NAME);
1333
1334 if (op->stats.food)
1335 {
1336 force->set_speed (0.01);
1337 force->speed_left = -op->stats.food;
1338 }
1339 else
1340 force->set_speed (0);
1341
1342 /* put in the lock code */
1343 force->slaying = op->slaying;
1344
1345 if (op->lore)
1346 force->lore = op->lore;
1347
1348 insert_ob_in_ob (force, tmp);
1349 if (op->msg) 1234 if (op->msg)
1350 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg); 1235 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1351 1236
1352 if (op->stats.hp > 0) 1237 if (op->stats.hp > 0)
1353 { 1238 {
1354 op->stats.hp--; 1239 op->stats.hp--;
1240
1355 if (op->stats.hp == 0) 1241 if (op->stats.hp == 0)
1356 { 1242 {
1357 /* marker expires--granted mark number limit */ 1243 /* marker expires--granted mark number limit */
1358 op->destroy (); 1244 op->destroy ();
1359 return; 1245 return;
… …
1361 } 1247 }
1362 } 1248 }
1363 } 1249 }
1364} 1250}
1365 1251
1366int 1252// mapscript objects activate themselves (only) then their timer fires
1253// TODO: maybe they should simply trigger the link like any other object?
1254static void
1255move_mapscript (object *op)
1256{
1257 op->set_speed (0);
1258 cfperl_mapscript_activate (op, true, op, 0);
1259}
1260
1261static void
1262move_lamp (object *op)
1263{
1264 // if the lamp/torch is off, we should disable it.
1265 if (!op->glow_radius)
1266 {
1267 op->set_speed (0);
1268 return;
1269 }
1270 else
1271 {
1272 // check whether the face might need to be updated
1273 // (currently this is needed to have already switched on torches
1274 // on maps, as they just set the glow_radius in the archetype)
1275 if (op->other_arch
1276 && (
1277 (op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
1278 || (op->flag [FLAG_ANIMATE]
1279 ? (op->animation_id != op->other_arch->animation_id)
1280 : (op->face != op->other_arch->face))
1281 ))
1282 get_animation_from_arch (op, op->other_arch);
1283 }
1284
1285 // lamps and torches on maps don't use up their fuel
1286 if (op->is_on_map ())
1287 return;
1288
1289 if (op->stats.food > 0)
1290 {
1291 op->stats.food--;
1292 return;
1293 }
1294
1295 apply_lamp (op, false);
1296}
1297
1298void
1367process_object (object *op) 1299process_object (object *op)
1368{ 1300{
1369 if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 1301 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))
1370 return 0; 1302 return;
1371 1303
1372 if (INVOKE_OBJECT (TICK, op)) 1304 if (expect_false (INVOKE_OBJECT (TICK, op)))
1373 return 0; 1305 return;
1374 1306
1375 if (QUERY_FLAG (op, FLAG_MONSTER)) 1307 if (QUERY_FLAG (op, FLAG_MONSTER))
1376 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1308 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED))
1377 return 1; 1309 return;
1378 1310
1379 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1311 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0)
1380 { 1312 {
1381 if (op->type == PLAYER)
1382 animate_object (op, op->facing);
1383 else
1384 animate_object (op, op->direction); 1313 animate_object (op, op->contr ? op->facing : op->direction);
1385 1314
1386 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1315 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1387 make_sure_seen (op); 1316 make_sure_seen (op);
1388 } 1317 }
1389 1318
1319 if (expect_false (
1320 op->flag [FLAG_GENERATOR]
1321 || op->flag [FLAG_CHANGING]
1322 || op->flag [FLAG_IS_USED_UP]
1323 ))
1324 {
1390 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1325 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
1391 { 1326 {
1392 change_object (op); 1327 change_object (op);
1393 return 1; 1328 return;
1394 } 1329 }
1395 1330
1396 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1331 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY))
1397 generate_monster (op); 1332 generate_monster (op);
1398 1333
1399 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1334 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0)
1400 { 1335 {
1401 if (QUERY_FLAG (op, FLAG_APPLIED)) 1336 if (QUERY_FLAG (op, FLAG_APPLIED))
1402 remove_force (op); 1337 remove_force (op);
1403 else 1338 else
1404 { 1339 {
1405 /* IF necessary, delete the item from the players inventory */ 1340 op->remove (); // TODO: really necessary?
1406 object *pl = op->in_player ();
1407 1341
1408 if (pl)
1409 esrv_del_item (pl->contr, op->count);
1410
1411 op->remove ();
1412
1413 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1342 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1414 make_sure_not_seen (op); 1343 make_sure_not_seen (op);
1415 1344
1416 op->destroy (); 1345 op->drop_and_destroy ();
1417 } 1346 }
1418 1347
1419 return 1; 1348 return;
1349 }
1420 } 1350 }
1421 1351
1422 switch (op->type) 1352 switch (op->type)
1423 { 1353 {
1424 case SPELL_EFFECT: 1354 case SPELL_EFFECT:
1425 move_spell_effect (op); 1355 move_spell_effect (op);
1426 return 1; 1356 break;
1427 1357
1428 case ROD: 1358 case ROD:
1429 case HORN: 1359 case HORN:
1430 regenerate_rod (op); 1360 regenerate_rod (op);
1431 return 1; 1361 break;
1432 1362
1433 case FORCE: 1363 case FORCE:
1434 case POTION_EFFECT: 1364 case POTION_EFFECT:
1435 remove_force (op); 1365 remove_force (op);
1436 return 1; 1366 break;
1437 1367
1438 case BLINDNESS: 1368 case BLINDNESS:
1439 remove_blindness (op); 1369 remove_blindness (op);
1440 return 0; 1370 break;
1441 1371
1442 case POISONING: 1372 case POISONING:
1443 poison_more (op); 1373 poison_more (op);
1444 return 0; 1374 break;
1445 1375
1446 case DISEASE: 1376 case DISEASE:
1447 move_disease (op); 1377 move_disease (op);
1448 return 0; 1378 break;
1449 1379
1450 case SYMPTOM: 1380 case SYMPTOM:
1451 move_symptom (op); 1381 move_symptom (op);
1452 return 0; 1382 break;
1453 1383
1454 case THROWN_OBJ: 1384 case THROWN_OBJ:
1455 case ARROW: 1385 case ARROW:
1456 move_arrow (op); 1386 move_arrow (op);
1457 return 0; 1387 break;
1458 1388
1459 case DOOR: 1389 case DOOR:
1460 remove_door (op); 1390 remove_door (op);
1461 return 0; 1391 break;
1462 1392
1463 case LOCKED_DOOR: 1393 case LOCKED_DOOR:
1464 remove_door2 (op); 1394 remove_door2 (op);
1465 return 0; 1395 break;
1466 1396
1467 case TELEPORTER: 1397 case TELEPORTER:
1468 move_teleporter (op); 1398 move_teleporter (op);
1469 return 0; 1399 break;
1470 1400
1471 case GOLEM: 1401 case GOLEM:
1472 move_golem (op); 1402 move_golem (op);
1473 return 0; 1403 break;
1474 1404
1475 case EARTHWALL: 1405 case EARTHWALL:
1476 hit_player (op, 2, op, AT_PHYSICAL, 1); 1406 hit_player (op, 2, op, AT_PHYSICAL, 1);
1477 return 0; 1407 break;
1478 1408
1479 case FIREWALL: 1409 case FIREWALL:
1480 move_firewall (op); 1410 move_firewall (op);
1481 if (op->stats.maxsp) 1411 if (op->stats.maxsp)
1482 animate_turning (op); 1412 animate_turning (op);
1483 return 0; 1413 break;
1484 1414
1485 case MOOD_FLOOR: 1415 case MOOD_FLOOR:
1486 do_mood_floor (op); 1416 do_mood_floor (op);
1487 return 0; 1417 break;
1488 1418
1489 case GATE: 1419 case GATE:
1490 move_gate (op); 1420 move_gate (op);
1491 return 0; 1421 break;
1492 1422
1493 case TIMED_GATE: 1423 case TIMED_GATE:
1494 move_timed_gate (op); 1424 move_timed_gate (op);
1495 return 0; 1425 break;
1496 1426
1497 case TRIGGER: 1427 case TRIGGER:
1498 case TRIGGER_BUTTON: 1428 case TRIGGER_BUTTON:
1499 case TRIGGER_PEDESTAL: 1429 case TRIGGER_PEDESTAL:
1500 case TRIGGER_ALTAR: 1430 case TRIGGER_ALTAR:
1501 animate_trigger (op); 1431 animate_trigger (op);
1502 return 0; 1432 break;
1503 1433
1504 case DETECTOR: 1434 case DETECTOR:
1505 move_detector (op); 1435 move_detector (op);
1506 1436
1507 case DIRECTOR: 1437 case DIRECTOR:
1508 if (op->stats.maxsp) 1438 if (op->stats.maxsp)
1509 animate_turning (op); 1439 animate_turning (op);
1510 return 0; 1440 break;
1511 1441
1512 case HOLE: 1442 case HOLE:
1513 move_hole (op); 1443 move_hole (op);
1514 return 0; 1444 break;
1515 1445
1516 case DEEP_SWAMP: 1446 case DEEP_SWAMP:
1517 move_deep_swamp (op); 1447 move_deep_swamp (op);
1518 return 0; 1448 break;
1519 1449
1520 case RUNE: 1450 case RUNE:
1521 case TRAP: 1451 case TRAP:
1522 move_rune (op); 1452 move_rune (op);
1523 return 0; 1453 break;
1524 1454
1525 case PLAYERMOVER: 1455 case PLAYERMOVER:
1526 move_player_mover (op); 1456 move_player_mover (op);
1527 return 0; 1457 break;
1528 1458
1529 case CREATOR: 1459 case CREATOR:
1530 move_creator (op); 1460 move_creator (op);
1531 return 0; 1461 break;
1532 1462
1533 case MARKER: 1463 case MARKER:
1534 move_marker (op); 1464 move_marker (op);
1535 return 0; 1465 break;
1536 1466
1537 case PLAYER_CHANGER: 1467 case PLAYER_CHANGER:
1538 move_player_changer (op); 1468 move_player_changer (op);
1539 return 0; 1469 break;
1540 1470
1541 case PEACEMAKER: 1471 case PEACEMAKER:
1542 move_peacemaker (op); 1472 move_peacemaker (op);
1543 return 0; 1473 break;
1544 }
1545 1474
1546 return 0; 1475 case PLAYER:
1476 // players have their own speed-management, so undo the --speed_left
1477 ++op->speed_left;
1478 break;
1479
1480 case MAPSCRIPT:
1481 move_mapscript (op);
1482 break;
1483
1484 case LAMP:
1485 case TORCH:
1486 move_lamp (op);
1487 break;
1488 }
1547} 1489}
1490

Diff Legend

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