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.63 by root, Sat Aug 4 22:23:47 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 != NULL; 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 == NULL) 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);
328 op->play_sound (sound_find ("blocked_gate"));
318 329
319 if (tmp->type == PLAYER) 330 if (tmp->type == PLAYER)
320 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name); 331 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
321 } 332 }
322 else
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 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 != NULL; 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 {
350 op->stats.food = 1; 360 op->stats.food = 1;
351 }
352 else 361 else
353 { 362 {
354 op->move_block = MOVE_ALL; 363 op->move_block = MOVE_ALL;
364
355 if (!op->arch->stats.ac) 365 if (!op->arch->stats.ac)
356 SET_FLAG (op, FLAG_BLOCKSVIEW); 366 op->set_flag (FLAG_BLOCKSVIEW);
357 update_all_los (op->map, op->x, op->y); 367 update_all_los (op->map, op->x, op->y);
358 } 368 }
359 } /* gate is halfway up */ 369 } /* gate is halfway up */
360 370
361 SET_ANIMATION (op, op->stats.wc); 371 SET_ANIMATION (op, op->stats.wc);
… …
365 375
366/* hp : how long door is open/closed 376/* hp : how long door is open/closed
367 * maxhp : initial value for hp 377 * maxhp : initial value for hp
368 * sp : 1 = open, 0 = close 378 * sp : 1 = open, 0 = close
369 */ 379 */
370void 380static void
371move_timed_gate (object *op) 381move_timed_gate (object *op)
372{ 382{
373 int v = op->value; 383 int v = op->value;
374 384
375 if (op->stats.sp) 385 if (op->stats.sp)
376 { 386 {
377 move_gate (op); 387 move_gate (op);
388
378 if (op->value != v) /* change direction ? */ 389 if (op->value != v) /* change direction ? */
379 op->stats.sp = 0; 390 op->stats.sp = 0;
380 return; 391 return;
381 } 392 }
393
382 if (--op->stats.hp <= 0) 394 if (--op->stats.hp <= 0)
383 { /* keep gate down */ 395 { /* keep gate down */
384 move_gate (op); 396 move_gate (op);
397
385 if (op->value != v) 398 if (op->value != v)
386 op->set_speed (0); 399 op->set_speed (0);
387 } 400 }
388} 401}
389 402
… …
391 * speed: frequency of 'glances' 404 * speed: frequency of 'glances'
392 * connected: connected value of detector 405 * connected: connected value of detector
393 * sp: 1 if detection sets buttons 406 * sp: 1 if detection sets buttons
394 * -1 if detection unsets buttons 407 * -1 if detection unsets buttons
395 */ 408 */
396 409static void
397void
398move_detector (object *op) 410move_detector (object *op)
399{ 411{
400 object *tmp; 412 object *tmp;
401 int last = op->value; 413 int last = op->value;
402 int detected; 414 int detected;
403 415
404 detected = 0; 416 detected = 0;
405 417
406 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above) 418 for (tmp = op->ms ().bot; tmp && !detected; tmp = tmp->above)
407 { 419 {
408 object *tmp2; 420 object *tmp2;
409 421
410 if (op->stats.hp) 422 if (op->stats.hp)
411 { 423 {
… …
429 if (op->stats.sp == 1) 441 if (op->stats.sp == 1)
430 { 442 {
431 if (detected && last == 0) 443 if (detected && last == 0)
432 { 444 {
433 op->value = 1; 445 op->value = 1;
434 push_button (op); 446 push_button (op, tmp);
435 } 447 }
448
436 if (!detected && last == 1) 449 if (!detected && last == 1)
437 { 450 {
438 op->value = 0; 451 op->value = 0;
439 push_button (op); 452 push_button (op, tmp);
440 } 453 }
441 } 454 }
442 else 455 else
443 { /* in this case, we unset buttons */ 456 { /* in this case, we unset buttons */
444 if (detected && last == 1) 457 if (detected && last == 1)
445 { 458 {
446 op->value = 0; 459 op->value = 0;
447 push_button (op); 460 push_button (op, tmp);
448 } 461 }
462
449 if (!detected && last == 0) 463 if (!detected && last == 0)
450 { 464 {
451 op->value = 1; 465 op->value = 1;
452 push_button (op); 466 push_button (op, tmp);
453 } 467 }
454 } 468 }
455} 469}
456
457 470
458void 471void
459animate_trigger (object *op) 472animate_trigger (object *op)
460{ 473{
461 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 474 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
… …
468 SET_ANIMATION (op, op->stats.wc); 481 SET_ANIMATION (op, op->stats.wc);
469 update_object (op, UP_OBJ_FACE); 482 update_object (op, UP_OBJ_FACE);
470 } 483 }
471} 484}
472 485
473void 486static void
474move_hole (object *op) 487move_hole (object *op)
475{ /* 1 = opening, 0 = closing */ 488{ /* 1 = opening, 0 = closing */
476 object *next, *tmp;
477
478 if (op->value) 489 if (op->value)
479 { /* We're opening */ 490 { /* We're opening */
480 if (--op->stats.wc <= 0) 491 if (--op->stats.wc <= 0)
481 { /* Opened, let's stop */ 492 { /* Opened, let's stop */
482 op->stats.wc = 0; 493 op->stats.wc = 0;
483 op->set_speed (0); 494 op->set_speed (0);
484 495
485 /* Hard coding this makes sense for holes I suppose */ 496 /* Hard coding this makes sense for holes I suppose */
486 op->move_on = MOVE_WALK; 497 op->move_on = MOVE_WALK;
487 for (tmp = op->above; tmp != NULL; tmp = next) 498 for (object *next, *tmp = op->above; tmp; tmp = next)
488 { 499 {
489 next = tmp->above; 500 next = tmp->above;
490 move_apply (op, tmp, tmp); 501 move_apply (op, tmp, tmp);
491 } 502 }
492 } 503 }
493 504
494 SET_ANIMATION (op, op->stats.wc); 505 SET_ANIMATION (op, op->stats.wc);
495 update_object (op, UP_OBJ_FACE); 506 update_object (op, UP_OBJ_CHANGE);
496 return; 507 return;
497 } 508 }
509
498 /* We're closing */ 510 /* We're closing */
499 op->move_on = 0; 511 op->move_on = 0;
500 512
501 op->stats.wc++; 513 op->stats.wc++;
502 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 514 if (op->stats.wc >= NUM_ANIMATIONS (op))
503 op->stats.wc = NUM_ANIMATIONS (op) - 1; 515 op->stats.wc = NUM_ANIMATIONS (op) - 1;
504 516
505 SET_ANIMATION (op, op->stats.wc); 517 SET_ANIMATION (op, op->stats.wc);
506 update_object (op, UP_OBJ_FACE); 518 update_object (op, UP_OBJ_CHANGE);
507 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 519 if (op->stats.wc == (NUM_ANIMATIONS (op) - 1))
508 op->set_speed (0); /* closed, let's stop */ 520 op->set_speed (0); /* closed, let's stop */
509} 521}
510 522
511 523
512/* 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
… …
533 { 545 {
534 object *payload = op->inv; 546 object *payload = op->inv;
535 547
536 if (payload == NULL) 548 if (payload == NULL)
537 return NULL; 549 return NULL;
550
538 payload->remove (); 551 payload->remove ();
539 op->destroy (); 552 op->destroy ();
540 return payload; 553 return payload;
541 } 554 }
542 555
… …
559fix_stopped_item (object *op, maptile *map, object *originator) 572fix_stopped_item (object *op, maptile *map, object *originator)
560{ 573{
561 if (map == NULL) 574 if (map == NULL)
562 return; 575 return;
563 576
564 if (QUERY_FLAG (op, FLAG_REMOVED)) 577 if (op->flag [FLAG_REMOVED])
565 insert_ob_in_map (op, map, originator, 0); 578 insert_ob_in_map (op, map, originator, 0);
566 else if (op->type == ARROW) 579 else if (op->type == ARROW)
567 merge_ob (op, NULL); /* only some arrows actually need this */ 580 merge_ob (op, NULL); /* only some arrows actually need this */
568} 581}
569 582
… …
585 598
586 // restore original wc, dam, attacktype and slaying 599 // restore original wc, dam, attacktype and slaying
587 op->stats.wc = op->stats.sp; 600 op->stats.wc = op->stats.sp;
588 op->stats.dam = op->stats.hp; 601 op->stats.dam = op->stats.hp;
589 op->attacktype = op->stats.grace; 602 op->attacktype = op->stats.grace;
603 op->slaying = op->custom_name;
590 604
591 if (op->spellarg)
592 {
593 op->slaying = op->spellarg;
594 free (op->spellarg);
595 op->spellarg = 0;
596 }
597 else
598 op->slaying = 0;
599
600 /* 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 */
601 op->spellarg = NULL; 606 op->custom_name = 0;
602 op->stats.sp = 0; 607 op->stats.sp = 0;
603 op->stats.hp = 0; 608 op->stats.hp = 0;
604 op->stats.grace = 0; 609 op->stats.grace = 0;
605 op->level = 0; 610 op->level = 0;
606 op->face = op->arch->face; 611 op->face = op->arch->face;
607 op->owner = NULL; /* So that stopped arrows will be saved */ 612 op->owner = 0;
613
608 update_object (op, UP_OBJ_CHANGE); 614 update_object (op, UP_OBJ_CHANGE);
615
609 return op; 616 return op;
610} 617}
611 618
612/* stop_arrow() - what to do when a non-living flying object 619/* stop_arrow() - what to do when a non-living flying object
613 * 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
… …
622 if (INVOKE_OBJECT (STOP, op)) 629 if (INVOKE_OBJECT (STOP, op))
623 return; 630 return;
624 631
625 if (op->inv) 632 if (op->inv)
626 { 633 {
634 // replace this by straightforward drop to ground?
627 object *payload = op->inv; 635 object *payload = op->inv;
628 636
629 payload->remove ();
630 payload->owner = 0; 637 payload->owner = 0;
631 insert_ob_in_map (payload, op->map, payload, 0); 638 insert_ob_in_map (payload, op->map, payload, 0);
632 op->destroy (); 639 op->destroy ();
633 } 640 }
634 else 641 else
… …
638 if (op) 645 if (op)
639 merge_ob (op, 0); 646 merge_ob (op, 0);
640 } 647 }
641} 648}
642 649
643/* 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.
644 */ 651 */
645void 652void
646move_arrow (object *op) 653move_arrow (object *op)
647{ 654{
648 object *tmp;
649 sint16 new_x, new_y;
650 int was_reflected, mflags; 655 int was_reflected;
651 maptile *m;
652 656
653 if (op->map == NULL) 657 if (!op->map)
654 { 658 {
655 LOG (llevError, "BUG: Arrow had no map.\n"); 659 LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
656 op->destroy (); 660 op->destroy ();
657 return; 661 return;
658 } 662 }
659 663
660 /* we need to stop thrown objects at some point. Like here. */ 664 /* we need to stop thrown objects at some point. Like here. */
… …
666 * 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,
667 * 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
668 * 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,
669 * and it is easy enough to clean it up here. 673 * and it is easy enough to clean it up here.
670 */ 674 */
671 if (op->inv == NULL) 675 if (!op->inv)
672 { 676 {
673 op->destroy (); 677 op->destroy ();
674 return; 678 return;
675 } 679 }
676 680
… …
679 stop_arrow (op); 683 stop_arrow (op);
680 return; 684 return;
681 } 685 }
682 } 686 }
683 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
684 /* 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
685 values look rediculous. */ 694 values look rediculous. */
686 if (op->speed < 0.5 && op->type == ARROW) 695 if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
687 { 696 {
688 stop_arrow (op); 697 stop_arrow (op);
689 return; 698 return;
690 } 699 }
691 700
692 /* Calculate target map square */ 701 /* Calculate target map square */
693 new_x = op->x + DIRX (op);
694 new_y = op->y + DIRY (op);
695 was_reflected = 0; 702 was_reflected = 0;
696 703
697 m = op->map; 704 mapxy pos (op); pos.move (op->direction);
698 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
699 705
700 if (mflags & P_OUT_OF_MAP) 706 if (!pos.normalise ())
701 { 707 {
702 stop_arrow (op); 708 stop_arrow (op);
703 return; 709 return;
704 } 710 }
705 711
706 /* only need to look for living creatures if this flag is set */ 712 /* only need to look for living creatures if this flag is set */
707 if (mflags & P_IS_ALIVE) 713 if (pos->flags () & P_IS_ALIVE)
708 { 714 {
709 for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above) 715 object *tmp;
710 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 716
717 for (tmp = pos->bot; tmp; tmp = tmp->above)
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
… …
737 return; 743 return;
738 } 744 }
739 } /* if this is not hitting its owner */ 745 } /* if this is not hitting its owner */
740 } /* if there is something alive on this space */ 746 } /* if there is something alive on this space */
741 747
742 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 748 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
743 { 749 {
744 int retry = 0; 750 int retry = 0;
745 751
746 /* if the object doesn't reflect, stop the arrow from moving 752 /* if the object doesn't reflect, stop the arrow from moving
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
… …
760 if (op->direction & 1) 766 if (op->direction & 1)
761 { 767 {
762 op->direction = absdir (op->direction + 4); 768 op->direction = absdir (op->direction + 4);
763 retry = 1; 769 retry = 1;
764 } 770 }
771
765 /* There were two blocks with identical code - 772 /* There were two blocks with identical code -
766 * use this retry here to make this one block 773 * use this retry here to make this one block
767 * that did the same thing. 774 * that did the same thing.
768 */ 775 */
769 while (retry < 2) 776 while (retry < 2)
770 { 777 {
771 int left, right, mflags;
772 maptile *m1;
773 sint16 x1, y1;
774
775 retry++; 778 retry++;
776 779
777 /* Need to check for P_OUT_OF_MAP: if the arrow is tavelling 780 /* Need to check for P_OUT_OF_MAP: if the arrow is travelling
778 * over a corner in a tiled map, it is possible that 781 * over a corner in a tiled map, it is possible that
779 * op->direction is within an adjacent map but either 782 * op->direction is within an adjacent map but either
780 * op->direction-1 or op->direction+1 does not exist. 783 * op->direction-1 or op->direction+1 does not exist.
781 */ 784 */
782 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)], 785 mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
783 op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1); 786 bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
784 left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
785 787
786 mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)], 788 mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
787 op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1); 789 bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
788 right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
789 790
790 if (left == right) 791 if (left == right)
791 op->direction = absdir (op->direction + 4); 792 op->direction = absdir (op->direction + 4);
792 else if (left) 793 else if (left)
793 op->direction = absdir (op->direction + 2); 794 op->direction = absdir (op->direction + 2);
794 else if (right) 795 else if (right)
795 op->direction = absdir (op->direction - 2); 796 op->direction = absdir (op->direction - 2);
796 797
797 mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
798
799 /* If this space is not out of the map and not blocked, valid space - 798 /* If this space is not out of the map and not blocked, valid space -
800 * don't need to retry again. 799 * don't need to retry again.
801 */ 800 */
802 if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1))) 801 mapxy pos3 (pos); pos3.move (op->direction);
802 if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
803 break; 803 break;
804
805 } 804 }
805
806 /* Couldn't find a direction to move the arrow to - just 806 /* Couldn't find a direction to move the arrow to - just
807 * top it from moving. 807 * stop it from moving.
808 */ 808 */
809 if (retry == 2) 809 if (retry == 2)
810 { 810 {
811 stop_arrow (op); 811 stop_arrow (op);
812 return; 812 return;
813 } 813 }
814
814 /* update object image for new facing */ 815 /* update object image for new facing */
815 /* many thrown objects *don't* have more than one face */ 816 /* many thrown objects *don't* have more than one face */
816 if (GET_ANIM_ID (op)) 817 if (op->has_anim ())
817 SET_ANIMATION (op, op->direction); 818 op->set_anim_frame (op->direction);
818 } /* object is reflected */ 819 } /* object is reflected */
819 } /* object ran into a wall */ 820 } /* object ran into a wall */
820 821
821 /* Move the arrow. */ 822 /* Move the arrow. */
822 op->remove (); 823 op->move_to (pos);
823 op->x = new_x;
824 op->y = new_y;
825
826 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
827 * about 17 squares. Tune as needed.
828 */
829 op->speed -= 0.05;
830 insert_ob_in_map (op, m, op, 0);
831} 824}
832 825
833/* This routine doesnt seem to work for "inanimate" objects that 826static void
834 * are being carried, ie a held torch leaps from your hands!.
835 * Modified this routine to allow held objects. b.t. */
836
837void
838change_object (object *op) 827change_object (object *op)
839{ /* Doesn`t handle linked objs yet */ 828{ /* Doesn`t handle linked objs yet */
840 int i, j;
841
842 if (op->other_arch == NULL) 829 if (!op->other_arch)
843 { 830 {
844 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 ());
845 return; 832 return;
846 } 833 }
847 834
848 /* In non-living items only change when food value is 0 */ 835 /* In non-living items only change when food value is 0 */
849 if (!QUERY_FLAG (op, FLAG_ALIVE)) 836 if (!op->flag [FLAG_ALIVE])
850 { 837 {
851 if (op->stats.food-- > 0) 838 if (op->stats.food-- > 0)
852 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);
853 else 855 else
854 op->stats.food = 1; /* so 1 other_arch is made */
855 }
856
857 object *pl = op->in_player ();
858 object *env = op->env;
859
860 op->remove ();
861 for (i = 0; i < NROFNEWOBJS (op); i++)
862 {
863 object *tmp = arch_to_object (op->other_arch);
864
865 if (op->type == LAMP)
866 tmp->stats.food = op->stats.food - 1;
867
868 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
869 if (env)
870 {
871 tmp->x = env->x, tmp->y = env->y;
872 tmp = insert_ob_in_ob (tmp, env);
873
874 /* If this object is the players inventory, we need to tell the
875 * client of the change. Insert_ob_in_map takes care of the
876 * updating the client, so we don't need to do that below.
877 */
878 if (pl)
879 {
880 esrv_del_item (pl->contr, op->count);
881 esrv_send_item (pl, tmp);
882 }
883 } 856 {
884 else
885 {
886 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
887 if (j == -1) /* No free spot */ 859 if (j < 0) /* No free spot */
888 tmp->destroy (); 860 tmp->destroy ();
889 else 861 else
890 { 862 {
891 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j]; 863 mapxy pos (op); pos.move (j);
892 insert_ob_in_map (tmp, op->map, op, 0); 864
865 if (pos.normalise ())
866 pos.insert (tmp, op);
893 } 867 }
894 } 868 }
895 } 869 }
896 870
897 op->destroy (); 871 op->destroy ();
… …
914 888
915 if (op->head) 889 if (op->head)
916 head = op->head; 890 head = op->head;
917 891
918 for (tmp = op->above; tmp; tmp = tmp->above) 892 for (tmp = op->above; tmp; tmp = tmp->above)
919 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 893 if (!tmp->flag [FLAG_IS_FLOOR])
920 break; 894 break;
921 895
922 /* If nothing above us to move, nothing to do */ 896 /* If nothing above us to move, nothing to do */
923 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 897 if (!tmp || tmp->flag [FLAG_WIZPASS])
924 return; 898 return;
925 899
926 if (EXIT_PATH (head)) 900 if (EXIT_PATH (head))
927 { 901 {
928 if (tmp->type == PLAYER) 902 if (tmp->type == PLAYER)
… …
953 else 927 else
954 { 928 {
955 /* Random teleporter */ 929 /* Random teleporter */
956 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp))) 930 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
957 return; 931 return;
932
958 teleport (head, TELEPORTER, tmp); 933 teleport (head, TELEPORTER, tmp);
959 } 934 }
960} 935}
961 936
962/* This object will teleport someone to a different map 937/* This object will teleport someone to a different map
963 and will also apply changes to the player from its inventory. 938 and will also apply changes to the player from its inventory.
964 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
965 can't be generalized. 940 can't be generalized.
966*/ 941*/
967void 942static void
968move_player_changer (object *op) 943move_player_changer (object *op)
969{ 944{
970 object *player;
971 object *walk;
972
973 if (!op->above || !EXIT_PATH (op)) 945 if (!op->above || !EXIT_PATH (op))
974 return; 946 return;
975 947
976 /* This isn't all that great - means that the player_mover 948 /* This isn't all that great - means that the player_mover
977 * needs to be on top. 949 * needs to be on top.
978 */ 950 */
979 if (op->above->type == PLAYER) 951 if (op->above->type == PLAYER)
980 { 952 {
953 object *player = op->above;
954
981 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 955 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
982 return; 956 return;
983 957
984 player = op->above;
985
986 for (walk = op->inv; walk; walk = walk->below) 958 for (object *walk = op->inv; walk; walk = walk->below)
987 apply_changes_to_player (player, walk); 959 apply_changes_to_player (player, walk);
988 960
989 player->update_stats (); 961 player->update_stats ();
990 962
991 esrv_send_inventory (op->above, op->above); 963 esrv_send_inventory (op->above, op->above);
… …
1029 } 1001 }
1030 1002
1031 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);
1032} 1004}
1033 1005
1034/* move_player_mover: this function takes a "player mover" as an 1006/* move_player_mover: this function takes a "player mover" as an
1035 * argument, and performs the function of a player mover, which is: 1007 * argument, and performs the function of a player mover, which is:
1036 * 1008 *
1037 * 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
1038 * 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.
1039 * 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,
1040 * 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,
1041 * it'll paralyze the victim for hp*his speed/op->speed 1013 * it'll paralyze the victim for hp*his speed/op->speed
1042 */ 1014 */
1043void 1015static void
1044move_player_mover (object *op) 1016move_player_mover (object *op)
1045{ 1017{
1046 int dir = op->stats.sp; 1018 int dir = 0;
1047 sint16 nx, ny;
1048 maptile *m;
1049
1050 /* Determine direction now for random movers so we do the right thing */
1051 if (!dir)
1052 dir = rndm (1, 8);
1053 1019
1054 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1020 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1055 { 1021 {
1056 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1022 if (victim->flag [FLAG_ALIVE]
1023 && !victim->flag [FLAG_WIZPASS]
1057 (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)
1058 { 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 }
1059 1045
1060 if (victim->head) 1046 if (victim->head)
1061 victim = victim->head; 1047 victim = victim->head;
1062 1048
1063 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1064 {
1065 op->remove ();
1066 return;
1067 }
1068
1069 nx = op->x + freearr_x[dir];
1070 ny = op->y + freearr_y[dir];
1071 m = op->map;
1072 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1073 {
1074 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1075 return;
1076 }
1077
1078 if (should_director_abort (op, victim)) 1049 if (should_director_abort (op, victim))
1079 return; 1050 return;
1080 1051
1081 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)
1082 { 1053 {
1083 if (nextmover->type == PLAYERMOVER) 1054 if (nextmover->type == PLAYERMOVER)
1084 nextmover->speed_left = -.99f; 1055 nextmover->speed_left = -.99f;
1085 1056
1086 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1057 if (nextmover->flag [FLAG_ALIVE])
1087 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 */
1088 } 1059 }
1089 1060
1090 if (victim->type == PLAYER) 1061 if (victim->type == PLAYER)
1091 { 1062 {
1092 /* only level >=1 movers move people */ 1063 /* only level >=1 movers move people */
1093 if (op->level) 1064 if (op->level)
1094 { 1065 {
1095 /* 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
1096 * is cleared, otherwise the player will get stuck in 1067 * is cleared, otherwise the player will get stuck in
1097 * place. This can happen if the player used a spell to 1068 * place. This can happen if the player used a spell to
1098 * get to this space. 1069 * get to this space.
1099 */ 1070 */
1100 victim->contr->fire_on = 0; 1071 victim->contr->fire_on = 0;
1101 victim->speed_left = 1.f; 1072 victim->speed_left = 1.f;
1102 move_player (victim, dir); 1073 move_player (victim, dir);
1103 } 1074 }
1104 else 1075 else
1105 return; 1076 return;
1106 } 1077 }
1107 else 1078 else
1108 move_object (victim, dir); 1079 victim->move (dir);
1109 1080
1110 if (!op->stats.maxsp && op->attacktype) 1081 if (!op->stats.maxsp && op->attacktype)
1111 op->stats.maxsp = 2; 1082 op->stats.maxsp = 2;
1112 1083
1113 if (op->attacktype) 1084 if (op->attacktype)
1114 { /* flag to paralyze the player */ 1085 { /* flag to paralyze the player */
1115 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);
1116 } 1087 }
1117 } 1088 }
1118 } 1089 }
1119} 1090}
1120 1091
… …
1171 * has to make sure that there is in fact space for the object. 1142 * has to make sure that there is in fact space for the object.
1172 * It should really do this for small objects also, but there is 1143 * It should really do this for small objects also, but there is
1173 * more concern with large objects, most notably a part being placed 1144 * more concern with large objects, most notably a part being placed
1174 * outside of the map which would cause the server to crash 1145 * outside of the map which would cause the server to crash
1175*/ 1146*/
1176
1177void 1147void
1178move_creator (object *creator) 1148move_creator (object *creator)
1179{ 1149{
1180 object *new_ob; 1150 object *new_ob;
1181 1151
1182 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1152 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1183 { 1153 {
1184 creator->stats.hp = -1; 1154 creator->stats.hp = -1;
1185 return; 1155 return;
1186 } 1156 }
1187 1157
1188 if (creator->inv != NULL) 1158 if (creator->inv)
1189 { 1159 {
1190 object *ob; 1160 object *ob;
1191 int i; 1161 int i;
1192 object *ob_to_copy; 1162 object *ob_to_copy;
1193 1163
1194 /* select random object from inventory to copy */ 1164 /* select random object from inventory to copy */
1195 ob_to_copy = creator->inv; 1165 ob_to_copy = creator->inv;
1196 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++)
1197 { 1167 {
1198 if (rndm (0, i) == 0) 1168 if (rndm (0, i) == 0)
1199 { 1169 {
1200 ob_to_copy = ob; 1170 ob_to_copy = ob;
1201 } 1171 }
1202 } 1172 }
1203 new_ob = object_create_clone (ob_to_copy); 1173
1204 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);
1205 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1176 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1206 } 1177 }
1207 else 1178 else
1208 { 1179 {
1209 if (creator->other_arch == NULL) 1180 if (!creator->other_arch)
1210 { 1181 {
1211 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",
1212 &creator->name, &creator->map->path, creator->x, creator->y); 1183 &creator->name, &creator->map->path, creator->x, creator->y);
1213 return; 1184 return;
1214 } 1185 }
… …
1216 new_ob = object_create_arch (creator->other_arch); 1187 new_ob = object_create_arch (creator->other_arch);
1217 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL); 1188 fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1218 } 1189 }
1219 1190
1220 /* Make sure this multipart object fits */ 1191 /* Make sure this multipart object fits */
1221 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))
1222 { 1193 {
1223 new_ob->destroy (); 1194 new_ob->destroy ();
1224 return; 1195 return;
1225 } 1196 }
1226 1197
1227 // for now lets try to identify everything generated here, it mostly 1198 // for now lets try to identify everything generated here, it mostly
1228 // 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
1229 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1200 if (new_ob->need_identify ())
1201 new_ob->set_flag (FLAG_IDENTIFIED);
1230 1202
1231 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);
1232 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1204 if (new_ob->flag [FLAG_FREED])
1233 return; 1205 return;
1234 1206
1235 if (creator->slaying) 1207 if (creator->slaying)
1236 {
1237 new_ob->name = new_ob->title = creator->slaying; 1208 new_ob->name = new_ob->title = creator->slaying;
1238 }
1239} 1209}
1240 1210
1241/* move_marker --peterm@soda.csua.berkeley.edu 1211/* move_marker --peterm@soda.csua.berkeley.edu
1242 when moved, a marker will search for a player sitting above 1212 when moved, a marker will search for a player sitting above
1243 it, and insert an invisible, weightless force into him 1213 it, and insert an invisible, weightless force into him
… …
1253 { 1223 {
1254 /* remove an old force with a slaying field == op->name */ 1224 /* remove an old force with a slaying field == op->name */
1255 if (object *force = tmp->force_find (op->name)) 1225 if (object *force = tmp->force_find (op->name))
1256 force->destroy (); 1226 force->destroy ();
1257 1227
1258 if (!tmp->force_find (op->slaying)) 1228 if (op->slaying && !tmp->force_find (op->slaying))
1259 { 1229 {
1260 tmp->force_add (op->slaying, op->stats.food); 1230 tmp->force_add (op->slaying, op->stats.food);
1261 1231
1262 if (op->msg) 1232 if (op->msg)
1263 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg); 1233 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
… …
1275 } 1245 }
1276 } 1246 }
1277 } 1247 }
1278} 1248}
1279 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
1280void 1296void
1281process_object (object *op) 1297process_object (object *op)
1282{ 1298{
1283 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1299 if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1284 return; 1300 return;
1285 1301
1286 if (expect_false (INVOKE_OBJECT (TICK, op))) 1302 if (expect_false (INVOKE_OBJECT (TICK, op)))
1287 return; 1303 return;
1288 1304
1289 if (QUERY_FLAG (op, FLAG_MONSTER)) 1305 if (op->flag [FLAG_MONSTER])
1290 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1306 if (move_monster (op) || op->flag [FLAG_FREED])
1291 return; 1307 return;
1292 1308
1293 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1309 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1294 { 1310 {
1295 animate_object (op, op->contr ? op->facing : op->direction); 1311 animate_object (op, op->contr ? op->facing : op->direction);
1296 1312
1297 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1313 if (op->flag [FLAG_SEE_ANYWHERE])
1298 make_sure_seen (op); 1314 make_sure_seen (op);
1299 } 1315 }
1300 1316
1301 if (expect_false ( 1317 if (expect_false (
1302 op->flag [FLAG_GENERATOR] 1318 op->flag [FLAG_GENERATOR]
1303 || op->flag [FLAG_CHANGING] 1319 || op->flag [FLAG_CHANGING]
1304 || op->flag [FLAG_IS_USED_UP] 1320 || op->flag [FLAG_IS_USED_UP]
1305 )) 1321 ))
1306 { 1322 {
1307 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1323 if (op->flag [FLAG_CHANGING] && !op->state)
1308 { 1324 {
1309 change_object (op); 1325 change_object (op);
1310 return; 1326 return;
1311 } 1327 }
1312 1328
1313 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1329 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1314 generate_monster (op); 1330 generate_monster (op);
1315 1331
1316 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1332 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1317 { 1333 {
1318 if (QUERY_FLAG (op, FLAG_APPLIED)) 1334 if (op->flag [FLAG_APPLIED])
1319 remove_force (op); 1335 remove_force (op);
1320 else 1336 else
1321 { 1337 {
1322 /* If necessary, delete the item from the players inventory */ 1338 op->remove (); // TODO: really necessary?
1323 object *pl = op->in_player ();
1324 1339
1325 if (pl)
1326 esrv_del_item (pl->contr, op->count);
1327
1328 op->remove ();
1329
1330 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1340 if (op->flag [FLAG_SEE_ANYWHERE])
1331 make_sure_not_seen (op); 1341 make_sure_not_seen (op);
1332 1342
1333 op->destroy (); 1343 op->drop_and_destroy ();
1334 } 1344 }
1335 1345
1336 return; 1346 return;
1337 } 1347 }
1338 } 1348 }
… …
1462 1472
1463 case PLAYER: 1473 case PLAYER:
1464 // players have their own speed-management, so undo the --speed_left 1474 // players have their own speed-management, so undo the --speed_left
1465 ++op->speed_left; 1475 ++op->speed_left;
1466 break; 1476 break;
1467 }
1468}
1469 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