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.1 by elmex, Sun Aug 13 17:16:05 2006 UTC vs.
Revision 1.12 by root, Thu Sep 14 22:34:05 2006 UTC

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

Diff Legend

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