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.17 by root, Tue Dec 12 21:39:57 2006 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines