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.66 by root, Mon Aug 27 06:29:18 2007 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC

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

Diff Legend

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