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.13 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.63 by root, Sat Aug 4 22:23:47 2007 UTC

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

Diff Legend

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