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.61 by root, Thu Jul 12 19:42:14 2007 UTC vs.
Revision 1.107 by root, Sun Apr 11 18:50:04 2010 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 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;
110 int dir;
101 111
102 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 112 if (gen->flag [FLAG_CONTENT_ON_GEN])
103 { 113 {
104 // either copy one item from the inventory... 114 // either copy one item from the inventory...
105 if (!gen->inv) 115 if (!gen->inv)
106 return; 116 return;
107 117
… …
109 int index = 0; 119 int index = 0;
110 for (object *tmp = gen->inv; tmp; tmp = tmp->below) 120 for (object *tmp = gen->inv; tmp; tmp = tmp->below)
111 if (!rndm (++index)) 121 if (!rndm (++index))
112 op = tmp; 122 op = tmp;
113 123
114 op = object_create_clone (op); 124 dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
125 if (dir < 0)
126 return;
115 127
116 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 128 op = op->deep_clone ();
129
130 op->clr_flag (FLAG_IS_A_TEMPLATE);
117 unflag_inv (op, FLAG_IS_A_TEMPLATE); 131 unflag_inv (op, FLAG_IS_A_TEMPLATE);
118 } 132 }
119 else if (gen->other_arch) 133 else if (gen->other_arch)
120 { 134 {
121 // ...or use other_arch 135 // ...or use other_arch
122 op = arch_to_object (gen->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;
139
140 op = gen->other_arch->instance ();
123 } 141 }
124 else 142 else
125 return; 143 return;
126 144
127 op->expand_tail (); 145 op->expand_tail ();
128 146
129 int i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9); 147 mapxy pos (gen); pos.move (dir);
130 if (i >= 0) 148
149 if (pos.insert (op, gen))
131 { 150 {
132 if (insert_ob_in_map_at (op, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]))
133 {
134 if (rndm (0, 9)) 151 if (rndm (0, 9))
135 generate_artifact (op, gen->map->difficulty); 152 generate_artifact (op, gen->map->difficulty);
136 153
137 if (op->has_random_items ()) 154 if (op->has_random_items ())
138 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty); 155 create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);
139 156
140 return; 157 return;
141 }
142 } 158 }
143 159
144 op->destroy (); 160 op->destroy ();
145} 161}
146 162
147void 163static void
148remove_force (object *op) 164remove_force (object *op)
149{ 165{
150 if (--op->duration > 0) 166 if (--op->duration > 0)
151 return; 167 return;
152 168
153 if (op->env) 169 if (op->env)
154 switch (op->subtype) 170 switch (op->subtype)
155 { 171 {
156 case FORCE_CONFUSION: 172 case FORCE_CONFUSION:
157 CLEAR_FLAG (op->env, FLAG_CONFUSED); 173 op->env->clr_flag (FLAG_CONFUSED);
158 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");
159 175
160 default: 176 default:
161 CLEAR_FLAG (op, FLAG_APPLIED); 177 op->clr_flag (FLAG_APPLIED);
162 change_abil (op->env, op); 178 change_abil (op->env, op);
163 op->env->update_stats (); 179 op->env->update_stats ();
164 } 180 }
165 181
166 op->destroy (); 182 op->destroy ();
167} 183}
168 184
169void 185static void
170remove_blindness (object *op) 186remove_blindness (object *op)
171{ 187{
172 if (--op->stats.food > 0) 188 if (--op->stats.food > 0)
173 return; 189 return;
174 190
175 CLEAR_FLAG (op, FLAG_APPLIED); 191 op->clr_flag (FLAG_APPLIED);
176 192
177 if (op->env) 193 if (op->env)
178 { 194 {
179 change_abil (op->env, op); 195 change_abil (op->env, op);
180 op->env->update_stats (); 196 op->env->update_stats ();
181 } 197 }
182 198
183 op->destroy (); 199 op->destroy ();
184} 200}
185 201
186void 202static void
187poison_more (object *op) 203poison_more (object *op)
188{ 204{
189 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)
190 { 206 {
191 op->destroy (); 207 op->destroy ();
192 return; 208 return;
193 } 209 }
194 210
… …
197 /* 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
198 * will not do anything. 214 * will not do anything.
199 */ 215 */
200 if (op->env->type == PLAYER) 216 if (op->env->type == PLAYER)
201 { 217 {
202 CLEAR_FLAG (op, FLAG_APPLIED); 218 op->clr_flag (FLAG_APPLIED);
203 op->env->update_stats (); 219 op->env->update_stats ();
204 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.");
205 } 221 }
206 222
207 op->destroy (); 223 op->destroy ();
… …
216 232
217 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 233 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
218} 234}
219 235
220 236
221void 237static void
222move_gate (object *op) 238move_gate (object *op)
223{ /* 1 = going down, 0 = going up */ 239{ /* 1 = going down, 0 = going up */
224 object *tmp; 240 object *tmp;
225 241
226 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))
… …
233 if (op->value) 249 if (op->value)
234 { 250 {
235 if (--op->stats.wc <= 0) 251 if (--op->stats.wc <= 0)
236 { /* Reached bottom, let's stop */ 252 { /* Reached bottom, let's stop */
237 op->stats.wc = 0; 253 op->stats.wc = 0;
238 if (op->arch->speed) 254 if (op->arch->has_active_speed ())
239 op->value = 0; 255 op->value = 0;
240 else 256 else
241 op->set_speed (0); 257 op->set_speed (0);
242 } 258 }
243 259
244 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 260 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
245 { 261 {
246 op->move_block = 0; 262 op->move_block = 0;
247 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 263 op->clr_flag (FLAG_BLOCKSVIEW);
248 update_all_los (op->map, op->x, op->y); 264 update_all_los (op->map, op->x, op->y);
249 } 265 }
250 266
251 SET_ANIMATION (op, op->stats.wc); 267 SET_ANIMATION (op, op->stats.wc);
252 update_object (op, UP_OBJ_CHANGE); 268 update_object (op, UP_OBJ_CHANGE);
… …
263 * 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,
264 * otherwise, we fall through to the code below which should lower 280 * otherwise, we fall through to the code below which should lower
265 * the gate slightly. 281 * the gate slightly.
266 */ 282 */
267 283
268 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 284 for (tmp = op->above; tmp; tmp = tmp->above)
269 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 285 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
270 break; 286 break;
271 287
272 if (tmp == NULL) 288 if (!tmp)
273 { 289 {
274 if (op->arch->speed) 290 if (op->arch->has_active_speed ())
275 op->value = 1; 291 op->value = 1;
276 else 292 else
277 op->set_speed (0); 293 op->set_speed (0);
278 294
279 return; 295 return;
… …
290 } 306 }
291 else 307 else
292 { /* The gate is still going up */ 308 { /* The gate is still going up */
293 op->stats.wc++; 309 op->stats.wc++;
294 310
295 if ((int) op->stats.wc >= (NUM_ANIMATIONS (op))) 311 if (op->stats.wc >= NUM_ANIMATIONS (op))
296 op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1; 312 op->stats.wc = NUM_ANIMATIONS (op) - 1;
297 313
298 /* 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.
299 * 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
300 */ 316 */
301 if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2) 317 if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
302 { 318 {
303 /* Halfway or further, check blocks */ 319 /* Halfway or further, check blocks */
304 /* First, get the top object on the square. */ 320 /* First, get the top object on the square. */
305 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 321 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
306 ; 322 ;
307 323
308 if (tmp) 324 if (tmp)
309 { 325 {
310 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 326 if (tmp->flag [FLAG_ALIVE])
311 { 327 {
312 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 328 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
329 op->play_sound (sound_find ("blocked_gate"));
313 330
314 if (tmp->type == PLAYER) 331 if (tmp->type == PLAYER)
315 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);
316 } 333 }
317 else
318 /* If the object is not alive, and the object either can 334 /* If the object is not alive, and the object either can
319 * be picked up or the object rolls, move the object 335 * be picked up or the object rolls, move the object
320 * off the gate. 336 * off the gate.
321 */ 337 */
322 if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL))) 338 else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
323 { 339 {
324 /* If it has speed, it should move itself, otherwise: */ 340 /* If it has speed, it should move itself, otherwise: */
325 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);
326 342
327 /* If there is a free spot, move the object someplace */ 343 /* If there is a free spot, move the object someplace */
328 if (i != -1) 344 if (i > 0)
329 { 345 {
346 mapxy pos (tmp);
347 pos.move (i);
348 if (pos.normalise ())
330 tmp->remove (); 349 tmp->move_to (pos);
331 tmp->x += freearr_x[i], tmp->y += freearr_y[i];
332 insert_ob_in_map (tmp, op->map, op, 0);
333 } 350 }
334 } 351 }
335 } 352 }
336 353
337 /* See if there is still anything blocking the gate */ 354 /* See if there is still anything blocking the gate */
338 for (tmp = op->above; tmp != NULL; tmp = tmp->above) 355 for (tmp = op->above; tmp; tmp = tmp->above)
339 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 356 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
340 break; 357 break;
341 358
342 /* IF there is, start putting the gate down */ 359 /* IF there is, start putting the gate down */
343 if (tmp) 360 if (tmp)
344 {
345 op->stats.food = 1; 361 op->stats.food = 1;
346 }
347 else 362 else
348 { 363 {
349 op->move_block = MOVE_ALL; 364 op->move_block = MOVE_ALL;
365
350 if (!op->arch->stats.ac) 366 if (!op->arch->stats.ac)
351 SET_FLAG (op, FLAG_BLOCKSVIEW); 367 op->set_flag (FLAG_BLOCKSVIEW);
352 update_all_los (op->map, op->x, op->y); 368 update_all_los (op->map, op->x, op->y);
353 } 369 }
354 } /* gate is halfway up */ 370 } /* gate is halfway up */
355 371
356 SET_ANIMATION (op, op->stats.wc); 372 SET_ANIMATION (op, op->stats.wc);
… …
360 376
361/* hp : how long door is open/closed 377/* hp : how long door is open/closed
362 * maxhp : initial value for hp 378 * maxhp : initial value for hp
363 * sp : 1 = open, 0 = close 379 * sp : 1 = open, 0 = close
364 */ 380 */
365void 381static void
366move_timed_gate (object *op) 382move_timed_gate (object *op)
367{ 383{
368 int v = op->value; 384 int v = op->value;
369 385
370 if (op->stats.sp) 386 if (op->stats.sp)
371 { 387 {
372 move_gate (op); 388 move_gate (op);
389
373 if (op->value != v) /* change direction ? */ 390 if (op->value != v) /* change direction ? */
374 op->stats.sp = 0; 391 op->stats.sp = 0;
375 return; 392 return;
376 } 393 }
394
377 if (--op->stats.hp <= 0) 395 if (--op->stats.hp <= 0)
378 { /* keep gate down */ 396 { /* keep gate down */
379 move_gate (op); 397 move_gate (op);
398
380 if (op->value != v) 399 if (op->value != v)
381 op->set_speed (0); 400 op->set_speed (0);
382 } 401 }
383} 402}
384 403
… …
386 * speed: frequency of 'glances' 405 * speed: frequency of 'glances'
387 * connected: connected value of detector 406 * connected: connected value of detector
388 * sp: 1 if detection sets buttons 407 * sp: 1 if detection sets buttons
389 * -1 if detection unsets buttons 408 * -1 if detection unsets buttons
390 */ 409 */
391 410static void
392void
393move_detector (object *op) 411move_detector (object *op)
394{ 412{
395 object *tmp; 413 object *tmp;
396 int last = op->value; 414 int last = op->value;
397 int detected; 415 int detected;
398 416
399 detected = 0; 417 detected = 0;
400 418
401 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)
402 { 420 {
403 object *tmp2; 421 object *tmp2;
404 422
405 if (op->stats.hp) 423 if (op->stats.hp)
406 { 424 {
… …
424 if (op->stats.sp == 1) 442 if (op->stats.sp == 1)
425 { 443 {
426 if (detected && last == 0) 444 if (detected && last == 0)
427 { 445 {
428 op->value = 1; 446 op->value = 1;
429 push_button (op); 447 push_button (op, tmp);
430 } 448 }
449
431 if (!detected && last == 1) 450 if (!detected && last == 1)
432 { 451 {
433 op->value = 0; 452 op->value = 0;
434 push_button (op); 453 push_button (op, tmp);
435 } 454 }
436 } 455 }
437 else 456 else
438 { /* in this case, we unset buttons */ 457 { /* in this case, we unset buttons */
439 if (detected && last == 1) 458 if (detected && last == 1)
440 { 459 {
441 op->value = 0; 460 op->value = 0;
442 push_button (op); 461 push_button (op, tmp);
443 } 462 }
463
444 if (!detected && last == 0) 464 if (!detected && last == 0)
445 { 465 {
446 op->value = 1; 466 op->value = 1;
447 push_button (op); 467 push_button (op, tmp);
448 } 468 }
449 } 469 }
450} 470}
451
452 471
453void 472void
454animate_trigger (object *op) 473animate_trigger (object *op)
455{ 474{
456 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 475 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
… …
463 SET_ANIMATION (op, op->stats.wc); 482 SET_ANIMATION (op, op->stats.wc);
464 update_object (op, UP_OBJ_FACE); 483 update_object (op, UP_OBJ_FACE);
465 } 484 }
466} 485}
467 486
468void 487static void
469move_hole (object *op) 488move_hole (object *op)
470{ /* 1 = opening, 0 = closing */ 489{ /* 1 = opening, 0 = closing */
471 object *next, *tmp;
472
473 if (op->value) 490 if (op->value)
474 { /* We're opening */ 491 { /* We're opening */
475 if (--op->stats.wc <= 0) 492 if (--op->stats.wc <= 0)
476 { /* Opened, let's stop */ 493 { /* Opened, let's stop */
477 op->stats.wc = 0; 494 op->stats.wc = 0;
478 op->set_speed (0); 495 op->set_speed (0);
479 496
480 /* Hard coding this makes sense for holes I suppose */ 497 /* Hard coding this makes sense for holes I suppose */
481 op->move_on = MOVE_WALK; 498 op->move_on = MOVE_WALK;
482 for (tmp = op->above; tmp != NULL; tmp = next) 499 for (object *next, *tmp = op->above; tmp; tmp = next)
483 { 500 {
484 next = tmp->above; 501 next = tmp->above;
485 move_apply (op, tmp, tmp); 502 move_apply (op, tmp, tmp);
486 } 503 }
487 } 504 }
488 505
489 SET_ANIMATION (op, op->stats.wc); 506 SET_ANIMATION (op, op->stats.wc);
490 update_object (op, UP_OBJ_FACE); 507 update_object (op, UP_OBJ_FACE);
491 return; 508 return;
492 } 509 }
510
493 /* We're closing */ 511 /* We're closing */
494 op->move_on = 0; 512 op->move_on = 0;
495 513
496 op->stats.wc++; 514 op->stats.wc++;
497 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 515 if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
… …
528 { 546 {
529 object *payload = op->inv; 547 object *payload = op->inv;
530 548
531 if (payload == NULL) 549 if (payload == NULL)
532 return NULL; 550 return NULL;
551
533 payload->remove (); 552 payload->remove ();
534 op->destroy (); 553 op->destroy ();
535 return payload; 554 return payload;
536 } 555 }
537 556
… …
554fix_stopped_item (object *op, maptile *map, object *originator) 573fix_stopped_item (object *op, maptile *map, object *originator)
555{ 574{
556 if (map == NULL) 575 if (map == NULL)
557 return; 576 return;
558 577
559 if (QUERY_FLAG (op, FLAG_REMOVED)) 578 if (op->flag [FLAG_REMOVED])
560 insert_ob_in_map (op, map, originator, 0); 579 insert_ob_in_map (op, map, originator, 0);
561 else if (op->type == ARROW) 580 else if (op->type == ARROW)
562 merge_ob (op, NULL); /* only some arrows actually need this */ 581 merge_ob (op, NULL); /* only some arrows actually need this */
563} 582}
564 583
… …
580 599
581 // restore original wc, dam, attacktype and slaying 600 // restore original wc, dam, attacktype and slaying
582 op->stats.wc = op->stats.sp; 601 op->stats.wc = op->stats.sp;
583 op->stats.dam = op->stats.hp; 602 op->stats.dam = op->stats.hp;
584 op->attacktype = op->stats.grace; 603 op->attacktype = op->stats.grace;
604 op->slaying = op->custom_name;
585 605
586 if (op->spellarg)
587 {
588 op->slaying = op->spellarg;
589 free (op->spellarg);
590 op->spellarg = 0;
591 }
592 else
593 op->slaying = 0;
594
595 /* 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 */
596 op->spellarg = NULL; 607 op->custom_name = 0;
597 op->stats.sp = 0; 608 op->stats.sp = 0;
598 op->stats.hp = 0; 609 op->stats.hp = 0;
599 op->stats.grace = 0; 610 op->stats.grace = 0;
600 op->level = 0; 611 op->level = 0;
601 op->face = op->arch->face; 612 op->face = op->arch->face;
602 op->owner = NULL; /* So that stopped arrows will be saved */ 613 op->owner = 0;
614
603 update_object (op, UP_OBJ_CHANGE); 615 update_object (op, UP_OBJ_CHANGE);
616
604 return op; 617 return op;
605} 618}
606 619
607/* stop_arrow() - what to do when a non-living flying object 620/* stop_arrow() - what to do when a non-living flying object
608 * 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
… …
617 if (INVOKE_OBJECT (STOP, op)) 630 if (INVOKE_OBJECT (STOP, op))
618 return; 631 return;
619 632
620 if (op->inv) 633 if (op->inv)
621 { 634 {
635 // replace this by straightforward drop to ground?
622 object *payload = op->inv; 636 object *payload = op->inv;
623 637
624 payload->remove ();
625 payload->owner = 0; 638 payload->owner = 0;
626 insert_ob_in_map (payload, op->map, payload, 0); 639 insert_ob_in_map (payload, op->map, payload, 0);
627 op->destroy (); 640 op->destroy ();
628 } 641 }
629 else 642 else
… …
633 if (op) 646 if (op)
634 merge_ob (op, 0); 647 merge_ob (op, 0);
635 } 648 }
636} 649}
637 650
638/* Move an arrow along its course. op is the arrow or thrown object. 651/* Move an arrow or throwen_obj along its course. op is the arrow or thrown object.
639 */ 652 */
640void 653void
641move_arrow (object *op) 654move_arrow (object *op)
642{ 655{
643 object *tmp;
644 sint16 new_x, new_y;
645 int was_reflected, mflags; 656 int was_reflected;
646 maptile *m;
647 657
648 if (op->map == NULL) 658 if (!op->map)
649 { 659 {
650 LOG (llevError, "BUG: Arrow had no map.\n"); 660 LOG (llevError, "BUG: Arrow had no map.\n");
651 op->destroy (); 661 op->destroy ();
652 return; 662 return;
653 } 663 }
… …
661 * 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,
662 * 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
663 * 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,
664 * and it is easy enough to clean it up here. 674 * and it is easy enough to clean it up here.
665 */ 675 */
666 if (op->inv == NULL) 676 if (!op->inv)
667 { 677 {
668 op->destroy (); 678 op->destroy ();
669 return; 679 return;
670 } 680 }
671 681
… …
674 stop_arrow (op); 684 stop_arrow (op);
675 return; 685 return;
676 } 686 }
677 } 687 }
678 688
689 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
690 * about 17 squares. Tune as needed.
691 */
692 op->speed -= 0.05;
693
679 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower 694 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower
680 values look rediculous. */ 695 values look rediculous. */
681 if (op->speed < 0.5 && op->type == ARROW) 696 if (op->speed < (op->type == ARROW ? 0.05 : MIN_ACTIVE_SPEED))
682 { 697 {
683 stop_arrow (op); 698 stop_arrow (op);
684 return; 699 return;
685 } 700 }
686 701
687 /* Calculate target map square */ 702 /* Calculate target map square */
688 new_x = op->x + DIRX (op);
689 new_y = op->y + DIRY (op);
690 was_reflected = 0; 703 was_reflected = 0;
691 704
692 m = op->map; 705 mapxy pos (op); pos.move (op->direction);
693 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
694 706
695 if (mflags & P_OUT_OF_MAP) 707 if (!pos.normalise ())
696 { 708 {
697 stop_arrow (op); 709 stop_arrow (op);
698 return; 710 return;
699 } 711 }
700 712
701 /* only need to look for living creatures if this flag is set */ 713 /* only need to look for living creatures if this flag is set */
702 if (mflags & P_IS_ALIVE) 714 if (pos->flags () & P_IS_ALIVE)
703 { 715 {
704 for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above) 716 object *tmp;
705 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 717
718 for (tmp = pos->bot; tmp; tmp = tmp->above)
719 if (tmp->flag [FLAG_ALIVE])
706 break; 720 break;
707 721
708 /* Not really fair, but don't let monsters hit themselves with 722 /* Not really fair, but don't let monsters hit themselves with
709 * their own arrow - this can be because they fire it then 723 * their own arrow - this can be because they fire it then
710 * move into it. 724 * move into it.
… …
713 { 727 {
714 /* Found living object, but it is reflecting the missile. Update 728 /* Found living object, but it is reflecting the missile. Update
715 * as below. (Note that for living creatures there is a small 729 * as below. (Note that for living creatures there is a small
716 * chance that reflect_missile fails.) 730 * chance that reflect_missile fails.)
717 */ 731 */
718 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 732 if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
719 { 733 {
720 int number = op->face; 734 int number = op->face;
721 735
722 op->direction = absdir (op->direction + 4); 736 op->direction = absdir (op->direction + 4);
723 update_turn_face (op); 737 update_turn_face (op);
… …
732 return; 746 return;
733 } 747 }
734 } /* if this is not hitting its owner */ 748 } /* if this is not hitting its owner */
735 } /* if there is something alive on this space */ 749 } /* if there is something alive on this space */
736 750
737 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 751 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
738 { 752 {
739 int retry = 0; 753 int retry = 0;
740 754
741 /* if the object doesn't reflect, stop the arrow from moving 755 /* if the object doesn't reflect, stop the arrow from moving
742 * note that this code will now catch cases where a monster is 756 * note that this code will now catch cases where a monster is
743 * on a wall but has reflecting - the arrow won't reflect. 757 * on a wall but has reflecting - the arrow won't reflect.
744 * Mapmakers shouldn't put monsters on top of wall in the first 758 * Mapmakers shouldn't put monsters on top of wall in the first
745 * place, so I don't consider that a problem. 759 * place, so I don't consider that a problem.
746 */ 760 */
747 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 761 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
748 { 762 {
749 stop_arrow (op); 763 stop_arrow (op);
750 return; 764 return;
751 } 765 }
752 else 766 else
… …
755 if (op->direction & 1) 769 if (op->direction & 1)
756 { 770 {
757 op->direction = absdir (op->direction + 4); 771 op->direction = absdir (op->direction + 4);
758 retry = 1; 772 retry = 1;
759 } 773 }
774
760 /* There were two blocks with identical code - 775 /* There were two blocks with identical code -
761 * use this retry here to make this one block 776 * use this retry here to make this one block
762 * that did the same thing. 777 * that did the same thing.
763 */ 778 */
764 while (retry < 2) 779 while (retry < 2)
765 { 780 {
766 int left, right, mflags;
767 maptile *m1;
768 sint16 x1, y1;
769
770 retry++; 781 retry++;
771 782
772 /* Need to check for P_OUT_OF_MAP: if the arrow is tavelling 783 /* Need to check for P_OUT_OF_MAP: if the arrow is travelling
773 * over a corner in a tiled map, it is possible that 784 * over a corner in a tiled map, it is possible that
774 * op->direction is within an adjacent map but either 785 * op->direction is within an adjacent map but either
775 * op->direction-1 or op->direction+1 does not exist. 786 * op->direction-1 or op->direction+1 does not exist.
776 */ 787 */
777 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)], 788 mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
778 op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1); 789 bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
779 left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
780 790
781 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)], 791 mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
782 op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1); 792 bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
783 right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
784 793
785 if (left == right) 794 if (left == right)
786 op->direction = absdir (op->direction + 4); 795 op->direction = absdir (op->direction + 4);
787 else if (left) 796 else if (left)
788 op->direction = absdir (op->direction + 2); 797 op->direction = absdir (op->direction + 2);
789 else if (right) 798 else if (right)
790 op->direction = absdir (op->direction - 2); 799 op->direction = absdir (op->direction - 2);
791 800
792 mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
793
794 /* If this space is not out of the map and not blocked, valid space - 801 /* If this space is not out of the map and not blocked, valid space -
795 * don't need to retry again. 802 * don't need to retry again.
796 */ 803 */
797 if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1))) 804 mapxy pos3 (pos); pos3.move (op->direction);
805 if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
798 break; 806 break;
799
800 } 807 }
808
801 /* Couldn't find a direction to move the arrow to - just 809 /* Couldn't find a direction to move the arrow to - just
802 * top it from moving. 810 * stop it from moving.
803 */ 811 */
804 if (retry == 2) 812 if (retry == 2)
805 { 813 {
806 stop_arrow (op); 814 stop_arrow (op);
807 return; 815 return;
808 } 816 }
817
809 /* update object image for new facing */ 818 /* update object image for new facing */
810 /* many thrown objects *don't* have more than one face */ 819 /* many thrown objects *don't* have more than one face */
811 if (GET_ANIM_ID (op)) 820 if (op->has_anim ())
812 SET_ANIMATION (op, op->direction); 821 op->set_anim_frame (op->direction);
813 } /* object is reflected */ 822 } /* object is reflected */
814 } /* object ran into a wall */ 823 } /* object ran into a wall */
815 824
816 /* Move the arrow. */ 825 /* Move the arrow. */
817 op->remove (); 826 op->move_to (pos);
818 op->x = new_x;
819 op->y = new_y;
820
821 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
822 * about 17 squares. Tune as needed.
823 */
824 op->speed -= 0.05;
825 insert_ob_in_map (op, m, op, 0);
826} 827}
827 828
828/* This routine doesnt seem to work for "inanimate" objects that 829static void
829 * are being carried, ie a held torch leaps from your hands!.
830 * Modified this routine to allow held objects. b.t. */
831
832void
833change_object (object *op) 830change_object (object *op)
834{ /* Doesn`t handle linked objs yet */ 831{ /* Doesn`t handle linked objs yet */
835 int i, j;
836
837 if (op->other_arch == NULL) 832 if (!op->other_arch)
838 { 833 {
839 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 ());
840 return; 835 return;
841 } 836 }
842 837
843 /* In non-living items only change when food value is 0 */ 838 /* In non-living items only change when food value is 0 */
844 if (!QUERY_FLAG (op, FLAG_ALIVE)) 839 if (!op->flag [FLAG_ALIVE])
845 { 840 {
846 if (op->stats.food-- > 0) 841 if (op->stats.food-- > 0)
847 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);
848 else 858 else
849 op->stats.food = 1; /* so 1 other_arch is made */
850 }
851
852 object *pl = op->in_player ();
853 object *env = op->env;
854
855 op->remove ();
856 for (i = 0; i < NROFNEWOBJS (op); i++)
857 {
858 object *tmp = arch_to_object (op->other_arch);
859
860 if (op->type == LAMP)
861 tmp->stats.food = op->stats.food - 1;
862
863 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
864 if (env)
865 {
866 tmp->x = env->x, tmp->y = env->y;
867 tmp = insert_ob_in_ob (tmp, env);
868
869 /* If this object is the players inventory, we need to tell the
870 * client of the change. Insert_ob_in_map takes care of the
871 * updating the client, so we don't need to do that below.
872 */
873 if (pl)
874 {
875 esrv_del_item (pl->contr, op->count);
876 esrv_send_item (pl, tmp);
877 }
878 } 859 {
879 else
880 {
881 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
882 if (j == -1) /* No free spot */ 862 if (j < 0) /* No free spot */
883 tmp->destroy (); 863 tmp->destroy ();
884 else 864 else
885 { 865 {
886 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j]; 866 mapxy pos (op); pos.move (j);
887 insert_ob_in_map (tmp, op->map, op, 0); 867
868 if (pos.normalise ())
869 pos.insert (tmp, op);
888 } 870 }
889 } 871 }
890 } 872 }
891 873
892 op->destroy (); 874 op->destroy ();
… …
909 891
910 if (op->head) 892 if (op->head)
911 head = op->head; 893 head = op->head;
912 894
913 for (tmp = op->above; tmp; tmp = tmp->above) 895 for (tmp = op->above; tmp; tmp = tmp->above)
914 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 896 if (!tmp->flag [FLAG_IS_FLOOR])
915 break; 897 break;
916 898
917 /* If nothing above us to move, nothing to do */ 899 /* If nothing above us to move, nothing to do */
918 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 900 if (!tmp || tmp->flag [FLAG_WIZPASS])
919 return; 901 return;
920 902
921 if (EXIT_PATH (head)) 903 if (EXIT_PATH (head))
922 { 904 {
923 if (tmp->type == PLAYER) 905 if (tmp->type == PLAYER)
… …
948 else 930 else
949 { 931 {
950 /* Random teleporter */ 932 /* Random teleporter */
951 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 933 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
952 return; 934 return;
935
953 teleport (head, TELEPORTER, tmp); 936 teleport (head, TELEPORTER, tmp);
954 } 937 }
955} 938}
956 939
957/* This object will teleport someone to a different map 940/* This object will teleport someone to a different map
958 and will also apply changes to the player from its inventory. 941 and will also apply changes to the player from its inventory.
959 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
960 can't be generalized. 943 can't be generalized.
961*/ 944*/
962void 945static void
963move_player_changer (object *op) 946move_player_changer (object *op)
964{ 947{
965 object *player;
966 object *walk;
967
968 if (!op->above || !EXIT_PATH (op)) 948 if (!op->above || !EXIT_PATH (op))
969 return; 949 return;
970 950
971 /* This isn't all that great - means that the player_mover 951 /* This isn't all that great - means that the player_mover
972 * needs to be on top. 952 * needs to be on top.
973 */ 953 */
974 if (op->above->type == PLAYER) 954 if (op->above->type == PLAYER)
975 { 955 {
956 object *player = op->above;
957
976 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 958 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
977 return; 959 return;
978 960
979 player = op->above;
980
981 for (walk = op->inv; walk; walk = walk->below) 961 for (object *walk = op->inv; walk; walk = walk->below)
982 apply_changes_to_player (player, walk); 962 apply_changes_to_player (player, walk);
983 963
984 player->update_stats (); 964 player->update_stats ();
985 965
986 esrv_send_inventory (op->above, op->above); 966 esrv_send_inventory (op->above, op->above);
… …
1033 * 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.
1034 * 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,
1035 * 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,
1036 * it'll paralyze the victim for hp*his speed/op->speed 1016 * it'll paralyze the victim for hp*his speed/op->speed
1037 */ 1017 */
1038void 1018static void
1039move_player_mover (object *op) 1019move_player_mover (object *op)
1040{ 1020{
1041 int dir = op->stats.sp; 1021 int dir = op->stats.sp;
1042 sint16 nx, ny; 1022 sint16 nx, ny;
1043 maptile *m; 1023 maptile *m;
… …
1046 if (!dir) 1026 if (!dir)
1047 dir = rndm (1, 8); 1027 dir = rndm (1, 8);
1048 1028
1049 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1029 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1050 { 1030 {
1051 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1031 if (victim->flag [FLAG_ALIVE] && !victim->flag [FLAG_WIZPASS] &&
1052 (victim->move_type & op->move_type || !victim->move_type)) 1032 (victim->move_type & op->move_type || !victim->move_type))
1053 { 1033 {
1054 1034
1055 if (victim->head) 1035 if (victim->head)
1056 victim = victim->head; 1036 victim = victim->head;
1057 1037
1058 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0) 1038 if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
1059 { 1039 {
1060 op->remove (); 1040 op->remove ();
1061 return; 1041 return;
1062 } 1042 }
1063 1043
… …
1076 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above) 1056 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1077 { 1057 {
1078 if (nextmover->type == PLAYERMOVER) 1058 if (nextmover->type == PLAYERMOVER)
1079 nextmover->speed_left = -.99f; 1059 nextmover->speed_left = -.99f;
1080 1060
1081 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1061 if (nextmover->flag [FLAG_ALIVE])
1082 op->speed_left = -1.1f; /* 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 */
1083 } 1063 }
1084 1064
1085 if (victim->type == PLAYER) 1065 if (victim->type == PLAYER)
1086 { 1066 {
1087 /* only level >=1 movers move people */ 1067 /* only level >=1 movers move people */
1088 if (op->level) 1068 if (op->level)
1089 { 1069 {
1090 /* 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
1091 * is cleared, otherwise the player will get stuck in 1071 * is cleared, otherwise the player will get stuck in
1092 * place. This can happen if the player used a spell to 1072 * place. This can happen if the player used a spell to
1093 * get to this space. 1073 * get to this space.
1094 */ 1074 */
1095 victim->contr->fire_on = 0; 1075 victim->contr->fire_on = 0;
1096 victim->speed_left = 1.f; 1076 victim->speed_left = 1.f;
1097 move_player (victim, dir); 1077 move_player (victim, dir);
1098 } 1078 }
1099 else 1079 else
1100 return; 1080 return;
1101 } 1081 }
1102 else 1082 else
1103 move_object (victim, dir); 1083 victim->move (dir);
1104 1084
1105 if (!op->stats.maxsp && op->attacktype) 1085 if (!op->stats.maxsp && op->attacktype)
1106 op->stats.maxsp = 2; 1086 op->stats.maxsp = 2;
1107 1087
1108 if (op->attacktype) 1088 if (op->attacktype)
1109 { /* flag to paralyze the player */ 1089 { /* flag to paralyze the player */
1110 victim->speed_left = max (-5.f, -FABS (op->stats.maxsp * victim->speed / op->speed)); 1090 victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1111 } 1091 }
1112 } 1092 }
1113 } 1093 }
1114} 1094}
1115 1095
… …
1166 * 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.
1167 * 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
1168 * more concern with large objects, most notably a part being placed 1148 * more concern with large objects, most notably a part being placed
1169 * outside of the map which would cause the server to crash 1149 * outside of the map which would cause the server to crash
1170*/ 1150*/
1171
1172void 1151void
1173move_creator (object *creator) 1152move_creator (object *creator)
1174{ 1153{
1175 object *new_ob; 1154 object *new_ob;
1176 1155
1177 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1156 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1178 { 1157 {
1179 creator->stats.hp = -1; 1158 creator->stats.hp = -1;
1180 return; 1159 return;
1181 } 1160 }
1182 1161
1183 if (creator->inv != NULL) 1162 if (creator->inv)
1184 { 1163 {
1185 object *ob; 1164 object *ob;
1186 int i; 1165 int i;
1187 object *ob_to_copy; 1166 object *ob_to_copy;
1188 1167
… …
1193 if (rndm (0, i) == 0) 1172 if (rndm (0, i) == 0)
1194 { 1173 {
1195 ob_to_copy = ob; 1174 ob_to_copy = ob;
1196 } 1175 }
1197 } 1176 }
1198 new_ob = object_create_clone (ob_to_copy); 1177 new_ob = ob_to_copy->deep_clone ();
1199 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1178 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1200 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1179 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1201 } 1180 }
1202 else 1181 else
1203 { 1182 {
1204 if (creator->other_arch == NULL) 1183 if (!creator->other_arch)
1205 { 1184 {
1206 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",
1207 &creator->name, &creator->map->path, creator->x, creator->y); 1186 &creator->name, &creator->map->path, creator->x, creator->y);
1208 return; 1187 return;
1209 } 1188 }
… …
1211 new_ob = object_create_arch (creator->other_arch); 1190 new_ob = object_create_arch (creator->other_arch);
1212 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1191 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1213 } 1192 }
1214 1193
1215 /* Make sure this multipart object fits */ 1194 /* Make sure this multipart object fits */
1216 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))
1217 { 1196 {
1218 new_ob->destroy (); 1197 new_ob->destroy ();
1219 return; 1198 return;
1220 } 1199 }
1221 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 new_ob->set_flag (FLAG_IDENTIFIED);
1204
1222 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);
1223 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1206 if (new_ob->flag [FLAG_FREED])
1224 return; 1207 return;
1225 1208
1226 if (creator->slaying) 1209 if (creator->slaying)
1227 {
1228 new_ob->name = new_ob->title = creator->slaying; 1210 new_ob->name = new_ob->title = creator->slaying;
1229 }
1230} 1211}
1231 1212
1232/* move_marker --peterm@soda.csua.berkeley.edu 1213/* move_marker --peterm@soda.csua.berkeley.edu
1233 when moved, a marker will search for a player sitting above 1214 when moved, a marker will search for a player sitting above
1234 it, and insert an invisible, weightless force into him 1215 it, and insert an invisible, weightless force into him
… …
1244 { 1225 {
1245 /* remove an old force with a slaying field == op->name */ 1226 /* remove an old force with a slaying field == op->name */
1246 if (object *force = tmp->force_find (op->name)) 1227 if (object *force = tmp->force_find (op->name))
1247 force->destroy (); 1228 force->destroy ();
1248 1229
1249 if (!tmp->force_find (op->slaying)) 1230 if (op->slaying && !tmp->force_find (op->slaying))
1250 { 1231 {
1251 tmp->force_add (op->slaying, op->stats.food); 1232 tmp->force_add (op->slaying, op->stats.food);
1252 1233
1253 if (op->msg) 1234 if (op->msg)
1254 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg); 1235 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
… …
1266 } 1247 }
1267 } 1248 }
1268 } 1249 }
1269} 1250}
1270 1251
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
1271void 1298void
1272process_object (object *op) 1299process_object (object *op)
1273{ 1300{
1274 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1301 if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1275 return; 1302 return;
1276 1303
1277 if (expect_false (INVOKE_OBJECT (TICK, op))) 1304 if (expect_false (INVOKE_OBJECT (TICK, op)))
1278 return; 1305 return;
1279 1306
1280 if (QUERY_FLAG (op, FLAG_MONSTER)) 1307 if (op->flag [FLAG_MONSTER])
1281 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1308 if (move_monster (op) || op->flag [FLAG_FREED])
1282 return; 1309 return;
1283 1310
1284 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1311 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1285 { 1312 {
1286 animate_object (op, op->contr ? op->facing : op->direction); 1313 animate_object (op, op->contr ? op->facing : op->direction);
1287 1314
1288 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1315 if (op->flag [FLAG_SEE_ANYWHERE])
1289 make_sure_seen (op); 1316 make_sure_seen (op);
1290 } 1317 }
1291 1318
1292 if (expect_false ( 1319 if (expect_false (
1293 op->flag [FLAG_GENERATOR] 1320 op->flag [FLAG_GENERATOR]
1294 || op->flag [FLAG_CHANGING] 1321 || op->flag [FLAG_CHANGING]
1295 || op->flag [FLAG_IS_USED_UP] 1322 || op->flag [FLAG_IS_USED_UP]
1296 )) 1323 ))
1297 { 1324 {
1298 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1325 if (op->flag [FLAG_CHANGING] && !op->state)
1299 { 1326 {
1300 change_object (op); 1327 change_object (op);
1301 return; 1328 return;
1302 } 1329 }
1303 1330
1304 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1331 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1305 generate_monster (op); 1332 generate_monster (op);
1306 1333
1307 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1334 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1308 { 1335 {
1309 if (QUERY_FLAG (op, FLAG_APPLIED)) 1336 if (op->flag [FLAG_APPLIED])
1310 remove_force (op); 1337 remove_force (op);
1311 else 1338 else
1312 { 1339 {
1313 /* If necessary, delete the item from the players inventory */ 1340 op->remove (); // TODO: really necessary?
1314 object *pl = op->in_player ();
1315 1341
1316 if (pl)
1317 esrv_del_item (pl->contr, op->count);
1318
1319 op->remove ();
1320
1321 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1342 if (op->flag [FLAG_SEE_ANYWHERE])
1322 make_sure_not_seen (op); 1343 make_sure_not_seen (op);
1323 1344
1324 op->destroy (); 1345 op->drop_and_destroy ();
1325 } 1346 }
1326 1347
1327 return; 1348 return;
1328 } 1349 }
1329 } 1350 }
… …
1453 1474
1454 case PLAYER: 1475 case PLAYER:
1455 // players have their own speed-management, so undo the --speed_left 1476 // players have their own speed-management, so undo the --speed_left
1456 ++op->speed_left; 1477 ++op->speed_left;
1457 break; 1478 break;
1458 }
1459}
1460 1479
1480 case MAPSCRIPT:
1481 move_mapscript (op);
1482 break;
1483
1484 case LAMP:
1485 case TORCH:
1486 move_lamp (op);
1487 break;
1488 }
1489}
1490

Diff Legend

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