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