ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/monster.C
(Generate patch)

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.3 by root, Tue Aug 29 05:03:55 2006 UTC vs.
Revision 1.4 by root, Tue Aug 29 08:01:37 2006 UTC

1/* 1/*
2 * static char *rcsid_monster_c = 2 * static char *rcsid_monster_c =
3 * "$Id: monster.C,v 1.3 2006/08/29 05:03:55 root Exp $"; 3 * "$Id: monster.C,v 1.4 2006/08/29 08:01:37 root Exp $";
4 */ 4 */
5 5
6/* 6/*
7 CrossFire, A Multiplayer game for X-windows 7 CrossFire, A Multiplayer game for X-windows
8 8
… …
48 /* if this is pet, let him attack the same enemy as his owner 48 /* if this is pet, let him attack the same enemy as his owner
49 * TODO: when there is no ower enemy, try to find a target, 49 * TODO: when there is no ower enemy, try to find a target,
50 * which CAN attack the owner. */ 50 * which CAN attack the owner. */
51 if ((npc->attack_movement & HI4) == PETMOVE) 51 if ((npc->attack_movement & HI4) == PETMOVE)
52 { 52 {
53 if (npc->owner == NULL) 53 if (npc->owner == NULL)
54 npc->enemy = NULL; 54 npc->enemy = NULL;
55 else if (npc->enemy == NULL) 55 else if (npc->enemy == NULL)
56 npc->enemy = npc->owner->enemy; 56 npc->enemy = npc->owner->enemy;
57 } 57 }
58 58
59 /* periodically, a monster mayu change its target. Also, if the object 59 /* periodically, a monster mayu change its target. Also, if the object
60 * has been destroyed, etc, clear the enemy. 60 * has been destroyed, etc, clear the enemy.
61 * TODO: this should be changed, because it invokes to attack forced or 61 * TODO: this should be changed, because it invokes to attack forced or
… …
67 * If we include a aggravated flag in , we can handle evil vs evil and good vs good 67 * If we include a aggravated flag in , we can handle evil vs evil and good vs good
68 * too. */ 68 * too. */
69 69
70 if(npc->enemy) 70 if(npc->enemy)
71 { 71 {
72 /* I broke these if's apart to better be able to see what 72 /* I broke these if's apart to better be able to see what
73 * the grouping checks are. Code is the same. 73 * the grouping checks are. Code is the same.
74 */ 74 */
75 if ( QUERY_FLAG(npc->enemy,FLAG_REMOVED) || 75 if ( QUERY_FLAG(npc->enemy,FLAG_REMOVED) ||
76 QUERY_FLAG(npc->enemy,FLAG_FREED) || 76 QUERY_FLAG(npc->enemy,FLAG_FREED) ||
77 !on_same_map(npc, npc->enemy) || 77 !on_same_map(npc, npc->enemy) ||
78 npc == npc->enemy || 78 npc == npc->enemy ||
79 QUERY_FLAG(npc, FLAG_NEUTRAL) || 79 QUERY_FLAG(npc, FLAG_NEUTRAL) ||
80 QUERY_FLAG(npc->enemy, FLAG_NEUTRAL)) 80 QUERY_FLAG(npc->enemy, FLAG_NEUTRAL))
81 npc->enemy = NULL; 81 npc->enemy = NULL;
82 82
83 else if (QUERY_FLAG(npc, FLAG_FRIENDLY) && ( 83 else if (QUERY_FLAG(npc, FLAG_FRIENDLY) && (
84 (QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && !(should_arena_attack(npc, npc->owner, npc->enemy))) || 84 (QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && !(should_arena_attack(npc, npc->owner, npc->enemy))) ||
85 ((npc->enemy->type == PLAYER) && !(should_arena_attack(npc, npc->owner, npc->enemy))) 85 ((npc->enemy->type == PLAYER) && !(should_arena_attack(npc, npc->owner, npc->enemy)))
86 || npc->enemy == npc->owner)) 86 || npc->enemy == npc->owner))
87 npc->enemy = NULL; 87 npc->enemy = NULL;
88 88
89 89
90 else if (!QUERY_FLAG(npc, FLAG_FRIENDLY) && 90 else if (!QUERY_FLAG(npc, FLAG_FRIENDLY) &&
91 (!QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && npc->enemy->type!=PLAYER)) 91 (!QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && npc->enemy->type!=PLAYER))
92 npc->enemy=NULL; 92 npc->enemy=NULL;
93 93
94 /* I've noticed that pets could sometimes get an arrow as the 94 /* I've noticed that pets could sometimes get an arrow as the
95 * target enemy - this code below makes sure the enemy is something 95 * target enemy - this code below makes sure the enemy is something
96 * that should be attacked. My guess is that the arrow hits 96 * that should be attacked. My guess is that the arrow hits
97 * the creature/owner, and so the creature then takes that 97 * the creature/owner, and so the creature then takes that
98 * as the enemy to attack. 98 * as the enemy to attack.
99 */ 99 */
100 else if (!QUERY_FLAG(npc->enemy, FLAG_MONSTER) && 100 else if (!QUERY_FLAG(npc->enemy, FLAG_MONSTER) &&
101 !QUERY_FLAG(npc->enemy,FLAG_GENERATOR) && 101 !QUERY_FLAG(npc->enemy,FLAG_GENERATOR) &&
102 npc->enemy->type!=PLAYER && npc->enemy->type != GOLEM) 102 npc->enemy->type!=PLAYER && npc->enemy->type != GOLEM)
103 npc->enemy=NULL; 103 npc->enemy=NULL;
104 104
105 } 105 }
106 return can_detect_enemy(npc,npc->enemy,rv)?npc->enemy:NULL; 106 return can_detect_enemy(npc,npc->enemy,rv)?npc->enemy:NULL;
107} 107}
… …
132 /* modified to implement smart searching using search_arr 132 /* modified to implement smart searching using search_arr
133 * guidance array to determine direction of search order 133 * guidance array to determine direction of search order
134 */ 134 */
135 nx = npc->x + freearr_x[search_arr[i]]; 135 nx = npc->x + freearr_x[search_arr[i]];
136 ny = npc->y + freearr_y[search_arr[i]]; 136 ny = npc->y + freearr_y[search_arr[i]];
137 m = npc->map; 137 m = npc->map;
138 138
139 mflags = get_map_flags(m, &m, nx, ny, &nx, &ny); 139 mflags = get_map_flags(m, &m, nx, ny, &nx, &ny);
140 if (mflags & P_OUT_OF_MAP) continue; 140 if (mflags & P_OUT_OF_MAP) continue;
141 141
142 if (mflags & P_IS_ALIVE) { 142 if (mflags & P_IS_ALIVE) {
143 tmp=get_map_ob(m,nx,ny); 143 tmp=get_map_ob(m,nx,ny);
144 while(tmp!=NULL && !QUERY_FLAG(tmp,FLAG_MONSTER)&& 144 while(tmp!=NULL && !QUERY_FLAG(tmp,FLAG_MONSTER)&&
145 !QUERY_FLAG(tmp,FLAG_GENERATOR ) && tmp->type!=PLAYER) 145 !QUERY_FLAG(tmp,FLAG_GENERATOR ) && tmp->type!=PLAYER)
146 tmp=tmp->above; 146 tmp=tmp->above;
147 147
148 if (!tmp) { 148 if (!tmp) {
149 LOG(llevDebug,"find_nearest_living_creature: map %s (%d,%d) has is_alive set but did not find a monster?\n", 149 LOG(llevDebug,"find_nearest_living_creature: map %s (%d,%d) has is_alive set but did not find a monster?\n",
150 m->path, nx, ny); 150 m->path, nx, ny);
151 } 151 }
152 else { 152 else {
153 if(can_see_monsterP(m,nx,ny,i)) 153 if(can_see_monsterP(m,nx,ny,i))
154 return tmp; 154 return tmp;
155 } 155 }
156 } /* is something living on this space */ 156 } /* is something living on this space */
157 } 157 }
158 return NULL; /* nothing found */ 158 return NULL; /* nothing found */
159} 159}
160 160
161 161
… …
174 attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */ 174 attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */
175 npc->attacked_by = NULL; /* always clear the attacker entry */ 175 npc->attacked_by = NULL; /* always clear the attacker entry */
176 176
177 /* if we berserk, we don't care about others - we attack all we can find */ 177 /* if we berserk, we don't care about others - we attack all we can find */
178 if(QUERY_FLAG(npc,FLAG_BERSERK)) { 178 if(QUERY_FLAG(npc,FLAG_BERSERK)) {
179 tmp = find_nearest_living_creature(npc); 179 tmp = find_nearest_living_creature(npc);
180 if (tmp) get_rangevector(npc, tmp, rv, 0); 180 if (tmp) get_rangevector(npc, tmp, rv, 0);
181 return tmp; 181 return tmp;
182 } 182 }
183 183
184 /* Here is the main enemy selection. 184 /* Here is the main enemy selection.
185 * We want this: if there is an enemy, attack him until its not possible or 185 * We want this: if there is an enemy, attack him until its not possible or
186 * one of both is dead. 186 * one of both is dead.
… …
192 */ 192 */
193 193
194 /* pet move */ 194 /* pet move */
195 if ((npc->attack_movement & HI4) == PETMOVE) { 195 if ((npc->attack_movement & HI4) == PETMOVE) {
196 tmp= get_pet_enemy(npc,rv); 196 tmp= get_pet_enemy(npc,rv);
197 if (tmp) get_rangevector(npc, tmp, rv, 0); 197 if (tmp) get_rangevector(npc, tmp, rv, 0);
198 return tmp; 198 return tmp;
199 } 199 }
200 200
201 /* we check our old enemy. */ 201 /* we check our old enemy. */
202 if((tmp=check_enemy(npc, rv))==NULL) 202 if((tmp=check_enemy(npc, rv))==NULL)
203 { 203 {
… …
225 225
226 /* we have no legal enemy or attacker, so we try to target a new one */ 226 /* we have no legal enemy or attacker, so we try to target a new one */
227 if(!QUERY_FLAG(npc, FLAG_UNAGGRESSIVE) && !QUERY_FLAG(npc, FLAG_FRIENDLY) && 227 if(!QUERY_FLAG(npc, FLAG_UNAGGRESSIVE) && !QUERY_FLAG(npc, FLAG_FRIENDLY) &&
228 !QUERY_FLAG(npc, FLAG_NEUTRAL)) 228 !QUERY_FLAG(npc, FLAG_NEUTRAL))
229 { 229 {
230 npc->enemy = get_nearest_player(npc); 230 npc->enemy = get_nearest_player(npc);
231 if (npc->enemy) 231 if (npc->enemy)
232 tmp = check_enemy(npc,rv); 232 tmp = check_enemy(npc,rv);
233 } 233 }
234 234
235 } 235 }
236 236
237 return tmp; 237 return tmp;
… …
249 /* Trim work - if no enemy, no need to do anything below */ 249 /* Trim work - if no enemy, no need to do anything below */
250 if (!enemy) return 0; 250 if (!enemy) return 0;
251 251
252 /* blinded monsters can only find nearby objects to attack */ 252 /* blinded monsters can only find nearby objects to attack */
253 if(QUERY_FLAG(op, FLAG_BLIND)) 253 if(QUERY_FLAG(op, FLAG_BLIND))
254 radius = MIN_MON_RADIUS; 254 radius = MIN_MON_RADIUS;
255 255
256 /* This covers the situation where the monster is in the dark 256 /* This covers the situation where the monster is in the dark
257 * and has an enemy. If the enemy has no carried light (or isnt 257 * and has an enemy. If the enemy has no carried light (or isnt
258 * glowing!) then the monster has trouble finding the enemy. 258 * glowing!) then the monster has trouble finding the enemy.
259 * Remember we already checked to see if the monster can see in 259 * Remember we already checked to see if the monster can see in
260 * the dark. */ 260 * the dark. */
261 261
262 else if(op->map && op->map->darkness>0 && enemy && !enemy->invisible && 262 else if(op->map && op->map->darkness>0 && enemy && !enemy->invisible &&
263 !stand_in_light(enemy) && 263 !stand_in_light(enemy) &&
264 (!QUERY_FLAG(op,FLAG_SEE_IN_DARK) || !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) { 264 (!QUERY_FLAG(op,FLAG_SEE_IN_DARK) || !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) {
265 int dark = radius/(op->map->darkness); 265 int dark = radius/(op->map->darkness);
266 radius = (dark>MIN_MON_RADIUS)?(dark+1):MIN_MON_RADIUS; 266 radius = (dark>MIN_MON_RADIUS)?(dark+1):MIN_MON_RADIUS;
267 } 267 }
268 else if(!QUERY_FLAG(op,FLAG_SLEEP)) return 1; 268 else if(!QUERY_FLAG(op,FLAG_SLEEP)) return 1;
269 269
270 /* enemy should already be on this map, so don't really need to check 270 /* enemy should already be on this map, so don't really need to check
271 * for that. 271 * for that.
272 */ 272 */
273 if (rv->distance < (QUERY_FLAG(enemy, FLAG_STEALTH)?(radius/2)+1:radius)) { 273 if (rv->distance < (QUERY_FLAG(enemy, FLAG_STEALTH)?(radius/2)+1:radius)) {
274 CLEAR_FLAG(op,FLAG_SLEEP); 274 CLEAR_FLAG(op,FLAG_SLEEP);
275 return 1; 275 return 1;
276 } 276 }
277 return 0; 277 return 0;
278} 278}
279 279
280int move_randomly(object *op) { 280int move_randomly(object *op) {
281 int i; 281 int i;
282 282
283 /* Give up to 15 chances for a monster to move randomly */ 283 /* Give up to 15 chances for a monster to move randomly */
284 for(i=0;i<15;i++) { 284 for(i=0;i<15;i++) {
285 if(move_object(op,RANDOM()%8+1)) 285 if(move_object(op,RANDOM()%8+1))
286 return 1; 286 return 1;
287 } 287 }
288 return 0; 288 return 0;
289} 289}
290 290
291/* 291/*
… …
316 } 316 }
317 317
318 /* generate hp, if applicable */ 318 /* generate hp, if applicable */
319 if(op->stats.Con > 0 && op->stats.hp < op->stats.maxhp) { 319 if(op->stats.Con > 0 && op->stats.hp < op->stats.maxhp) {
320 320
321 /* last heal is in funny units. Dividing by speed puts 321 /* last heal is in funny units. Dividing by speed puts
322 * the regeneration rate on a basis of time instead of 322 * the regeneration rate on a basis of time instead of
323 * #moves the monster makes. The scaling by 8 is 323 * #moves the monster makes. The scaling by 8 is
324 * to capture 8th's of a hp fraction regens 324 * to capture 8th's of a hp fraction regens
325 * 325 *
326 * Cast to sint32 before comparing to maxhp since otherwise an (sint16) 326 * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
327 * overflow might produce monsters with negative hp. 327 * overflow might produce monsters with negative hp.
328 */ 328 */
329 329
330 op->last_heal+= (int)((float)(8*op->stats.Con)/FABS(op->speed)); 330 op->last_heal+= (int)((float)(8*op->stats.Con)/FABS(op->speed));
331 op->stats.hp = MIN((sint32)op->stats.hp+op->last_heal/32, op->stats.maxhp); /* causes Con/4 hp/tick */ 331 op->stats.hp = MIN((sint32)op->stats.hp+op->last_heal/32, op->stats.maxhp); /* causes Con/4 hp/tick */
332 op->last_heal%=32; 332 op->last_heal%=32;
333 333
334 /* So if the monster has gained enough HP that they are no longer afraid */ 334 /* So if the monster has gained enough HP that they are no longer afraid */
335 if (QUERY_FLAG(op,FLAG_RUN_AWAY) && 335 if (QUERY_FLAG(op,FLAG_RUN_AWAY) &&
336 op->stats.hp >= (signed short)(((float)op->run_away/(float)100)* 336 op->stats.hp >= (signed short)(((float)op->run_away/(float)100)*
337 (float)op->stats.maxhp)) 337 (float)op->stats.maxhp))
338 CLEAR_FLAG(op, FLAG_RUN_AWAY); 338 CLEAR_FLAG(op, FLAG_RUN_AWAY);
339 339
340 if(op->stats.hp>op->stats.maxhp) 340 if(op->stats.hp>op->stats.maxhp)
341 op->stats.hp=op->stats.maxhp; 341 op->stats.hp=op->stats.maxhp;
342 } 342 }
343 343
344 /* generate sp, if applicable */ 344 /* generate sp, if applicable */
345 if(op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp) { 345 if(op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp) {
346 346
347 /* last_sp is in funny units. Dividing by speed puts 347 /* last_sp is in funny units. Dividing by speed puts
348 * the regeneration rate on a basis of time instead of 348 * the regeneration rate on a basis of time instead of
349 * #moves the monster makes. The scaling by 8 is 349 * #moves the monster makes. The scaling by 8 is
350 * to capture 8th's of a sp fraction regens 350 * to capture 8th's of a sp fraction regens
351 * 351 *
352 * Cast to sint32 before comparing to maxhp since otherwise an (sint16) 352 * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
353 * overflow might produce monsters with negative sp. 353 * overflow might produce monsters with negative sp.
354 */ 354 */
355 355
356 op->last_sp+= (int)((float)(8*op->stats.Pow)/FABS(op->speed)); 356 op->last_sp+= (int)((float)(8*op->stats.Pow)/FABS(op->speed));
357 op->stats.sp = MIN(op->stats.sp+op->last_sp/128, op->stats.maxsp); /* causes Pow/16 sp/tick */ 357 op->stats.sp = MIN(op->stats.sp+op->last_sp/128, op->stats.maxsp); /* causes Pow/16 sp/tick */
358 op->last_sp%=128; 358 op->last_sp%=128;
359 } 359 }
360 360
361 /* this should probably get modified by many more values. 361 /* this should probably get modified by many more values.
362 * (eg, creatures resistance to fear, level, etc. ) 362 * (eg, creatures resistance to fear, level, etc. )
363 */ 363 */
364 if(QUERY_FLAG(op, FLAG_SCARED) &&!(RANDOM()%20)) { 364 if(QUERY_FLAG(op, FLAG_SCARED) &&!(RANDOM()%20)) {
365 CLEAR_FLAG(op,FLAG_SCARED); /* Time to regain some "guts"... */ 365 CLEAR_FLAG(op,FLAG_SCARED); /* Time to regain some "guts"... */
366 } 366 }
367 367
368 if (INVOKE_OBJECT (MOVE, op, ARG_OBJECT (op->enemy)))//TODO: should go away 368 if (INVOKE_OBJECT (MOVE, op, ARG_OBJECT (op->enemy)))//TODO: should go away
369 return 0; 369 return 0;
370 370
371 if ( QUERY_FLAG(op, FLAG_SLEEP) || QUERY_FLAG(op, FLAG_BLIND) || 371 if ( QUERY_FLAG(op, FLAG_SLEEP) || QUERY_FLAG(op, FLAG_BLIND) ||
372 ((op->map->darkness>0) && !QUERY_FLAG(op,FLAG_SEE_IN_DARK) && 372 ((op->map->darkness>0) && !QUERY_FLAG(op,FLAG_SEE_IN_DARK) &&
373 !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) { 373 !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) {
374 if(!check_wakeup(op,enemy,&rv)) 374 if(!check_wakeup(op,enemy,&rv))
375 return 0; 375 return 0;
376 } 376 }
377 377
378 /* check if monster pops out of hidden spot */ 378 /* check if monster pops out of hidden spot */
379 if(op->hide) do_hidden_move(op); 379 if(op->hide) do_hidden_move(op);
380 380
381 if(op->pick_up) 381 if(op->pick_up)
382 monster_check_pickup(op); 382 monster_check_pickup(op);
383 383
384 if(op->will_apply) 384 if(op->will_apply)
385 monster_apply_below(op); /* Check for items to apply below */ 385 monster_apply_below(op); /* Check for items to apply below */
386 386
387 /* If we don't have an enemy, do special movement or the like */ 387 /* If we don't have an enemy, do special movement or the like */
388 if(!enemy) { 388 if(!enemy) {
389 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) { 389 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) {
390 remove_ob(op); 390 remove_ob(op);
391 free_object(op); 391 free_object(op);
392 return 1; 392 return 1;
393 } 393 }
394 394
395 /* Probably really a bug for a creature to have both 395 /* Probably really a bug for a creature to have both
396 * stand still and a movement type set. 396 * stand still and a movement type set.
397 */ 397 */
398 if(!QUERY_FLAG(op, FLAG_STAND_STILL)) { 398 if(!QUERY_FLAG(op, FLAG_STAND_STILL)) {
399 if (op->attack_movement & HI4) 399 if (op->attack_movement & HI4)
400 { 400 {
401 switch (op->attack_movement & HI4) { 401 switch (op->attack_movement & HI4) {
402 case (PETMOVE): 402 case (PETMOVE):
403 pet_move (op); 403 pet_move (op);
404 break; 404 break;
405 405
406 case (CIRCLE1): 406 case (CIRCLE1):
407 circ1_move (op); 407 circ1_move (op);
408 break; 408 break;
409 409
410 case (CIRCLE2): 410 case (CIRCLE2):
411 circ2_move (op); 411 circ2_move (op);
412 break; 412 break;
413 413
414 case (PACEV): 414 case (PACEV):
415 pace_movev(op); 415 pace_movev(op);
416 break; 416 break;
417 417
418 case (PACEH): 418 case (PACEH):
419 pace_moveh(op); 419 pace_moveh(op);
420 break; 420 break;
421 421
422 case (PACEV2): 422 case (PACEV2):
423 pace2_movev (op); 423 pace2_movev (op);
424 break; 424 break;
425 425
426 case (PACEH2): 426 case (PACEH2):
427 pace2_moveh (op); 427 pace2_moveh (op);
428 break; 428 break;
429 429
430 case (RANDO): 430 case (RANDO):
431 rand_move (op); 431 rand_move (op);
432 break; 432 break;
433 433
434 case (RANDO2): 434 case (RANDO2):
435 move_randomly (op); 435 move_randomly (op);
436 break; 436 break;
437 } 437 }
438 return 0; 438 return 0;
439 } 439 }
440 else if (QUERY_FLAG(op,FLAG_RANDOM_MOVE)) 440 else if (QUERY_FLAG(op,FLAG_RANDOM_MOVE))
441 (void) move_randomly(op); 441 (void) move_randomly(op);
442 442
443 } /* stand still */ 443 } /* stand still */
444 return 0; 444 return 0;
445 } /* no enemy */ 445 } /* no enemy */
446 446
447 /* We have an enemy. Block immediately below is for pets */ 447 /* We have an enemy. Block immediately below is for pets */
448 if((op->attack_movement&HI4) == PETMOVE && (owner = get_owner(op)) != NULL && !on_same_map(op,owner)) 448 if((op->attack_movement&HI4) == PETMOVE && (owner = get_owner(op)) != NULL && !on_same_map(op,owner))
… …
452 * player. Hmm. The code is here, but no monster in the current 452 * player. Hmm. The code is here, but no monster in the current
453 * arch set uses it. 453 * arch set uses it.
454 */ 454 */
455 if ( (op->race != NULL)&& strcmp(op->race,"doppleganger") == 0) 455 if ( (op->race != NULL)&& strcmp(op->race,"doppleganger") == 0)
456 { 456 {
457 op->face = enemy->face; 457 op->face = enemy->face;
458 if (op->name) 458 if (op->name)
459 free_string(op->name); 459 free_string(op->name);
460 add_refcount(op->name = enemy->name); 460 add_refcount(op->name = enemy->name);
461 } 461 }
462 462
463 /* Calculate range information for closest body part - this 463 /* Calculate range information for closest body part - this
464 * is used for the 'skill' code, which isn't that smart when 464 * is used for the 'skill' code, which isn't that smart when
465 * it comes to figuring it out - otherwise, giants throw boulders 465 * it comes to figuring it out - otherwise, giants throw boulders
… …
471 * we were not doing any of the logic below, so might as well save 471 * we were not doing any of the logic below, so might as well save
472 * a few cpu cycles. 472 * a few cpu cycles.
473 */ 473 */
474 if (!QUERY_FLAG(op, FLAG_SCARED)) 474 if (!QUERY_FLAG(op, FLAG_SCARED))
475 { 475 {
476 rv_vector rv1; 476 rv_vector rv1;
477 477
478 /* now we test every part of an object .... this is a real ugly piece of code */ 478 /* now we test every part of an object .... this is a real ugly piece of code */
479 for (part=op; part!=NULL; part=part->more) { 479 for (part=op; part!=NULL; part=part->more) {
480 get_rangevector(part, enemy, &rv1, 0x1); 480 get_rangevector(part, enemy, &rv1, 0x1);
481 dir=rv1.direction; 481 dir=rv1.direction;
482 482
483 /* hm, not sure about this part - in original was a scared flag here too 483 /* hm, not sure about this part - in original was a scared flag here too
484 * but that we test above... so can be old code here 484 * but that we test above... so can be old code here
485 */ 485 */
486 if(QUERY_FLAG(op,FLAG_RUN_AWAY)) 486 if(QUERY_FLAG(op,FLAG_RUN_AWAY))
487 dir=absdir(dir+4); 487 dir=absdir(dir+4);
488 if(QUERY_FLAG(op,FLAG_CONFUSED)) 488 if(QUERY_FLAG(op,FLAG_CONFUSED))
489 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 489 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
490 490
491 if(QUERY_FLAG(op,FLAG_CAST_SPELL) && !(RANDOM()%3)) { 491 if(QUERY_FLAG(op,FLAG_CAST_SPELL) && !(RANDOM()%3)) {
492 if(monster_cast_spell(op,part,enemy,dir,&rv1)) 492 if(monster_cast_spell(op,part,enemy,dir,&rv1))
493 return 0; 493 return 0;
494 } 494 }
495 495
496 if(QUERY_FLAG(op,FLAG_READY_SCROLL) && !(RANDOM()%3)) { 496 if(QUERY_FLAG(op,FLAG_READY_SCROLL) && !(RANDOM()%3)) {
497 if(monster_use_scroll(op,part,enemy,dir,&rv1)) 497 if(monster_use_scroll(op,part,enemy,dir,&rv1))
498 return 0; 498 return 0;
499 } 499 }
500 500
501 if(QUERY_FLAG(op,FLAG_READY_RANGE)&&!(RANDOM()%3)) { 501 if(QUERY_FLAG(op,FLAG_READY_RANGE)&&!(RANDOM()%3)) {
502 if(monster_use_range(op,part,enemy,dir)) 502 if(monster_use_range(op,part,enemy,dir))
503 return 0; 503 return 0;
504 } 504 }
505 if(QUERY_FLAG(op,FLAG_READY_SKILL)&&!(RANDOM()%3)) { 505 if(QUERY_FLAG(op,FLAG_READY_SKILL)&&!(RANDOM()%3)) {
506 if(monster_use_skill(op,rv.part,enemy,rv.direction)) 506 if(monster_use_skill(op,rv.part,enemy,rv.direction))
507 return 0; 507 return 0;
508 } 508 }
509 if(QUERY_FLAG(op,FLAG_READY_BOW)&&!(RANDOM()%2)) { 509 if(QUERY_FLAG(op,FLAG_READY_BOW)&&!(RANDOM()%2)) {
510 if(monster_use_bow(op,part,enemy,dir)) 510 if(monster_use_bow(op,part,enemy,dir))
511 return 0; 511 return 0;
512 } 512 }
513 } /* for processing of all parts */ 513 } /* for processing of all parts */
514 } /* If not scared */ 514 } /* If not scared */
515 515
516 516
517 part = rv.part; 517 part = rv.part;
518 dir=rv.direction; 518 dir=rv.direction;
519 519
520 if(QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op,FLAG_RUN_AWAY)) 520 if(QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op,FLAG_RUN_AWAY))
521 dir=absdir(dir+4); 521 dir=absdir(dir+4);
522 522
523 if(QUERY_FLAG(op,FLAG_CONFUSED)) 523 if(QUERY_FLAG(op,FLAG_CONFUSED))
524 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 524 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
525 525
526 pre_att_dir = dir; /* remember the original direction */ 526 pre_att_dir = dir; /* remember the original direction */
527 527
528 if ((op->attack_movement & LO4) && !QUERY_FLAG(op, FLAG_SCARED)) 528 if ((op->attack_movement & LO4) && !QUERY_FLAG(op, FLAG_SCARED))
529 { 529 {
530 switch (op->attack_movement & LO4) { 530 switch (op->attack_movement & LO4) {
531 case DISTATT: 531 case DISTATT:
532 dir = dist_att (dir,op,enemy,part,&rv); 532 dir = dist_att (dir,op,enemy,part,&rv);
533 break; 533 break;
534 534
535 case RUNATT: 535 case RUNATT:
536 dir = run_att (dir,op,enemy,part,&rv); 536 dir = run_att (dir,op,enemy,part,&rv);
537 break; 537 break;
538 538
539 case HITRUN: 539 case HITRUN:
540 dir = hitrun_att(dir,op,enemy); 540 dir = hitrun_att(dir,op,enemy);
541 break; 541 break;
542 542
543 case WAITATT: 543 case WAITATT:
544 dir = wait_att (dir,op,enemy,part,&rv); 544 dir = wait_att (dir,op,enemy,part,&rv);
545 break; 545 break;
546 546
547 case RUSH: /* default - monster normally moves towards player */ 547 case RUSH: /* default - monster normally moves towards player */
548 case ALLRUN: 548 case ALLRUN:
549 break; 549 break;
550 550
551 case DISTHIT: 551 case DISTHIT:
552 dir = disthit_att (dir,op,enemy,part,&rv); 552 dir = disthit_att (dir,op,enemy,part,&rv);
553 break; 553 break;
554 554
555 case WAIT2: 555 case WAIT2:
556 dir = wait_att2 (dir,op,enemy,part,&rv); 556 dir = wait_att2 (dir,op,enemy,part,&rv);
557 break; 557 break;
558 558
559 default: 559 default:
560 LOG(llevDebug,"Illegal low mon-move: %d\n",op->attack_movement & LO4); 560 LOG(llevDebug,"Illegal low mon-move: %d\n",op->attack_movement & LO4);
561 } 561 }
562 } 562 }
563 563
564 if (!dir) 564 if (!dir)
565 return 0; 565 return 0;
566 566
567 if (!QUERY_FLAG(op,FLAG_STAND_STILL)) { 567 if (!QUERY_FLAG(op,FLAG_STAND_STILL)) {
568 if(move_object(op,dir)) /* Can the monster move directly toward player? */ 568 if(move_object(op,dir)) /* Can the monster move directly toward player? */
569 { 569 {
570 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 570 /* elmex: Turn our monster after it moved if it has DISTATT attack */
571 if ((op->attack_movement & LO4) == DISTATT) 571 if ((op->attack_movement & LO4) == DISTATT)
572 op->direction = pre_att_dir; 572 op->direction = pre_att_dir;
573 573
574 return 0; 574 return 0;
575 } 575 }
576 576
577 if(QUERY_FLAG(op, FLAG_SCARED) || !can_hit(part,enemy,&rv) 577 if(QUERY_FLAG(op, FLAG_SCARED) || !can_hit(part,enemy,&rv)
578 || QUERY_FLAG(op,FLAG_RUN_AWAY)) { 578 || QUERY_FLAG(op,FLAG_RUN_AWAY)) {
579 579
580 /* Try move around corners if !close */ 580 /* Try move around corners if !close */
581 int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2; 581 int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2;
582 for(diff = 1; diff <= maxdiff; diff++) { 582 for(diff = 1; diff <= maxdiff; diff++) {
583 /* try different detours */ 583 /* try different detours */
584 int m = 1-(RANDOM()&2); /* Try left or right first? */ 584 int m = 1-(RANDOM()&2); /* Try left or right first? */
585 if(move_object(op,absdir(dir + diff*m)) || 585 if(move_object(op,absdir(dir + diff*m)) ||
586 move_object(op,absdir(dir - diff*m))) 586 move_object(op,absdir(dir - diff*m)))
587 return 0; 587 return 0;
588 } 588 }
589 } 589 }
590 } /* if monster is not standing still */ 590 } /* if monster is not standing still */
591 591
592 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 592 /* elmex: Turn our monster after it moved if it has DISTATT attack */
593 if ((op->attack_movement & LO4) == DISTATT) 593 if ((op->attack_movement & LO4) == DISTATT)
594 op->direction = pre_att_dir; 594 op->direction = pre_att_dir;
… …
596 /* 596 /*
597 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random 597 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
598 * direction if they can't move away. 598 * direction if they can't move away.
599 */ 599 */
600 if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)&&(QUERY_FLAG(op,FLAG_RUN_AWAY)||QUERY_FLAG(op, FLAG_SCARED))) 600 if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)&&(QUERY_FLAG(op,FLAG_RUN_AWAY)||QUERY_FLAG(op, FLAG_SCARED)))
601 if(move_randomly(op)) 601 if(move_randomly(op))
602 return 0; 602 return 0;
603 603
604 /* 604 /*
605 * Try giving the monster a new enemy - the player that is closest 605 * Try giving the monster a new enemy - the player that is closest
606 * to it. In this way, it won't just keep trying to get to a target 606 * to it. In this way, it won't just keep trying to get to a target
607 * that is inaccessible. 607 * that is inaccessible.
… …
612 * the monster could get to - as it is, the monster won't look at that 612 * the monster could get to - as it is, the monster won't look at that
613 * third one. 613 * third one.
614 */ 614 */
615 if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy) 615 if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy)
616 { 616 {
617 object *nearest_player = get_nearest_player(op); 617 object *nearest_player = get_nearest_player(op);
618 if (nearest_player && nearest_player != enemy && !can_hit(part,enemy,&rv)) { 618 if (nearest_player && nearest_player != enemy && !can_hit(part,enemy,&rv)) {
619 op->enemy = NULL; 619 op->enemy = NULL;
620 enemy = nearest_player; 620 enemy = nearest_player;
621 } 621 }
622 } 622 }
623 623
624 if(!QUERY_FLAG(op, FLAG_SCARED)&&can_hit(part,enemy,&rv)) 624 if(!QUERY_FLAG(op, FLAG_SCARED)&&can_hit(part,enemy,&rv))
625 { 625 {
626 /* The adjustement to wc that was here before looked totally bogus - 626 /* The adjustement to wc that was here before looked totally bogus -
627 * since wc can in fact get negative, that would mean by adding 627 * since wc can in fact get negative, that would mean by adding
628 * the current wc, the creature gets better? Instead, just 628 * the current wc, the creature gets better? Instead, just
629 * add a fixed amount - nasty creatures that are runny away should 629 * add a fixed amount - nasty creatures that are runny away should
630 * still be pretty nasty. 630 * still be pretty nasty.
631 */ 631 */
632 if(QUERY_FLAG(op,FLAG_RUN_AWAY)) 632 if(QUERY_FLAG(op,FLAG_RUN_AWAY))
633 { 633 {
634 part->stats.wc+=10; 634 part->stats.wc+=10;
635 (void)skill_attack(enemy,part,0,NULL, NULL); 635 (void)skill_attack(enemy,part,0,NULL, NULL);
636 part->stats.wc-=10; 636 part->stats.wc-=10;
637 } 637 }
638 else 638 else
639 (void)skill_attack(enemy,part,0,NULL, NULL); 639 (void)skill_attack(enemy,part,0,NULL, NULL);
640 } /* if monster is in attack range */ 640 } /* if monster is in attack range */
641 641
642 if(QUERY_FLAG(part,FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */ 642 if(QUERY_FLAG(part,FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
643 return 1; 643 return 1;
644 644
645 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) 645 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK))
646 { 646 {
647 remove_ob(op); 647 remove_ob(op);
648 free_object(op); 648 free_object(op);
649 return 1; 649 return 1;
650 } 650 }
651 return 0; 651 return 0;
652} 652}
653int can_hit(object *ob1,object *ob2, rv_vector *rv) { 653int can_hit(object *ob1,object *ob2, rv_vector *rv) {
654 object *more; 654 object *more;
655 rv_vector rv1; 655 rv_vector rv1;
656 656
657 if(QUERY_FLAG(ob1,FLAG_CONFUSED)&&!(RANDOM()%3)) 657 if(QUERY_FLAG(ob1,FLAG_CONFUSED)&&!(RANDOM()%3))
658 return 0; 658 return 0;
659 659
660 if (abs(rv->distance_x)<2&&abs(rv->distance_y)<2) return 1; 660 if (abs(rv->distance_x)<2&&abs(rv->distance_y)<2) return 1;
661 661
662 /* check all the parts of ob2 - just because we can't get to 662 /* check all the parts of ob2 - just because we can't get to
663 * its head doesn't mean we don't want to pound its feet 663 * its head doesn't mean we don't want to pound its feet
664 */ 664 */
665 for (more = ob2->more; more!=NULL; more = more->more) { 665 for (more = ob2->more; more!=NULL; more = more->more) {
666 get_rangevector(ob1, more, &rv1, 0); 666 get_rangevector(ob1, more, &rv1, 0);
667 if (abs(rv1.distance_x)<2&&abs(rv1.distance_y)<2) return 1; 667 if (abs(rv1.distance_x)<2&&abs(rv1.distance_y)<2) return 1;
668 } 668 }
669 return 0; 669 return 0;
670 670
671} 671}
672 672
… …
687 */ 687 */
688 688
689static int monster_should_cast_spell(object *monster, object *spell_ob) 689static int monster_should_cast_spell(object *monster, object *spell_ob)
690{ 690{
691 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET || 691 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
692 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE || 692 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
693 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE || 693 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE ||
694 spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM || 694 spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM ||
695 spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER || 695 spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER ||
696 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || 696 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM ||
697 spell_ob->subtype == SP_INVISIBLE) 697 spell_ob->subtype == SP_INVISIBLE)
698 698
699 return 1; 699 return 1;
700 700
701 return 0; 701 return 0;
702} 702}
703 703
704 704
… …
713 object *altern[MAX_KNOWN_SPELLS]; 713 object *altern[MAX_KNOWN_SPELLS];
714 object *tmp; 714 object *tmp;
715 int i=0; 715 int i=0;
716 716
717 for(tmp=monster->inv;tmp!=NULL;tmp=tmp->below) 717 for(tmp=monster->inv;tmp!=NULL;tmp=tmp->below)
718 if (tmp->type==SPELLBOOK || tmp->type==SPELL) { 718 if (tmp->type==SPELLBOOK || tmp->type==SPELL) {
719 /* Check and see if it's actually a useful spell. 719 /* Check and see if it's actually a useful spell.
720 * If its a spellbook, the spell is actually the inventory item. 720 * If its a spellbook, the spell is actually the inventory item.
721 * if it is a spell, then it is just the object itself. 721 * if it is a spell, then it is just the object itself.
722 */ 722 */
723 if (monster_should_cast_spell(monster, (tmp->type==SPELLBOOK)?tmp->inv:tmp)) { 723 if (monster_should_cast_spell(monster, (tmp->type==SPELLBOOK)?tmp->inv:tmp)) {
724 altern[i++]=tmp; 724 altern[i++]=tmp;
725 if(i==MAX_KNOWN_SPELLS) 725 if(i==MAX_KNOWN_SPELLS)
726 break; 726 break;
727 } 727 }
728 } 728 }
729 if(!i) 729 if(!i)
730 return NULL; 730 return NULL;
731 return altern[RANDOM()%i]; 731 return altern[RANDOM()%i];
732} 732}
733 733
734/* This checks to see if the monster should cast a spell/ability. 734/* This checks to see if the monster should cast a spell/ability.
735 * it returns true if the monster casts a spell, 0 if he doesn't. 735 * it returns true if the monster casts a spell, 0 if he doesn't.
… …
753 */ 753 */
754 if(!(dir=path_to_player(part,pl,0))) 754 if(!(dir=path_to_player(part,pl,0)))
755 return 0; 755 return 0;
756 756
757 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 757 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
758 get_rangevector(head, owner, &rv1, 0x1); 758 get_rangevector(head, owner, &rv1, 0x1);
759 if(dirdiff(dir,rv1.direction) < 2) { 759 if(dirdiff(dir,rv1.direction) < 2) {
760 return 0; /* Might hit owner with spell */ 760 return 0; /* Might hit owner with spell */
761 } 761 }
762 } 762 }
763 763
764 if(QUERY_FLAG(head,FLAG_CONFUSED)) 764 if(QUERY_FLAG(head,FLAG_CONFUSED))
765 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 765 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
766 766
767 /* If the monster hasn't already chosen a spell, choose one 767 /* If the monster hasn't already chosen a spell, choose one
768 * I'm not sure if it really make sense to pre-select spells (events 768 * I'm not sure if it really make sense to pre-select spells (events
769 * could be different by the time the monster goes again). 769 * could be different by the time the monster goes again).
770 */ 770 */
771 if(head->spellitem==NULL) { 771 if(head->spellitem==NULL) {
772 if((spell_item=monster_choose_random_spell(head))==NULL) { 772 if((spell_item=monster_choose_random_spell(head))==NULL) {
773 LOG(llevMonster,"Turned off spells in %s\n",head->name); 773 LOG(llevMonster,"Turned off spells in %s\n",head->name);
774 CLEAR_FLAG(head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */ 774 CLEAR_FLAG(head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
775 return 0; 775 return 0;
776 } 776 }
777 if (spell_item->type == SPELLBOOK) { 777 if (spell_item->type == SPELLBOOK) {
778 if (!spell_item->inv) { 778 if (!spell_item->inv) {
779 LOG(llevError,"spellbook %s does not contain a spell?\n", spell_item->name); 779 LOG(llevError,"spellbook %s does not contain a spell?\n", spell_item->name);
780 return 0; 780 return 0;
781 } 781 }
782 spell_item=spell_item->inv; 782 spell_item=spell_item->inv;
783 } 783 }
784 } 784 }
785 else 785 else
786 spell_item=head->spellitem; 786 spell_item=head->spellitem;
787 787
788 if (!spell_item) return 0; 788 if (!spell_item) return 0;
789 789
790 /* Best guess this is a defensive/healing spell */ 790 /* Best guess this is a defensive/healing spell */
791 if (spell_item->range<=1 || spell_item->stats.dam < 0) 791 if (spell_item->range<=1 || spell_item->stats.dam < 0)
792 dir = 0; 792 dir = 0;
793 793
794 /* Monster doesn't have enough spell-points */ 794 /* Monster doesn't have enough spell-points */
795 if(head->stats.sp<SP_level_spellpoint_cost(head,spell_item, SPELL_MANA)) 795 if(head->stats.sp<SP_level_spellpoint_cost(head,spell_item, SPELL_MANA))
796 return 0; 796 return 0;
797 797
798 if(head->stats.grace<SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE)) 798 if(head->stats.grace<SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE))
799 return 0; 799 return 0;
800 800
801 head->stats.sp-=SP_level_spellpoint_cost(head,spell_item, SPELL_MANA); 801 head->stats.sp-=SP_level_spellpoint_cost(head,spell_item, SPELL_MANA);
802 head->stats.grace-=SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE); 802 head->stats.grace-=SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE);
803 803
804 /* set this to null, so next time monster will choose something different */ 804 /* set this to null, so next time monster will choose something different */
… …
821 */ 821 */
822 if(!(dir=path_to_player(part,pl,0))) 822 if(!(dir=path_to_player(part,pl,0)))
823 return 0; 823 return 0;
824 824
825 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 825 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
826 get_rangevector(head, owner, &rv1, 0x1); 826 get_rangevector(head, owner, &rv1, 0x1);
827 if(dirdiff(dir,rv1.direction) < 2) { 827 if(dirdiff(dir,rv1.direction) < 2) {
828 return 0; /* Might hit owner with spell */ 828 return 0; /* Might hit owner with spell */
829 } 829 }
830 } 830 }
831 831
832 if(QUERY_FLAG(head,FLAG_CONFUSED)) 832 if(QUERY_FLAG(head,FLAG_CONFUSED))
833 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 833 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
834 834
835 for (scroll=head->inv; scroll; scroll=scroll->below) 835 for (scroll=head->inv; scroll; scroll=scroll->below)
836 if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv)) break; 836 if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv)) break;
837 837
838 /* Used up all his scrolls, so nothing do to */ 838 /* Used up all his scrolls, so nothing do to */
839 if (!scroll) { 839 if (!scroll) {
840 CLEAR_FLAG(head, FLAG_READY_SCROLL); 840 CLEAR_FLAG(head, FLAG_READY_SCROLL);
841 return 0; 841 return 0;
842 } 842 }
843 843
844 /* Spell should be cast on caster (ie, heal, strength) */ 844 /* Spell should be cast on caster (ie, heal, strength) */
845 if (scroll->inv->range==0) 845 if (scroll->inv->range==0)
846 dir = 0; 846 dir = 0;
847 847
848 apply_scroll(part, scroll, dir); 848 apply_scroll(part, scroll, dir);
849 return 1; 849 return 1;
850} 850}
851 851
… …
863 863
864int monster_use_skill(object *head, object *part, object *pl,int dir) { 864int monster_use_skill(object *head, object *part, object *pl,int dir) {
865 object *skill, *owner; 865 object *skill, *owner;
866 866
867 if(!(dir=path_to_player(part,pl,0))) 867 if(!(dir=path_to_player(part,pl,0)))
868 return 0; 868 return 0;
869 869
870 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 870 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
871 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 871 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
872 if(dirdiff(dir,dir2) < 1) 872 if(dirdiff(dir,dir2) < 1)
873 return 0; /* Might hit owner with skill -thrown rocks for example ?*/ 873 return 0; /* Might hit owner with skill -thrown rocks for example ?*/
874 } 874 }
875 if(QUERY_FLAG(head,FLAG_CONFUSED)) 875 if(QUERY_FLAG(head,FLAG_CONFUSED))
876 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 876 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
877 877
878 /* skill selection - monster will use the next unused skill. 878 /* skill selection - monster will use the next unused skill.
879 * well...the following scenario will allow the monster to 879 * well...the following scenario will allow the monster to
880 * toggle between 2 skills. One day it would be nice to make 880 * toggle between 2 skills. One day it would be nice to make
881 * more skills available to monsters. 881 * more skills available to monsters.
882 */ 882 */
883 883
884 for(skill=head->inv;skill!=NULL;skill=skill->below) 884 for(skill=head->inv;skill!=NULL;skill=skill->below)
885 if(skill->type==SKILL && skill!=head->chosen_skill) { 885 if(skill->type==SKILL && skill!=head->chosen_skill) {
886 head->chosen_skill=skill; 886 head->chosen_skill=skill;
887 break; 887 break;
888 } 888 }
889 889
890 if(!skill && !head->chosen_skill) { 890 if(!skill && !head->chosen_skill) {
891 LOG(llevDebug,"Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", 891 LOG(llevDebug,"Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n",
892 head->name,head->count); 892 head->name,head->count);
893 CLEAR_FLAG(head, FLAG_READY_SKILL); 893 CLEAR_FLAG(head, FLAG_READY_SKILL);
894 return 0; 894 return 0;
895 } 895 }
896 /* use skill */ 896 /* use skill */
897 return do_skill(head, part, head->chosen_skill,dir,NULL); 897 return do_skill(head, part, head->chosen_skill,dir,NULL);
898} 898}
899 899
… …
903 { 903 {
904 object *wand, *owner; 904 object *wand, *owner;
905 int at_least_one = 0; 905 int at_least_one = 0;
906 906
907 if(!(dir=path_to_player(part,pl,0))) 907 if(!(dir=path_to_player(part,pl,0)))
908 return 0; 908 return 0;
909 909
910 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 910 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
911 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 911 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
912 if(dirdiff(dir,dir2) < 2) 912 if(dirdiff(dir,dir2) < 2)
913 return 0; /* Might hit owner with spell */ 913 return 0; /* Might hit owner with spell */
914 } 914 }
915 if(QUERY_FLAG(head,FLAG_CONFUSED)) 915 if(QUERY_FLAG(head,FLAG_CONFUSED))
916 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 916 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
917 917
918 for(wand=head->inv;wand!=NULL;wand=wand->below) 918 for(wand=head->inv;wand!=NULL;wand=wand->below)
919 { 919 {
920 if (wand->type == WAND) 920 if (wand->type == WAND)
921 { 921 {
922 /* Found a wand, let's see if it has charges left */ 922 /* Found a wand, let's see if it has charges left */
923 at_least_one = 1; 923 at_least_one = 1;
924 if( wand->stats.food<=0 ) 924 if( wand->stats.food<=0 )
925 continue; 925 continue;
926 926
927 cast_spell( head, wand, dir, wand->inv, NULL ); 927 cast_spell( head, wand, dir, wand->inv, NULL );
928 928
929 if ( !( --wand->stats.food ) ) 929 if ( !( --wand->stats.food ) )
930 { 930 {
931 if ( wand->arch ) 931 if ( wand->arch )
932 { 932 {
933 CLEAR_FLAG(wand, FLAG_ANIMATE); 933 CLEAR_FLAG(wand, FLAG_ANIMATE);
934 wand->face = wand->arch->clone.face; 934 wand->face = wand->arch->clone.face;
935 wand->speed = 0; 935 wand->speed = 0;
936 update_ob_speed(wand); 936 update_ob_speed(wand);
937 } 937 }
938 } 938 }
939 /* Success */ 939 /* Success */
940 return 1; 940 return 1;
941 } 941 }
942 else if ( wand->type == ROD || wand->type==HORN ) { 942 else if ( wand->type == ROD || wand->type==HORN ) {
943 /* Found rod/horn, let's use it if possible */ 943 /* Found rod/horn, let's use it if possible */
944 at_least_one = 1; 944 at_least_one = 1;
945 if( wand->stats.hp < MAX( wand->inv->stats.sp, wand->inv->stats.grace ) ) 945 if( wand->stats.hp < MAX( wand->inv->stats.sp, wand->inv->stats.grace ) )
946 continue; 946 continue;
947 947
948 /* drain charge before casting spell - can be a case where the 948 /* drain charge before casting spell - can be a case where the
949 * spell destroys the monster, and rod, so if done after, results 949 * spell destroys the monster, and rod, so if done after, results
950 * in crash. 950 * in crash.
951 */ 951 */
952 drain_rod_charge( wand ); 952 drain_rod_charge( wand );
953 cast_spell( head, wand, dir, wand->inv, NULL ); 953 cast_spell( head, wand, dir, wand->inv, NULL );
954 954
955 /* Success */ 955 /* Success */
956 return 1; 956 return 1;
957 } 957 }
… …
960 if ( at_least_one ) 960 if ( at_least_one )
961 return 0; 961 return 0;
962 962
963 LOG(llevError,"Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", 963 LOG(llevError,"Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n",
964 head->name,head->count); 964 head->name,head->count);
965 CLEAR_FLAG(head, FLAG_READY_RANGE); 965 CLEAR_FLAG(head, FLAG_READY_RANGE);
966 return 0; 966 return 0;
967 } 967 }
968 968
969int monster_use_bow(object *head, object *part, object *pl, int dir) { 969int monster_use_bow(object *head, object *part, object *pl, int dir) {
970 object *owner; 970 object *owner;
971 971
972 if(!(dir=path_to_player(part,pl,0))) 972 if(!(dir=path_to_player(part,pl,0)))
973 return 0; 973 return 0;
974 if(QUERY_FLAG(head,FLAG_CONFUSED)) 974 if(QUERY_FLAG(head,FLAG_CONFUSED))
975 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 975 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
976 976
977 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 977 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
978 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 978 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
979 if(dirdiff(dir,dir2) < 1) 979 if(dirdiff(dir,dir2) < 1)
980 return 0; /* Might hit owner with arrow */ 980 return 0; /* Might hit owner with arrow */
981 } 981 }
982 982
983 /* in server/player.c */ 983 /* in server/player.c */
984 return fire_bow(head, part, NULL, dir, 0, part->x, part->y); 984 return fire_bow(head, part, NULL, dir, 0, part->x, part->y);
985 985
… …
995int check_good_weapon(object *who, object *item) { 995int check_good_weapon(object *who, object *item) {
996 object *other_weap; 996 object *other_weap;
997 int val=0, i; 997 int val=0, i;
998 998
999 for(other_weap=who->inv;other_weap!=NULL;other_weap=other_weap->below) 999 for(other_weap=who->inv;other_weap!=NULL;other_weap=other_weap->below)
1000 if(other_weap->type==item->type&&QUERY_FLAG(other_weap,FLAG_APPLIED)) 1000 if(other_weap->type==item->type&&QUERY_FLAG(other_weap,FLAG_APPLIED))
1001 break; 1001 break;
1002 1002
1003 if(other_weap==NULL) /* No other weapons */ 1003 if(other_weap==NULL) /* No other weapons */
1004 return 1; 1004 return 1;
1005 1005
1006 /* Rather than go through and apply the new one, and see if it is 1006 /* Rather than go through and apply the new one, and see if it is
1007 * better, just do some simple checks 1007 * better, just do some simple checks
1008 * Put some multipliers for things that hvae several effects, 1008 * Put some multipliers for things that hvae several effects,
1009 * eg, magic affects both damage and wc, so it has more weight 1009 * eg, magic affects both damage and wc, so it has more weight
… …
1013 val += (item->magic - other_weap->magic) * 3; 1013 val += (item->magic - other_weap->magic) * 3;
1014 /* Monsters don't really get benefits from things like regen rates 1014 /* Monsters don't really get benefits from things like regen rates
1015 * from items. But the bonus for their stats are very important. 1015 * from items. But the bonus for their stats are very important.
1016 */ 1016 */
1017 for (i=0; i<NUM_STATS; i++) 1017 for (i=0; i<NUM_STATS; i++)
1018 val += (get_attr_value(&item->stats, i) - get_attr_value(&other_weap->stats, i))*2; 1018 val += (get_attr_value(&item->stats, i) - get_attr_value(&other_weap->stats, i))*2;
1019 1019
1020 if (val > 0) return 1; 1020 if (val > 0) return 1;
1021 else return 0; 1021 else return 0;
1022 1022
1023} 1023}
… …
1025int check_good_armour(object *who, object *item) { 1025int check_good_armour(object *who, object *item) {
1026 object *other_armour; 1026 object *other_armour;
1027 int val=0,i; 1027 int val=0,i;
1028 1028
1029 for (other_armour = who->inv; other_armour != NULL; 1029 for (other_armour = who->inv; other_armour != NULL;
1030 other_armour = other_armour->below) 1030 other_armour = other_armour->below)
1031 if (other_armour->type == item->type && QUERY_FLAG(other_armour,FLAG_APPLIED)) 1031 if (other_armour->type == item->type && QUERY_FLAG(other_armour,FLAG_APPLIED))
1032 break; 1032 break;
1033 1033
1034 if (other_armour == NULL) /* No other armour, use the new */ 1034 if (other_armour == NULL) /* No other armour, use the new */
1035 return 1; 1035 return 1;
1036 1036
1037 /* Like above function , see which is better */ 1037 /* Like above function , see which is better */
1038 val = item->stats.ac - other_armour->stats.ac; 1038 val = item->stats.ac - other_armour->stats.ac;
1039 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL])/5; 1039 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL])/5;
1040 val += (item->magic - other_armour->magic) * 3; 1040 val += (item->magic - other_armour->magic) * 3;
… …
1044 * no good way to know what the player may attack the monster with. 1044 * no good way to know what the player may attack the monster with.
1045 * So if the new item has better protection than the old, give that higher 1045 * So if the new item has better protection than the old, give that higher
1046 * value. If the reverse, then decrease the value of this item some. 1046 * value. If the reverse, then decrease the value of this item some.
1047 */ 1047 */
1048 for (i=1; i <NROFATTACKS; i++) { 1048 for (i=1; i <NROFATTACKS; i++) {
1049 if (item->resist[i] > other_armour->resist[i]) val++; 1049 if (item->resist[i] > other_armour->resist[i]) val++;
1050 else if (item->resist[i] < other_armour->resist[i]) val--; 1050 else if (item->resist[i] < other_armour->resist[i]) val--;
1051 } 1051 }
1052 1052
1053 /* Very few armours have stats, so not much need to worry about those. */ 1053 /* Very few armours have stats, so not much need to worry about those. */
1054 1054
1055 if (val > 0) return 1; 1055 if (val > 0) return 1;
… …
1076void monster_check_pickup(object *monster) { 1076void monster_check_pickup(object *monster) {
1077 object *tmp,*next; 1077 object *tmp,*next;
1078 int next_tag; 1078 int next_tag;
1079 1079
1080 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1080 for(tmp=monster->below;tmp!=NULL;tmp=next) {
1081 next=tmp->below; 1081 next=tmp->below;
1082 next_tag = next ? next->count : 0; 1082 next_tag = next ? next->count : 0;
1083 if (monster_can_pick(monster,tmp)) { 1083 if (monster_can_pick(monster,tmp)) {
1084 remove_ob(tmp); 1084 remove_ob(tmp);
1085 tmp = insert_ob_in_ob(tmp,monster); 1085 tmp = insert_ob_in_ob(tmp,monster);
1086 (void) monster_check_apply(monster,tmp); 1086 (void) monster_check_apply(monster,tmp);
1087 } 1087 }
1088 /* We could try to re-establish the cycling, of the space, but probably 1088 /* We could try to re-establish the cycling, of the space, but probably
1089 * not a big deal to just bail out. 1089 * not a big deal to just bail out.
1090 */ 1090 */
1091 if (next && was_destroyed(next, next_tag)) return; 1091 if (next && was_destroyed(next, next_tag)) return;
1092 } 1092 }
1093} 1093}
1094 1094
1095/* 1095/*
1096 * monster_can_pick(): If the monster is interested in picking up 1096 * monster_can_pick(): If the monster is interested in picking up
… …
1102int monster_can_pick(object *monster, object *item) { 1102int monster_can_pick(object *monster, object *item) {
1103 int flag=0; 1103 int flag=0;
1104 int i; 1104 int i;
1105 1105
1106 if(!can_pick(monster,item)) 1106 if(!can_pick(monster,item))
1107 return 0; 1107 return 0;
1108 1108
1109 if(QUERY_FLAG(item,FLAG_UNPAID)) 1109 if(QUERY_FLAG(item,FLAG_UNPAID))
1110 return 0; 1110 return 0;
1111 1111
1112 if (monster->pick_up&64) /* All */ 1112 if (monster->pick_up&64) /* All */
1113 flag=1; 1113 flag=1;
1114 1114
1115 else switch(item->type) { 1115 else switch(item->type) {
1116 case MONEY: 1116 case MONEY:
1117 case GEM: 1117 case GEM:
1118 flag=monster->pick_up&2; 1118 flag=monster->pick_up&2;
1119 break; 1119 break;
1120 1120
1121 case FOOD: 1121 case FOOD:
1122 flag=monster->pick_up&4; 1122 flag=monster->pick_up&4;
1123 break; 1123 break;
1124 1124
1125 case WEAPON: 1125 case WEAPON:
1126 flag=(monster->pick_up&8)||QUERY_FLAG(monster,FLAG_USE_WEAPON); 1126 flag=(monster->pick_up&8)||QUERY_FLAG(monster,FLAG_USE_WEAPON);
1127 break; 1127 break;
1128 1128
1129 case ARMOUR: 1129 case ARMOUR:
1130 case SHIELD: 1130 case SHIELD:
1131 case HELMET: 1131 case HELMET:
1132 case BOOTS: 1132 case BOOTS:
1133 case GLOVES: 1133 case GLOVES:
1134 case GIRDLE: 1134 case GIRDLE:
1135 flag=(monster->pick_up&16)||QUERY_FLAG(monster,FLAG_USE_ARMOUR); 1135 flag=(monster->pick_up&16)||QUERY_FLAG(monster,FLAG_USE_ARMOUR);
1136 break; 1136 break;
1137 1137
1138 case SKILL: 1138 case SKILL:
1139 flag=QUERY_FLAG(monster,FLAG_CAN_USE_SKILL); 1139 flag=QUERY_FLAG(monster,FLAG_CAN_USE_SKILL);
1140 break; 1140 break;
1141 1141
1142 case RING: 1142 case RING:
1143 flag=QUERY_FLAG(monster,FLAG_USE_RING); 1143 flag=QUERY_FLAG(monster,FLAG_USE_RING);
1144 break; 1144 break;
1145 1145
1146 case WAND: 1146 case WAND:
1147 case HORN: 1147 case HORN:
1148 case ROD: 1148 case ROD:
1149 flag=QUERY_FLAG(monster,FLAG_USE_RANGE); 1149 flag=QUERY_FLAG(monster,FLAG_USE_RANGE);
1150 break; 1150 break;
1151 1151
1152 case SPELLBOOK: 1152 case SPELLBOOK:
1153 flag=(monster->arch!=NULL&&QUERY_FLAG((&monster->arch->clone),FLAG_CAST_SPELL)); 1153 flag=(monster->arch!=NULL&&QUERY_FLAG((&monster->arch->clone),FLAG_CAST_SPELL));
1154 break; 1154 break;
1155 1155
1156 case SCROLL: 1156 case SCROLL:
1157 flag = QUERY_FLAG(monster,FLAG_USE_SCROLL); 1157 flag = QUERY_FLAG(monster,FLAG_USE_SCROLL);
1158 break; 1158 break;
1159 1159
1160 case BOW: 1160 case BOW:
1161 case ARROW: 1161 case ARROW:
1162 flag=QUERY_FLAG(monster,FLAG_USE_BOW); 1162 flag=QUERY_FLAG(monster,FLAG_USE_BOW);
1163 break; 1163 break;
1164 } 1164 }
1165 /* Simplistic check - if the monster has a location to equip it, he will 1165 /* Simplistic check - if the monster has a location to equip it, he will
1166 * pick it up. Note that this doesn't handle cases where an item may 1166 * pick it up. Note that this doesn't handle cases where an item may
1167 * use several locations. 1167 * use several locations.
1168 */ 1168 */
1169 for (i=0; i < NUM_BODY_LOCATIONS; i++) { 1169 for (i=0; i < NUM_BODY_LOCATIONS; i++) {
1170 if (monster->body_info[i] && item->body_info[i]) { 1170 if (monster->body_info[i] && item->body_info[i]) {
1171 flag=1; 1171 flag=1;
1172 break; 1172 break;
1173 } 1173 }
1174 } 1174 }
1175 1175
1176 if (((!(monster->pick_up&32))&&flag) || ((monster->pick_up&32)&&(!flag))) 1176 if (((!(monster->pick_up&32))&&flag) || ((monster->pick_up&32)&&(!flag)))
1177 return 1; 1177 return 1;
1178 return 0; 1178 return 0;
1179} 1179}
1180 1180
1181/* 1181/*
1182 * monster_apply_below(): 1182 * monster_apply_below():
… …
1187 1187
1188void monster_apply_below(object *monster) { 1188void monster_apply_below(object *monster) {
1189 object *tmp, *next; 1189 object *tmp, *next;
1190 1190
1191 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1191 for(tmp=monster->below;tmp!=NULL;tmp=next) {
1192 next=tmp->below; 1192 next=tmp->below;
1193 switch (tmp->type) { 1193 switch (tmp->type) {
1194 case CF_HANDLE: 1194 case CF_HANDLE:
1195 case TRIGGER: 1195 case TRIGGER:
1196 if (monster->will_apply&1) 1196 if (monster->will_apply&1)
1197 manual_apply(monster,tmp,0); 1197 manual_apply(monster,tmp,0);
1198 break; 1198 break;
1199 1199
1200 case TREASURE: 1200 case TREASURE:
1201 if (monster->will_apply&2) 1201 if (monster->will_apply&2)
1202 manual_apply(monster,tmp,0); 1202 manual_apply(monster,tmp,0);
1203 break; 1203 break;
1204 1204
1205 } 1205 }
1206 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1206 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1207 break; 1207 break;
1208 } 1208 }
1209} 1209}
1210 1210
1211/* 1211/*
1212 * monster_check_apply() is meant to be called after an item is 1212 * monster_check_apply() is meant to be called after an item is
… …
1224 1224
1225 int flag = 0; 1225 int flag = 0;
1226 1226
1227 if(item->type==SPELLBOOK&& 1227 if(item->type==SPELLBOOK&&
1228 mon->arch!=NULL&&(QUERY_FLAG((&mon->arch->clone),FLAG_CAST_SPELL))) { 1228 mon->arch!=NULL&&(QUERY_FLAG((&mon->arch->clone),FLAG_CAST_SPELL))) {
1229 SET_FLAG(mon, FLAG_CAST_SPELL); 1229 SET_FLAG(mon, FLAG_CAST_SPELL);
1230 return; 1230 return;
1231 } 1231 }
1232 1232
1233 /* If for some reason, this item is already applied, no more work to do */ 1233 /* If for some reason, this item is already applied, no more work to do */
1234 if(QUERY_FLAG(item,FLAG_APPLIED)) return; 1234 if(QUERY_FLAG(item,FLAG_APPLIED)) return;
1235 1235
1236 /* Might be better not to do this - if the monster can fire a bow, 1236 /* Might be better not to do this - if the monster can fire a bow,
1237 * it is possible in his wanderings, he will find one to use. In 1237 * it is possible in his wanderings, he will find one to use. In
1238 * which case, it would be nice to have ammo for it. 1238 * which case, it would be nice to have ammo for it.
1239 */ 1239 */
1240 if(QUERY_FLAG(mon,FLAG_USE_BOW) && item->type==ARROW) { 1240 if(QUERY_FLAG(mon,FLAG_USE_BOW) && item->type==ARROW) {
1241 /* Check for the right kind of bow */ 1241 /* Check for the right kind of bow */
1242 object *bow; 1242 object *bow;
1243 for(bow=mon->inv;bow!=NULL;bow=bow->below) 1243 for(bow=mon->inv;bow!=NULL;bow=bow->below)
1244 if(bow->type==BOW && bow->race==item->race) { 1244 if(bow->type==BOW && bow->race==item->race) {
1245 SET_FLAG(mon, FLAG_READY_BOW); 1245 SET_FLAG(mon, FLAG_READY_BOW);
1246 LOG(llevMonster,"Found correct bow for arrows.\n"); 1246 LOG(llevMonster,"Found correct bow for arrows.\n");
1247 return; /* nothing more to do for arrows */ 1247 return; /* nothing more to do for arrows */
1248 } 1248 }
1249 } 1249 }
1250 1250
1251 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE) flag=1; 1251 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE) flag=1;
1252 /* Eating food gets hp back */ 1252 /* Eating food gets hp back */
1253 else if (item->type == FOOD && mon->will_apply & WILL_APPLY_FOOD) flag=1; 1253 else if (item->type == FOOD && mon->will_apply & WILL_APPLY_FOOD) flag=1;
… …
1264 /* Should do something more, like make sure this is a better item */ 1264 /* Should do something more, like make sure this is a better item */
1265 else if (item->type == RING) 1265 else if (item->type == RING)
1266 flag=1; 1266 flag=1;
1267 else if ( item->type==WAND || item->type == ROD || item->type==HORN ) 1267 else if ( item->type==WAND || item->type == ROD || item->type==HORN )
1268 { 1268 {
1269 /* We never really 'ready' the wand/rod/horn, because that would mean the 1269 /* We never really 'ready' the wand/rod/horn, because that would mean the
1270 * weapon would get undone. 1270 * weapon would get undone.
1271 */ 1271 */
1272 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK)) 1272 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1273 { 1273 {
1274 SET_FLAG(mon, FLAG_READY_RANGE); 1274 SET_FLAG(mon, FLAG_READY_RANGE);
1275 SET_FLAG(item, FLAG_APPLIED); 1275 SET_FLAG(item, FLAG_APPLIED);
1276 } 1276 }
1277 return; 1277 return;
1278 } 1278 }
1279 else if (item->type == BOW) { 1279 else if (item->type == BOW) {
1280 /* We never really 'ready' the bow, because that would mean the 1280 /* We never really 'ready' the bow, because that would mean the
1281 * weapon would get undone. 1281 * weapon would get undone.
1282 */ 1282 */
1283 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK)) 1283 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1284 SET_FLAG(mon, FLAG_READY_BOW); 1284 SET_FLAG(mon, FLAG_READY_BOW);
1285 return; 1285 return;
1286 } 1286 }
1287 else if ( item->type == SKILL ) 1287 else if ( item->type == SKILL )
1288 { 1288 {
1289 /* 1289 /*
1290 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set, 1290 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set,
… …
1323 object *npc; 1323 object *npc;
1324 sint16 sx, sy; 1324 sint16 sx, sy;
1325 mapstruct *m; 1325 mapstruct *m;
1326 1326
1327 for(x = -3; x < 4; x++) 1327 for(x = -3; x < 4; x++)
1328 for(y = -3; y < 4; y++) { 1328 for(y = -3; y < 4; y++) {
1329 m = op->map; 1329 m = op->map;
1330 sx = op->x + x; 1330 sx = op->x + x;
1331 sy = op->y + y; 1331 sy = op->y + y;
1332 mflags = get_map_flags(m, &m, sx, sy, &sx, &sy); 1332 mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);
1333 /* If nothing alive on this space, no need to search the space. */ 1333 /* If nothing alive on this space, no need to search the space. */
1334 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE)) 1334 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE))
1335 continue; 1335 continue;
1336 1336
1337 for(npc = get_map_ob(m,sx,sy);npc!=NULL;npc=npc->above) 1337 for(npc = get_map_ob(m,sx,sy);npc!=NULL;npc=npc->above)
1338 if(QUERY_FLAG(npc, FLAG_ALIVE)&&QUERY_FLAG(npc, FLAG_UNAGGRESSIVE)) 1338 if(QUERY_FLAG(npc, FLAG_ALIVE)&&QUERY_FLAG(npc, FLAG_UNAGGRESSIVE))
1339 npc->enemy = op->enemy; 1339 npc->enemy = op->enemy;
1340 } 1340 }
1341} 1341}
1342 1342
1343 1343
1344int dist_att (int dir , object *ob, object *enemy, object *part, rv_vector *rv) { 1344int dist_att (int dir , object *ob, object *enemy, object *part, rv_vector *rv) {
1345 1345
… …
1353} 1353}
1354 1354
1355int run_att (int dir, object *ob, object *enemy,object *part, rv_vector *rv) { 1355int run_att (int dir, object *ob, object *enemy,object *part, rv_vector *rv) {
1356 1356
1357 if ((can_hit (part,enemy,rv) && ob->move_status <20) || ob->move_status <20) { 1357 if ((can_hit (part,enemy,rv) && ob->move_status <20) || ob->move_status <20) {
1358 ob->move_status++; 1358 ob->move_status++;
1359 return (dir); 1359 return (dir);
1360 } 1360 }
1361 else if (ob->move_status >20) 1361 else if (ob->move_status >20)
1362 ob->move_status = 0; 1362 ob->move_status = 0;
1363 return absdir (dir+4); 1363 return absdir (dir+4);
1364} 1364}
1365 1365
1366int hitrun_att (int dir, object *ob,object *enemy) { 1366int hitrun_att (int dir, object *ob,object *enemy) {
1367 if (ob->move_status ++ < 25) 1367 if (ob->move_status ++ < 25)
1368 return dir; 1368 return dir;
1369 else if (ob->move_status <50) 1369 else if (ob->move_status <50)
1370 return absdir (dir+4); 1370 return absdir (dir+4);
1371 else 1371 else
1372 ob->move_status = 0; 1372 ob->move_status = 0;
1373 return absdir(dir+4); 1373 return absdir(dir+4);
1374} 1374}
1375 1375
1376int wait_att (int dir, object *ob,object *enemy,object *part,rv_vector *rv) { 1376int wait_att (int dir, object *ob,object *enemy,object *part,rv_vector *rv) {
1377 1377
1378 int inrange = can_hit (part, enemy,rv); 1378 int inrange = can_hit (part, enemy,rv);
1379 1379
1380 if (ob->move_status || inrange) 1380 if (ob->move_status || inrange)
1381 ob->move_status++; 1381 ob->move_status++;
1382 1382
1383 if (ob->move_status == 0) 1383 if (ob->move_status == 0)
1384 return 0; 1384 return 0;
1385 else if (ob->move_status <10) 1385 else if (ob->move_status <10)
1386 return dir; 1386 return dir;
1387 else if (ob->move_status <15) 1387 else if (ob->move_status <15)
1388 return absdir(dir+4); 1388 return absdir(dir+4);
1389 ob->move_status = 0; 1389 ob->move_status = 0;
1390 return 0; 1390 return 0;
1391} 1391}
1392 1392
1393int disthit_att (int dir, object *ob, object *enemy, object *part,rv_vector *rv) { 1393int disthit_att (int dir, object *ob, object *enemy, object *part,rv_vector *rv) {
… …
1398 * I think its wrong for a creature to have a zero maxhp value, but 1398 * I think its wrong for a creature to have a zero maxhp value, but
1399 * at least one map has this set, and whatever the map contains, the 1399 * at least one map has this set, and whatever the map contains, the
1400 * server should try to be resilant enough to avoid the problem 1400 * server should try to be resilant enough to avoid the problem
1401 */ 1401 */
1402 if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away) 1402 if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away)
1403 return absdir(dir+4); 1403 return absdir(dir+4);
1404 return dist_att (dir,ob,enemy,part,rv); 1404 return dist_att (dir,ob,enemy,part,rv);
1405} 1405}
1406 1406
1407int wait_att2 (int dir, object *ob,object *enemy,object *part, rv_vector *rv) { 1407int wait_att2 (int dir, object *ob,object *enemy,object *part, rv_vector *rv) {
1408 if (rv->distance < 9) 1408 if (rv->distance < 9)
1409 return absdir (dir+4); 1409 return absdir (dir+4);
1410 return 0; 1410 return 0;
1411} 1411}
1412 1412
1413void circ1_move (object *ob) { 1413void circ1_move (object *ob) {
1414 static int circle [12] = {3,3,4,5,5,6,7,7,8,1,1,2}; 1414 static int circle [12] = {3,3,4,5,5,6,7,7,8,1,1,2};
… …
1478} 1478}
1479 1479
1480void check_earthwalls(object *op, mapstruct *m, int x, int y) { 1480void check_earthwalls(object *op, mapstruct *m, int x, int y) {
1481 object *tmp; 1481 object *tmp;
1482 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1482 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
1483 if (tmp->type == EARTHWALL) { 1483 if (tmp->type == EARTHWALL) {
1484 hit_player(tmp,op->stats.dam,op,AT_PHYSICAL,1); 1484 hit_player(tmp,op->stats.dam,op,AT_PHYSICAL,1);
1485 return; 1485 return;
1486 } 1486 }
1487 } 1487 }
1488} 1488}
1489 1489
1490void check_doors(object *op, mapstruct *m, int x, int y) { 1490void check_doors(object *op, mapstruct *m, int x, int y) {
1491 object *tmp; 1491 object *tmp;
1492 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1492 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
1493 if (tmp->type == DOOR) { 1493 if (tmp->type == DOOR) {
1494 hit_player(tmp,1000,op,AT_PHYSICAL,1); 1494 hit_player(tmp,1000,op,AT_PHYSICAL,1);
1495 return; 1495 return;
1496 } 1496 }
1497 } 1497 }
1498} 1498}
1499 1499
1500/* find_mon_throw_ob() - modeled on find_throw_ob 1500/* find_mon_throw_ob() - modeled on find_throw_ob
1501 * This is probably overly simplistic as it is now - We want 1501 * This is probably overly simplistic as it is now - We want
… …
1514 * marked item and throw it to the enemy. 1514 * marked item and throw it to the enemy.
1515 */ 1515 */
1516 1516
1517 for(tmp=op->inv;tmp;tmp=tmp->below) { 1517 for(tmp=op->inv;tmp;tmp=tmp->below) {
1518 1518
1519 /* Can't throw invisible objects or items that are applied */ 1519 /* Can't throw invisible objects or items that are applied */
1520 if(tmp->invisible || QUERY_FLAG(tmp,FLAG_APPLIED)) continue; 1520 if(tmp->invisible || QUERY_FLAG(tmp,FLAG_APPLIED)) continue;
1521 1521
1522 if(QUERY_FLAG(tmp,FLAG_IS_THROWN)) 1522 if(QUERY_FLAG(tmp,FLAG_IS_THROWN))
1523 break; 1523 break;
1524 1524
1525 } 1525 }
1526 1526
1527#ifdef DEBUG_THROW 1527#ifdef DEBUG_THROW
1528 LOG(llevDebug,"%s chooses to throw: %s (%d)\n",op->name, 1528 LOG(llevDebug,"%s chooses to throw: %s (%d)\n",op->name,
1529 !(tmp)?"(nothing)":query_name(tmp),tmp?tmp->count:-1); 1529 !(tmp)?"(nothing)":query_name(tmp),tmp?tmp->count:-1);
1530#endif 1530#endif
1531 1531
1532 return tmp; 1532 return tmp;
1533} 1533}
1534 1534
… …
1569 1569
1570 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE 1570 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1571 * flag (which was already checked) in can_see_enmy (). Lets get out of here 1571 * flag (which was already checked) in can_see_enmy (). Lets get out of here
1572 */ 1572 */
1573 if(enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden))) 1573 if(enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
1574 return 0; 1574 return 0;
1575 1575
1576 /* use this for invis also */ 1576 /* use this for invis also */
1577 hide_discovery = op->stats.Int/5; 1577 hide_discovery = op->stats.Int/5;
1578 1578
1579 /* Determine Detection radii */ 1579 /* Determine Detection radii */
1580 if(!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */ 1580 if(!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */
1581 radius = (op->stats.Wis/5)+1>MIN_MON_RADIUS?(op->stats.Wis/5)+1:MIN_MON_RADIUS; 1581 radius = (op->stats.Wis/5)+1>MIN_MON_RADIUS?(op->stats.Wis/5)+1:MIN_MON_RADIUS;
1582 else { /* a level/INT/Dex adjustment for hiding */ 1582 else { /* a level/INT/Dex adjustment for hiding */
1583 object *sk_hide; 1583 object *sk_hide;
1584 int bonus = (op->level/2) + (op->stats.Int/5); 1584 int bonus = (op->level/2) + (op->stats.Int/5);
1585 1585
1586 if(enemy->type==PLAYER) { 1586 if(enemy->type==PLAYER) {
1587 if((sk_hide = find_skill_by_number(enemy,SK_HIDING))) 1587 if((sk_hide = find_skill_by_number(enemy,SK_HIDING)))
1588 bonus -= sk_hide->level; 1588 bonus -= sk_hide->level;
1589 else { 1589 else {
1590 LOG(llevError,"can_detect_enemy() got hidden player w/o hiding skill!\n"); 1590 LOG(llevError,"can_detect_enemy() got hidden player w/o hiding skill!\n");
1591 make_visible(enemy); 1591 make_visible(enemy);
1592 radius=radius<MIN_MON_RADIUS?MIN_MON_RADIUS:radius; 1592 radius=radius<MIN_MON_RADIUS?MIN_MON_RADIUS:radius;
1593 } 1593 }
1594 } 1594 }
1595 else /* enemy is not a player */ 1595 else /* enemy is not a player */
1596 bonus -= enemy->level; 1596 bonus -= enemy->level;
1597 1597
1598 radius += bonus/5; 1598 radius += bonus/5;
1599 hide_discovery += bonus*5; 1599 hide_discovery += bonus*5;
1600 } /* else creature has modifiers for hiding */ 1600 } /* else creature has modifiers for hiding */
1601 1601
1602 /* Radii stealth adjustment. Only if you are stealthy 1602 /* Radii stealth adjustment. Only if you are stealthy
1603 * will you be able to sneak up closer to creatures */ 1603 * will you be able to sneak up closer to creatures */
1604 if(QUERY_FLAG(enemy,FLAG_STEALTH)) 1604 if(QUERY_FLAG(enemy,FLAG_STEALTH))
1605 radius = radius/2, hide_discovery = hide_discovery/3; 1605 radius = radius/2, hide_discovery = hide_discovery/3;
1606 1606
1607 /* Radii adjustment for enemy standing in the dark */ 1607 /* Radii adjustment for enemy standing in the dark */
1608 if(op->map->darkness>0 && !stand_in_light(enemy)) { 1608 if(op->map->darkness>0 && !stand_in_light(enemy)) {
1609 /* on dark maps body heat can help indicate location with infravision 1609 /* on dark maps body heat can help indicate location with infravision
1610 * undead don't have body heat, so no benefit detecting them. 1610 * undead don't have body heat, so no benefit detecting them.
1611 */ 1611 */
1612 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK) && !is_true_undead(enemy)) 1612 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK) && !is_true_undead(enemy))
1613 radius += op->map->darkness/2; 1613 radius += op->map->darkness/2;
1614 else 1614 else
1615 radius -= op->map->darkness/2; 1615 radius -= op->map->darkness/2;
1616 1616
1617 /* op next to a monster (and not in complete darkness) 1617 /* op next to a monster (and not in complete darkness)
1618 * the monster should have a chance to see you. 1618 * the monster should have a chance to see you.
1619 */ 1619 */
1620 if(radius<MIN_MON_RADIUS && op->map->darkness<5 && rv->distance<=1) 1620 if(radius<MIN_MON_RADIUS && op->map->darkness<5 && rv->distance<=1)
1621 radius = MIN_MON_RADIUS; 1621 radius = MIN_MON_RADIUS;
1622 } /* if on dark map */ 1622 } /* if on dark map */
1623 1623
1624 /* Lets not worry about monsters that have incredible detection 1624 /* Lets not worry about monsters that have incredible detection
1625 * radii, we only need to worry here about things the player can 1625 * radii, we only need to worry here about things the player can
1626 * (potentially) see. This is 13, as that is the maximum size the player 1626 * (potentially) see. This is 13, as that is the maximum size the player
… …
1631 */ 1631 */
1632 if(radius>13) radius = 13; 1632 if(radius>13) radius = 13;
1633 1633
1634 /* Enemy in range! Now test for detection */ 1634 /* Enemy in range! Now test for detection */
1635 if ((int) rv->distance <= radius) { 1635 if ((int) rv->distance <= radius) {
1636 /* ah, we are within range, detected? take cases */ 1636 /* ah, we are within range, detected? take cases */
1637 if(!enemy->invisible) /* enemy in dark squares... are seen! */ 1637 if(!enemy->invisible) /* enemy in dark squares... are seen! */
1638 return 1; 1638 return 1;
1639 1639
1640 /* hidden or low-quality invisible */ 1640 /* hidden or low-quality invisible */
1641 if(enemy->hide && (rv->distance <= 1) && (RANDOM()%100<=hide_discovery)) { 1641 if(enemy->hide && (rv->distance <= 1) && (RANDOM()%100<=hide_discovery)) {
1642 make_visible(enemy); 1642 make_visible(enemy);
1643 /* inform players of new status */ 1643 /* inform players of new status */
1644 if(enemy->type==PLAYER && player_can_view(enemy,op)) 1644 if(enemy->type==PLAYER && player_can_view(enemy,op))
1645 new_draw_info_format(NDI_UNIQUE,0, enemy, 1645 new_draw_info_format(NDI_UNIQUE,0, enemy,
1646 "You are discovered by %s!",op->name); 1646 "You are discovered by %s!",op->name);
1647 return 1; /* detected enemy */ 1647 return 1; /* detected enemy */
1648 } 1648 }
1649 else if (enemy->invisible) { 1649 else if (enemy->invisible) {
1650 /* Change this around - instead of negating the invisible, just 1650 /* Change this around - instead of negating the invisible, just
1651 * return true so that the mosnter that managed to detect you can 1651 * return true so that the mosnter that managed to detect you can
1652 * do something to you. Decreasing the duration of invisible 1652 * do something to you. Decreasing the duration of invisible
1653 * doesn't make a lot of sense IMO, as a bunch of stupid creatures 1653 * doesn't make a lot of sense IMO, as a bunch of stupid creatures
1654 * can then basically negate the spell. The spell isn't negated - 1654 * can then basically negate the spell. The spell isn't negated -
1655 * they just know where you are! 1655 * they just know where you are!
1656 */ 1656 */
1657 if ((RANDOM() % 50) <= hide_discovery) { 1657 if ((RANDOM() % 50) <= hide_discovery) {
1658 if (enemy->type == PLAYER) { 1658 if (enemy->type == PLAYER) {
1659 new_draw_info_format(NDI_UNIQUE,0, enemy, 1659 new_draw_info_format(NDI_UNIQUE,0, enemy,
1660 "You see %s noticing your position.", query_name(op)); 1660 "You see %s noticing your position.", query_name(op));
1661 } 1661 }
1662 return 1; 1662 return 1;
1663 } 1663 }
1664 } 1664 }
1665 } /* within range */ 1665 } /* within range */
1666 1666
1667 /* Wasn't detected above, so still hidden */ 1667 /* Wasn't detected above, so still hidden */
1668 return 0; 1668 return 0;
1669} 1669}
… …
1681 1681
1682 if(!op) return 0; 1682 if(!op) return 0;
1683 if(op->glow_radius > 0) return 1; 1683 if(op->glow_radius > 0) return 1;
1684 1684
1685 if(op->map) { 1685 if(op->map) {
1686 int x, y, x1, y1; 1686 int x, y, x1, y1;
1687 1687
1688 1688
1689 1689
1690 /* Check the spaces with the max light radius to see if any of them 1690 /* Check the spaces with the max light radius to see if any of them
1691 * have lights, and if any of them light the player enough, then return 1. 1691 * have lights, and if any of them light the player enough, then return 1.
1692 */ 1692 */
1693 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) { 1693 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) {
1694 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) { 1694 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) {
1695 m = op->map; 1695 m = op->map;
1696 nx = x; 1696 nx = x;
1697 ny = y; 1697 ny = y;
1698 1698
1699 if (get_map_flags(m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) continue; 1699 if (get_map_flags(m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) continue;
1700 1700
1701 x1 = abs(x - op->x)*abs(x - op->x); 1701 x1 = abs(x - op->x)*abs(x - op->x);
1702 y1 = abs(y - op->y)*abs(y - op->y); 1702 y1 = abs(y - op->y)*abs(y - op->y);
1703 if (isqrt(x1 + y1) < GET_MAP_LIGHT(m, nx, ny)) return 1; 1703 if (isqrt(x1 + y1) < GET_MAP_LIGHT(m, nx, ny)) return 1;
1704 } 1704 }
1705 } 1705 }
1706 } 1706 }
1707 return 0; 1707 return 0;
1708} 1708}
1709 1709
1710 1710
… …
1717int can_see_enemy (object *op, object *enemy) { 1717int can_see_enemy (object *op, object *enemy) {
1718 object *looker = op->head?op->head:op; 1718 object *looker = op->head?op->head:op;
1719 1719
1720 /* safety */ 1720 /* safety */
1721 if(!looker||!enemy||!QUERY_FLAG(looker,FLAG_ALIVE)) 1721 if(!looker||!enemy||!QUERY_FLAG(looker,FLAG_ALIVE))
1722 return 0; 1722 return 0;
1723 1723
1724 /* we dont give a full treatment of xrays here (shorter range than normal, 1724 /* we dont give a full treatment of xrays here (shorter range than normal,
1725 * see through walls). Should we change the code elsewhere to make you 1725 * see through walls). Should we change the code elsewhere to make you
1726 * blind even if you can xray? 1726 * blind even if you can xray?
1727 */ 1727 */
1728 if(QUERY_FLAG(looker,FLAG_BLIND) && !QUERY_FLAG(looker,FLAG_XRAYS)) 1728 if(QUERY_FLAG(looker,FLAG_BLIND) && !QUERY_FLAG(looker,FLAG_XRAYS))
1729 return 0; 1729 return 0;
1730 1730
1731 /* checking for invisible things */ 1731 /* checking for invisible things */
1732 if(enemy->invisible) { 1732 if(enemy->invisible) {
1733 /* HIDDEN ENEMY. by definition, you can't see hidden stuff! 1733 /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1734 * However,if you carry any source of light, then the hidden 1734 * However,if you carry any source of light, then the hidden
1735 * creature is seeable (and stupid) */ 1735 * creature is seeable (and stupid) */
1736 1736
1737 if(has_carried_lights(enemy)) { 1737 if(has_carried_lights(enemy)) {
1738 if(enemy->hide) { 1738 if(enemy->hide) {
1739 make_visible(enemy); 1739 make_visible(enemy);
1740 new_draw_info(NDI_UNIQUE,0, enemy, 1740 new_draw_info(NDI_UNIQUE,0, enemy,
1741 "Your light reveals your hiding spot!"); 1741 "Your light reveals your hiding spot!");
1742 } 1742 }
1743 return 1; 1743 return 1;
1744 } else if (enemy->hide) return 0; 1744 } else if (enemy->hide) return 0;
1745 1745
1746 /* Invisible enemy. Break apart the check for invis undead/invis looker 1746 /* Invisible enemy. Break apart the check for invis undead/invis looker
1747 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values, 1747 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
1748 * and making it a conditional makes the code pretty ugly. 1748 * and making it a conditional makes the code pretty ugly.
1749 */ 1749 */
1750 if (!QUERY_FLAG(looker,FLAG_SEE_INVISIBLE)) { 1750 if (!QUERY_FLAG(looker,FLAG_SEE_INVISIBLE)) {
1751 if (makes_invisible_to(enemy, looker)) return 0; 1751 if (makes_invisible_to(enemy, looker)) return 0;
1752 } 1752 }
1753 } else if(looker->type==PLAYER) /* for players, a (possible) shortcut */ 1753 } else if(looker->type==PLAYER) /* for players, a (possible) shortcut */
1754 if(player_can_view(looker,enemy)) return 1; 1754 if(player_can_view(looker,enemy)) return 1;
1755 1755
1756 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen 1756 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1757 * unless they carry a light or stand in light. Darkness doesnt 1757 * unless they carry a light or stand in light. Darkness doesnt

Diff Legend

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