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.2 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.7 by pippijn, Thu Sep 7 10:01:58 2006 UTC

1/* 1/*
2 * static char *rcsid_monster_c = 2 * static char *rcsid_monster_c =
3 * "$Id: monster.C,v 1.2 2006/08/26 23:36:34 root Exp $"; 3 * "$Id: monster.C,v 1.7 2006/09/07 10:01:58 pippijn 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 < (unsigned int) (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 (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
369 return 0; 369 return QUERY_FLAG (op, FLAG_FREED);
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 op->name = enemy->name;
459 free_string(op->name);
460 add_refcount(op->name = enemy->name);
461 } 459 }
462 460
463 /* Calculate range information for closest body part - this 461 /* Calculate range information for closest body part - this
464 * is used for the 'skill' code, which isn't that smart when 462 * is used for the 'skill' code, which isn't that smart when
465 * it comes to figuring it out - otherwise, giants throw boulders 463 * 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 469 * we were not doing any of the logic below, so might as well save
472 * a few cpu cycles. 470 * a few cpu cycles.
473 */ 471 */
474 if (!QUERY_FLAG(op, FLAG_SCARED)) 472 if (!QUERY_FLAG(op, FLAG_SCARED))
475 { 473 {
476 rv_vector rv1; 474 rv_vector rv1;
477 475
478 /* now we test every part of an object .... this is a real ugly piece of code */ 476 /* 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) { 477 for (part=op; part!=NULL; part=part->more) {
480 get_rangevector(part, enemy, &rv1, 0x1); 478 get_rangevector(part, enemy, &rv1, 0x1);
481 dir=rv1.direction; 479 dir=rv1.direction;
482 480
483 /* hm, not sure about this part - in original was a scared flag here too 481 /* 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 482 * but that we test above... so can be old code here
485 */ 483 */
486 if(QUERY_FLAG(op,FLAG_RUN_AWAY)) 484 if(QUERY_FLAG(op,FLAG_RUN_AWAY))
487 dir=absdir(dir+4); 485 dir=absdir(dir+4);
488 if(QUERY_FLAG(op,FLAG_CONFUSED)) 486 if(QUERY_FLAG(op,FLAG_CONFUSED))
489 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 487 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
490 488
491 if(QUERY_FLAG(op,FLAG_CAST_SPELL) && !(RANDOM()%3)) { 489 if(QUERY_FLAG(op,FLAG_CAST_SPELL) && !(RANDOM()%3)) {
492 if(monster_cast_spell(op,part,enemy,dir,&rv1)) 490 if(monster_cast_spell(op,part,enemy,dir,&rv1))
493 return 0; 491 return 0;
494 } 492 }
495 493
496 if(QUERY_FLAG(op,FLAG_READY_SCROLL) && !(RANDOM()%3)) { 494 if(QUERY_FLAG(op,FLAG_READY_SCROLL) && !(RANDOM()%3)) {
497 if(monster_use_scroll(op,part,enemy,dir,&rv1)) 495 if(monster_use_scroll(op,part,enemy,dir,&rv1))
498 return 0; 496 return 0;
499 } 497 }
500 498
501 if(QUERY_FLAG(op,FLAG_READY_RANGE)&&!(RANDOM()%3)) { 499 if(QUERY_FLAG(op,FLAG_READY_RANGE)&&!(RANDOM()%3)) {
502 if(monster_use_range(op,part,enemy,dir)) 500 if(monster_use_range(op,part,enemy,dir))
503 return 0; 501 return 0;
504 } 502 }
505 if(QUERY_FLAG(op,FLAG_READY_SKILL)&&!(RANDOM()%3)) { 503 if(QUERY_FLAG(op,FLAG_READY_SKILL)&&!(RANDOM()%3)) {
506 if(monster_use_skill(op,rv.part,enemy,rv.direction)) 504 if(monster_use_skill(op,rv.part,enemy,rv.direction))
507 return 0; 505 return 0;
508 } 506 }
509 if(QUERY_FLAG(op,FLAG_READY_BOW)&&!(RANDOM()%2)) { 507 if(QUERY_FLAG(op,FLAG_READY_BOW)&&!(RANDOM()%2)) {
510 if(monster_use_bow(op,part,enemy,dir)) 508 if(monster_use_bow(op,part,enemy,dir))
511 return 0; 509 return 0;
512 } 510 }
513 } /* for processing of all parts */ 511 } /* for processing of all parts */
514 } /* If not scared */ 512 } /* If not scared */
515 513
516 514
517 part = rv.part; 515 part = rv.part;
518 dir=rv.direction; 516 dir=rv.direction;
519 517
520 if(QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op,FLAG_RUN_AWAY)) 518 if(QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op,FLAG_RUN_AWAY))
521 dir=absdir(dir+4); 519 dir=absdir(dir+4);
522 520
523 if(QUERY_FLAG(op,FLAG_CONFUSED)) 521 if(QUERY_FLAG(op,FLAG_CONFUSED))
524 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 522 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
525 523
526 pre_att_dir = dir; /* remember the original direction */ 524 pre_att_dir = dir; /* remember the original direction */
527 525
528 if ((op->attack_movement & LO4) && !QUERY_FLAG(op, FLAG_SCARED)) 526 if ((op->attack_movement & LO4) && !QUERY_FLAG(op, FLAG_SCARED))
529 { 527 {
530 switch (op->attack_movement & LO4) { 528 switch (op->attack_movement & LO4) {
531 case DISTATT: 529 case DISTATT:
532 dir = dist_att (dir,op,enemy,part,&rv); 530 dir = dist_att (dir,op,enemy,part,&rv);
533 break; 531 break;
534 532
535 case RUNATT: 533 case RUNATT:
536 dir = run_att (dir,op,enemy,part,&rv); 534 dir = run_att (dir,op,enemy,part,&rv);
537 break; 535 break;
538 536
539 case HITRUN: 537 case HITRUN:
540 dir = hitrun_att(dir,op,enemy); 538 dir = hitrun_att(dir,op,enemy);
541 break; 539 break;
542 540
543 case WAITATT: 541 case WAITATT:
544 dir = wait_att (dir,op,enemy,part,&rv); 542 dir = wait_att (dir,op,enemy,part,&rv);
545 break; 543 break;
546 544
547 case RUSH: /* default - monster normally moves towards player */ 545 case RUSH: /* default - monster normally moves towards player */
548 case ALLRUN: 546 case ALLRUN:
549 break; 547 break;
550 548
551 case DISTHIT: 549 case DISTHIT:
552 dir = disthit_att (dir,op,enemy,part,&rv); 550 dir = disthit_att (dir,op,enemy,part,&rv);
553 break; 551 break;
554 552
555 case WAIT2: 553 case WAIT2:
556 dir = wait_att2 (dir,op,enemy,part,&rv); 554 dir = wait_att2 (dir,op,enemy,part,&rv);
557 break; 555 break;
558 556
559 default: 557 default:
560 LOG(llevDebug,"Illegal low mon-move: %d\n",op->attack_movement & LO4); 558 LOG(llevDebug,"Illegal low mon-move: %d\n",op->attack_movement & LO4);
561 } 559 }
562 } 560 }
563 561
564 if (!dir) 562 if (!dir)
565 return 0; 563 return 0;
566 564
567 if (!QUERY_FLAG(op,FLAG_STAND_STILL)) { 565 if (!QUERY_FLAG(op,FLAG_STAND_STILL)) {
568 if(move_object(op,dir)) /* Can the monster move directly toward player? */ 566 if(move_object(op,dir)) /* Can the monster move directly toward player? */
569 { 567 {
570 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 568 /* elmex: Turn our monster after it moved if it has DISTATT attack */
571 if ((op->attack_movement & LO4) == DISTATT) 569 if ((op->attack_movement & LO4) == DISTATT)
572 op->direction = pre_att_dir; 570 op->direction = pre_att_dir;
573 571
574 return 0; 572 return 0;
575 } 573 }
576 574
577 if(QUERY_FLAG(op, FLAG_SCARED) || !can_hit(part,enemy,&rv) 575 if(QUERY_FLAG(op, FLAG_SCARED) || !can_hit(part,enemy,&rv)
578 || QUERY_FLAG(op,FLAG_RUN_AWAY)) { 576 || QUERY_FLAG(op,FLAG_RUN_AWAY)) {
579 577
580 /* Try move around corners if !close */ 578 /* Try move around corners if !close */
581 int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2; 579 int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2;
582 for(diff = 1; diff <= maxdiff; diff++) { 580 for(diff = 1; diff <= maxdiff; diff++) {
583 /* try different detours */ 581 /* try different detours */
584 int m = 1-(RANDOM()&2); /* Try left or right first? */ 582 int m = 1-(RANDOM()&2); /* Try left or right first? */
585 if(move_object(op,absdir(dir + diff*m)) || 583 if(move_object(op,absdir(dir + diff*m)) ||
586 move_object(op,absdir(dir - diff*m))) 584 move_object(op,absdir(dir - diff*m)))
587 return 0; 585 return 0;
588 } 586 }
589 } 587 }
590 } /* if monster is not standing still */ 588 } /* if monster is not standing still */
591 589
592 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 590 /* elmex: Turn our monster after it moved if it has DISTATT attack */
593 if ((op->attack_movement & LO4) == DISTATT) 591 if ((op->attack_movement & LO4) == DISTATT)
594 op->direction = pre_att_dir; 592 op->direction = pre_att_dir;
… …
596 /* 594 /*
597 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random 595 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
598 * direction if they can't move away. 596 * direction if they can't move away.
599 */ 597 */
600 if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)&&(QUERY_FLAG(op,FLAG_RUN_AWAY)||QUERY_FLAG(op, FLAG_SCARED))) 598 if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)&&(QUERY_FLAG(op,FLAG_RUN_AWAY)||QUERY_FLAG(op, FLAG_SCARED)))
601 if(move_randomly(op)) 599 if(move_randomly(op))
602 return 0; 600 return 0;
603 601
604 /* 602 /*
605 * Try giving the monster a new enemy - the player that is closest 603 * 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 604 * to it. In this way, it won't just keep trying to get to a target
607 * that is inaccessible. 605 * that is inaccessible.
… …
612 * the monster could get to - as it is, the monster won't look at that 610 * the monster could get to - as it is, the monster won't look at that
613 * third one. 611 * third one.
614 */ 612 */
615 if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy) 613 if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy)
616 { 614 {
617 object *nearest_player = get_nearest_player(op); 615 object *nearest_player = get_nearest_player(op);
618 if (nearest_player && nearest_player != enemy && !can_hit(part,enemy,&rv)) { 616 if (nearest_player && nearest_player != enemy && !can_hit(part,enemy,&rv)) {
619 op->enemy = NULL; 617 op->enemy = NULL;
620 enemy = nearest_player; 618 enemy = nearest_player;
621 } 619 }
622 } 620 }
623 621
624 if(!QUERY_FLAG(op, FLAG_SCARED)&&can_hit(part,enemy,&rv)) 622 if(!QUERY_FLAG(op, FLAG_SCARED)&&can_hit(part,enemy,&rv))
625 { 623 {
626 /* The adjustement to wc that was here before looked totally bogus - 624 /* The adjustement to wc that was here before looked totally bogus -
627 * since wc can in fact get negative, that would mean by adding 625 * since wc can in fact get negative, that would mean by adding
628 * the current wc, the creature gets better? Instead, just 626 * the current wc, the creature gets better? Instead, just
629 * add a fixed amount - nasty creatures that are runny away should 627 * add a fixed amount - nasty creatures that are runny away should
630 * still be pretty nasty. 628 * still be pretty nasty.
631 */ 629 */
632 if(QUERY_FLAG(op,FLAG_RUN_AWAY)) 630 if(QUERY_FLAG(op,FLAG_RUN_AWAY))
633 { 631 {
634 part->stats.wc+=10; 632 part->stats.wc+=10;
635 (void)skill_attack(enemy,part,0,NULL, NULL); 633 (void)skill_attack(enemy,part,0,NULL, NULL);
636 part->stats.wc-=10; 634 part->stats.wc-=10;
637 } 635 }
638 else 636 else
639 (void)skill_attack(enemy,part,0,NULL, NULL); 637 (void)skill_attack(enemy,part,0,NULL, NULL);
640 } /* if monster is in attack range */ 638 } /* if monster is in attack range */
641 639
642 if(QUERY_FLAG(part,FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */ 640 if(QUERY_FLAG(part,FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
643 return 1; 641 return 1;
644 642
645 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) 643 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK))
646 { 644 {
647 remove_ob(op); 645 remove_ob(op);
648 free_object(op); 646 free_object(op);
649 return 1; 647 return 1;
650 } 648 }
651 return 0; 649 return 0;
652} 650}
651
653int can_hit(object *ob1,object *ob2, rv_vector *rv) { 652int can_hit(object *ob1,object *ob2, rv_vector *rv) {
654 object *more; 653 object *more;
655 rv_vector rv1; 654 rv_vector rv1;
656 655
657 if(QUERY_FLAG(ob1,FLAG_CONFUSED)&&!(RANDOM()%3)) 656 if(QUERY_FLAG(ob1,FLAG_CONFUSED)&&!(RANDOM()%3))
658 return 0; 657 return 0;
659 658
660 if (abs(rv->distance_x)<2&&abs(rv->distance_y)<2) return 1; 659 if (abs(rv->distance_x)<2&&abs(rv->distance_y)<2) return 1;
661 660
662 /* check all the parts of ob2 - just because we can't get to 661 /* 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 662 * its head doesn't mean we don't want to pound its feet
664 */ 663 */
665 for (more = ob2->more; more!=NULL; more = more->more) { 664 for (more = ob2->more; more!=NULL; more = more->more) {
666 get_rangevector(ob1, more, &rv1, 0); 665 get_rangevector(ob1, more, &rv1, 0);
667 if (abs(rv1.distance_x)<2&&abs(rv1.distance_y)<2) return 1; 666 if (abs(rv1.distance_x)<2&&abs(rv1.distance_y)<2) return 1;
668 } 667 }
669 return 0; 668 return 0;
670 669
671} 670}
672 671
… …
687 */ 686 */
688 687
689static int monster_should_cast_spell(object *monster, object *spell_ob) 688static int monster_should_cast_spell(object *monster, object *spell_ob)
690{ 689{
691 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET || 690 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
692 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE || 691 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
693 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE || 692 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE ||
694 spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM || 693 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 || 694 spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER ||
696 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || 695 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM ||
697 spell_ob->subtype == SP_INVISIBLE) 696 spell_ob->subtype == SP_INVISIBLE)
698 697
699 return 1; 698 return 1;
700 699
701 return 0; 700 return 0;
702} 701}
703 702
704 703
… …
713 object *altern[MAX_KNOWN_SPELLS]; 712 object *altern[MAX_KNOWN_SPELLS];
714 object *tmp; 713 object *tmp;
715 int i=0; 714 int i=0;
716 715
717 for(tmp=monster->inv;tmp!=NULL;tmp=tmp->below) 716 for(tmp=monster->inv;tmp!=NULL;tmp=tmp->below)
718 if (tmp->type==SPELLBOOK || tmp->type==SPELL) { 717 if (tmp->type==SPELLBOOK || tmp->type==SPELL) {
719 /* Check and see if it's actually a useful spell. 718 /* Check and see if it's actually a useful spell.
720 * If its a spellbook, the spell is actually the inventory item. 719 * If its a spellbook, the spell is actually the inventory item.
721 * if it is a spell, then it is just the object itself. 720 * if it is a spell, then it is just the object itself.
722 */ 721 */
723 if (monster_should_cast_spell(monster, (tmp->type==SPELLBOOK)?tmp->inv:tmp)) { 722 if (monster_should_cast_spell(monster, (tmp->type==SPELLBOOK)?tmp->inv:tmp)) {
724 altern[i++]=tmp; 723 altern[i++]=tmp;
725 if(i==MAX_KNOWN_SPELLS) 724 if(i==MAX_KNOWN_SPELLS)
726 break; 725 break;
727 } 726 }
728 } 727 }
729 if(!i) 728 if(!i)
730 return NULL; 729 return NULL;
731 return altern[RANDOM()%i]; 730 return altern[RANDOM()%i];
732} 731}
733 732
734/* This checks to see if the monster should cast a spell/ability. 733/* 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. 734 * it returns true if the monster casts a spell, 0 if he doesn't.
… …
753 */ 752 */
754 if(!(dir=path_to_player(part,pl,0))) 753 if(!(dir=path_to_player(part,pl,0)))
755 return 0; 754 return 0;
756 755
757 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 756 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
758 get_rangevector(head, owner, &rv1, 0x1); 757 get_rangevector(head, owner, &rv1, 0x1);
759 if(dirdiff(dir,rv1.direction) < 2) { 758 if(dirdiff(dir,rv1.direction) < 2) {
760 return 0; /* Might hit owner with spell */ 759 return 0; /* Might hit owner with spell */
761 } 760 }
762 } 761 }
763 762
764 if(QUERY_FLAG(head,FLAG_CONFUSED)) 763 if(QUERY_FLAG(head,FLAG_CONFUSED))
765 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 764 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
766 765
767 /* If the monster hasn't already chosen a spell, choose one 766 /* 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 767 * 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). 768 * could be different by the time the monster goes again).
770 */ 769 */
771 if(head->spellitem==NULL) { 770 if(head->spellitem==NULL) {
772 if((spell_item=monster_choose_random_spell(head))==NULL) { 771 if((spell_item=monster_choose_random_spell(head))==NULL) {
773 LOG(llevMonster,"Turned off spells in %s\n",head->name); 772 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 */ 773 CLEAR_FLAG(head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
775 return 0; 774 return 0;
776 } 775 }
777 if (spell_item->type == SPELLBOOK) { 776 if (spell_item->type == SPELLBOOK) {
778 if (!spell_item->inv) { 777 if (!spell_item->inv) {
779 LOG(llevError,"spellbook %s does not contain a spell?\n", spell_item->name); 778 LOG(llevError,"spellbook %s does not contain a spell?\n", &spell_item->name);
780 return 0; 779 return 0;
781 } 780 }
782 spell_item=spell_item->inv; 781 spell_item=spell_item->inv;
783 } 782 }
784 } 783 }
785 else 784 else
786 spell_item=head->spellitem; 785 spell_item=head->spellitem;
787 786
788 if (!spell_item) return 0; 787 if (!spell_item) return 0;
789 788
790 /* Best guess this is a defensive/healing spell */ 789 /* Best guess this is a defensive/healing spell */
791 if (spell_item->range<=1 || spell_item->stats.dam < 0) 790 if (spell_item->range<=1 || spell_item->stats.dam < 0)
792 dir = 0; 791 dir = 0;
793 792
794 /* Monster doesn't have enough spell-points */ 793 /* Monster doesn't have enough spell-points */
795 if(head->stats.sp<SP_level_spellpoint_cost(head,spell_item, SPELL_MANA)) 794 if(head->stats.sp<SP_level_spellpoint_cost(head,spell_item, SPELL_MANA))
796 return 0; 795 return 0;
797 796
798 if(head->stats.grace<SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE)) 797 if(head->stats.grace<SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE))
799 return 0; 798 return 0;
800 799
801 head->stats.sp-=SP_level_spellpoint_cost(head,spell_item, SPELL_MANA); 800 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); 801 head->stats.grace-=SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE);
803 802
804 /* set this to null, so next time monster will choose something different */ 803 /* set this to null, so next time monster will choose something different */
… …
821 */ 820 */
822 if(!(dir=path_to_player(part,pl,0))) 821 if(!(dir=path_to_player(part,pl,0)))
823 return 0; 822 return 0;
824 823
825 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 824 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
826 get_rangevector(head, owner, &rv1, 0x1); 825 get_rangevector(head, owner, &rv1, 0x1);
827 if(dirdiff(dir,rv1.direction) < 2) { 826 if(dirdiff(dir,rv1.direction) < 2) {
828 return 0; /* Might hit owner with spell */ 827 return 0; /* Might hit owner with spell */
829 } 828 }
830 } 829 }
831 830
832 if(QUERY_FLAG(head,FLAG_CONFUSED)) 831 if(QUERY_FLAG(head,FLAG_CONFUSED))
833 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 832 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
834 833
835 for (scroll=head->inv; scroll; scroll=scroll->below) 834 for (scroll=head->inv; scroll; scroll=scroll->below)
836 if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv)) break; 835 if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv)) break;
837 836
838 /* Used up all his scrolls, so nothing do to */ 837 /* Used up all his scrolls, so nothing do to */
839 if (!scroll) { 838 if (!scroll) {
840 CLEAR_FLAG(head, FLAG_READY_SCROLL); 839 CLEAR_FLAG(head, FLAG_READY_SCROLL);
841 return 0; 840 return 0;
842 } 841 }
843 842
844 /* Spell should be cast on caster (ie, heal, strength) */ 843 /* Spell should be cast on caster (ie, heal, strength) */
845 if (scroll->inv->range==0) 844 if (scroll->inv->range==0)
846 dir = 0; 845 dir = 0;
847 846
848 apply_scroll(part, scroll, dir); 847 apply_scroll(part, scroll, dir);
849 return 1; 848 return 1;
850} 849}
851 850
… …
863 862
864int monster_use_skill(object *head, object *part, object *pl,int dir) { 863int monster_use_skill(object *head, object *part, object *pl,int dir) {
865 object *skill, *owner; 864 object *skill, *owner;
866 865
867 if(!(dir=path_to_player(part,pl,0))) 866 if(!(dir=path_to_player(part,pl,0)))
868 return 0; 867 return 0;
869 868
870 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 869 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); 870 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
872 if(dirdiff(dir,dir2) < 1) 871 if(dirdiff(dir,dir2) < 1)
873 return 0; /* Might hit owner with skill -thrown rocks for example ?*/ 872 return 0; /* Might hit owner with skill -thrown rocks for example ?*/
874 } 873 }
875 if(QUERY_FLAG(head,FLAG_CONFUSED)) 874 if(QUERY_FLAG(head,FLAG_CONFUSED))
876 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 875 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
877 876
878 /* skill selection - monster will use the next unused skill. 877 /* skill selection - monster will use the next unused skill.
879 * well...the following scenario will allow the monster to 878 * well...the following scenario will allow the monster to
880 * toggle between 2 skills. One day it would be nice to make 879 * toggle between 2 skills. One day it would be nice to make
881 * more skills available to monsters. 880 * more skills available to monsters.
882 */ 881 */
883 882
884 for(skill=head->inv;skill!=NULL;skill=skill->below) 883 for(skill=head->inv;skill!=NULL;skill=skill->below)
885 if(skill->type==SKILL && skill!=head->chosen_skill) { 884 if(skill->type==SKILL && skill!=head->chosen_skill) {
886 head->chosen_skill=skill; 885 head->chosen_skill=skill;
887 break; 886 break;
888 } 887 }
889 888
890 if(!skill && !head->chosen_skill) { 889 if(!skill && !head->chosen_skill) {
891 LOG(llevDebug,"Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", 890 LOG(llevDebug,"Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n",
892 head->name,head->count); 891 &head->name,head->count);
893 CLEAR_FLAG(head, FLAG_READY_SKILL); 892 CLEAR_FLAG(head, FLAG_READY_SKILL);
894 return 0; 893 return 0;
895 } 894 }
896 /* use skill */ 895 /* use skill */
897 return do_skill(head, part, head->chosen_skill,dir,NULL); 896 return do_skill(head, part, head->chosen_skill,dir,NULL);
898} 897}
899 898
… …
903 { 902 {
904 object *wand, *owner; 903 object *wand, *owner;
905 int at_least_one = 0; 904 int at_least_one = 0;
906 905
907 if(!(dir=path_to_player(part,pl,0))) 906 if(!(dir=path_to_player(part,pl,0)))
908 return 0; 907 return 0;
909 908
910 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 909 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); 910 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
912 if(dirdiff(dir,dir2) < 2) 911 if(dirdiff(dir,dir2) < 2)
913 return 0; /* Might hit owner with spell */ 912 return 0; /* Might hit owner with spell */
914 } 913 }
915 if(QUERY_FLAG(head,FLAG_CONFUSED)) 914 if(QUERY_FLAG(head,FLAG_CONFUSED))
916 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 915 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
917 916
918 for(wand=head->inv;wand!=NULL;wand=wand->below) 917 for(wand=head->inv;wand!=NULL;wand=wand->below)
919 { 918 {
920 if (wand->type == WAND) 919 if (wand->type == WAND)
921 { 920 {
922 /* Found a wand, let's see if it has charges left */ 921 /* Found a wand, let's see if it has charges left */
923 at_least_one = 1; 922 at_least_one = 1;
924 if( wand->stats.food<=0 ) 923 if( wand->stats.food<=0 )
925 continue; 924 continue;
926 925
927 cast_spell( head, wand, dir, wand->inv, NULL ); 926 cast_spell( head, wand, dir, wand->inv, NULL );
928 927
929 if ( !( --wand->stats.food ) ) 928 if ( !( --wand->stats.food ) )
930 { 929 {
931 if ( wand->arch ) 930 if ( wand->arch )
932 { 931 {
933 CLEAR_FLAG(wand, FLAG_ANIMATE); 932 CLEAR_FLAG(wand, FLAG_ANIMATE);
934 wand->face = wand->arch->clone.face; 933 wand->face = wand->arch->clone.face;
935 wand->speed = 0; 934 wand->speed = 0;
936 update_ob_speed(wand); 935 update_ob_speed(wand);
937 } 936 }
938 } 937 }
939 /* Success */ 938 /* Success */
940 return 1; 939 return 1;
941 } 940 }
942 else if ( wand->type == ROD || wand->type==HORN ) { 941 else if ( wand->type == ROD || wand->type==HORN ) {
943 /* Found rod/horn, let's use it if possible */ 942 /* Found rod/horn, let's use it if possible */
944 at_least_one = 1; 943 at_least_one = 1;
945 if( wand->stats.hp < MAX( wand->inv->stats.sp, wand->inv->stats.grace ) ) 944 if( wand->stats.hp < MAX( wand->inv->stats.sp, wand->inv->stats.grace ) )
946 continue; 945 continue;
947 946
948 /* drain charge before casting spell - can be a case where the 947 /* drain charge before casting spell - can be a case where the
949 * spell destroys the monster, and rod, so if done after, results 948 * spell destroys the monster, and rod, so if done after, results
950 * in crash. 949 * in crash.
951 */ 950 */
952 drain_rod_charge( wand ); 951 drain_rod_charge( wand );
953 cast_spell( head, wand, dir, wand->inv, NULL ); 952 cast_spell( head, wand, dir, wand->inv, NULL );
954 953
955 /* Success */ 954 /* Success */
956 return 1; 955 return 1;
957 } 956 }
… …
959 958
960 if ( at_least_one ) 959 if ( at_least_one )
961 return 0; 960 return 0;
962 961
963 LOG(llevError,"Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", 962 LOG(llevError,"Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n",
964 head->name,head->count); 963 &head->name,head->count);
965 CLEAR_FLAG(head, FLAG_READY_RANGE); 964 CLEAR_FLAG(head, FLAG_READY_RANGE);
966 return 0; 965 return 0;
967 } 966 }
968 967
969int monster_use_bow(object *head, object *part, object *pl, int dir) { 968int monster_use_bow(object *head, object *part, object *pl, int dir) {
970 object *owner; 969 object *owner;
971 970
972 if(!(dir=path_to_player(part,pl,0))) 971 if(!(dir=path_to_player(part,pl,0)))
973 return 0; 972 return 0;
974 if(QUERY_FLAG(head,FLAG_CONFUSED)) 973 if(QUERY_FLAG(head,FLAG_CONFUSED))
975 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 974 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
976 975
977 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 976 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); 977 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
979 if(dirdiff(dir,dir2) < 1) 978 if(dirdiff(dir,dir2) < 1)
980 return 0; /* Might hit owner with arrow */ 979 return 0; /* Might hit owner with arrow */
981 } 980 }
982 981
983 /* in server/player.c */ 982 /* in server/player.c */
984 return fire_bow(head, part, NULL, dir, 0, part->x, part->y); 983 return fire_bow(head, part, NULL, dir, 0, part->x, part->y);
985 984
… …
995int check_good_weapon(object *who, object *item) { 994int check_good_weapon(object *who, object *item) {
996 object *other_weap; 995 object *other_weap;
997 int val=0, i; 996 int val=0, i;
998 997
999 for(other_weap=who->inv;other_weap!=NULL;other_weap=other_weap->below) 998 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)) 999 if(other_weap->type==item->type&&QUERY_FLAG(other_weap,FLAG_APPLIED))
1001 break; 1000 break;
1002 1001
1003 if(other_weap==NULL) /* No other weapons */ 1002 if(other_weap==NULL) /* No other weapons */
1004 return 1; 1003 return 1;
1005 1004
1006 /* Rather than go through and apply the new one, and see if it is 1005 /* Rather than go through and apply the new one, and see if it is
1007 * better, just do some simple checks 1006 * better, just do some simple checks
1008 * Put some multipliers for things that hvae several effects, 1007 * Put some multipliers for things that hvae several effects,
1009 * eg, magic affects both damage and wc, so it has more weight 1008 * eg, magic affects both damage and wc, so it has more weight
… …
1013 val += (item->magic - other_weap->magic) * 3; 1012 val += (item->magic - other_weap->magic) * 3;
1014 /* Monsters don't really get benefits from things like regen rates 1013 /* Monsters don't really get benefits from things like regen rates
1015 * from items. But the bonus for their stats are very important. 1014 * from items. But the bonus for their stats are very important.
1016 */ 1015 */
1017 for (i=0; i<NUM_STATS; i++) 1016 for (i=0; i<NUM_STATS; i++)
1018 val += (get_attr_value(&item->stats, i) - get_attr_value(&other_weap->stats, i))*2; 1017 val += (get_attr_value(&item->stats, i) - get_attr_value(&other_weap->stats, i))*2;
1019 1018
1020 if (val > 0) return 1; 1019 if (val > 0) return 1;
1021 else return 0; 1020 else return 0;
1022 1021
1023} 1022}
… …
1025int check_good_armour(object *who, object *item) { 1024int check_good_armour(object *who, object *item) {
1026 object *other_armour; 1025 object *other_armour;
1027 int val=0,i; 1026 int val=0,i;
1028 1027
1029 for (other_armour = who->inv; other_armour != NULL; 1028 for (other_armour = who->inv; other_armour != NULL;
1030 other_armour = other_armour->below) 1029 other_armour = other_armour->below)
1031 if (other_armour->type == item->type && QUERY_FLAG(other_armour,FLAG_APPLIED)) 1030 if (other_armour->type == item->type && QUERY_FLAG(other_armour,FLAG_APPLIED))
1032 break; 1031 break;
1033 1032
1034 if (other_armour == NULL) /* No other armour, use the new */ 1033 if (other_armour == NULL) /* No other armour, use the new */
1035 return 1; 1034 return 1;
1036 1035
1037 /* Like above function , see which is better */ 1036 /* Like above function , see which is better */
1038 val = item->stats.ac - other_armour->stats.ac; 1037 val = item->stats.ac - other_armour->stats.ac;
1039 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL])/5; 1038 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL])/5;
1040 val += (item->magic - other_armour->magic) * 3; 1039 val += (item->magic - other_armour->magic) * 3;
… …
1044 * no good way to know what the player may attack the monster with. 1043 * 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 1044 * 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. 1045 * value. If the reverse, then decrease the value of this item some.
1047 */ 1046 */
1048 for (i=1; i <NROFATTACKS; i++) { 1047 for (i=1; i <NROFATTACKS; i++) {
1049 if (item->resist[i] > other_armour->resist[i]) val++; 1048 if (item->resist[i] > other_armour->resist[i]) val++;
1050 else if (item->resist[i] < other_armour->resist[i]) val--; 1049 else if (item->resist[i] < other_armour->resist[i]) val--;
1051 } 1050 }
1052 1051
1053 /* Very few armours have stats, so not much need to worry about those. */ 1052 /* Very few armours have stats, so not much need to worry about those. */
1054 1053
1055 if (val > 0) return 1; 1054 if (val > 0) return 1;
… …
1076void monster_check_pickup(object *monster) { 1075void monster_check_pickup(object *monster) {
1077 object *tmp,*next; 1076 object *tmp,*next;
1078 int next_tag; 1077 int next_tag;
1079 1078
1080 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1079 for(tmp=monster->below;tmp!=NULL;tmp=next) {
1081 next=tmp->below; 1080 next=tmp->below;
1082 next_tag = next ? next->count : 0; 1081 next_tag = next ? next->count : 0;
1083 if (monster_can_pick(monster,tmp)) { 1082 if (monster_can_pick(monster,tmp)) {
1084 remove_ob(tmp); 1083 remove_ob(tmp);
1085 tmp = insert_ob_in_ob(tmp,monster); 1084 tmp = insert_ob_in_ob(tmp,monster);
1086 (void) monster_check_apply(monster,tmp); 1085 (void) monster_check_apply(monster,tmp);
1087 } 1086 }
1088 /* We could try to re-establish the cycling, of the space, but probably 1087 /* We could try to re-establish the cycling, of the space, but probably
1089 * not a big deal to just bail out. 1088 * not a big deal to just bail out.
1090 */ 1089 */
1091 if (next && was_destroyed(next, next_tag)) return; 1090 if (next && was_destroyed(next, next_tag)) return;
1092 } 1091 }
1093} 1092}
1094 1093
1095/* 1094/*
1096 * monster_can_pick(): If the monster is interested in picking up 1095 * monster_can_pick(): If the monster is interested in picking up
… …
1102int monster_can_pick(object *monster, object *item) { 1101int monster_can_pick(object *monster, object *item) {
1103 int flag=0; 1102 int flag=0;
1104 int i; 1103 int i;
1105 1104
1106 if(!can_pick(monster,item)) 1105 if(!can_pick(monster,item))
1107 return 0; 1106 return 0;
1108 1107
1109 if(QUERY_FLAG(item,FLAG_UNPAID)) 1108 if(QUERY_FLAG(item,FLAG_UNPAID))
1110 return 0; 1109 return 0;
1111 1110
1112 if (monster->pick_up&64) /* All */ 1111 if (monster->pick_up&64) /* All */
1113 flag=1; 1112 flag=1;
1114 1113
1115 else switch(item->type) { 1114 else switch(item->type) {
1116 case MONEY: 1115 case MONEY:
1117 case GEM: 1116 case GEM:
1118 flag=monster->pick_up&2; 1117 flag=monster->pick_up&2;
1119 break; 1118 break;
1120 1119
1121 case FOOD: 1120 case FOOD:
1122 flag=monster->pick_up&4; 1121 flag=monster->pick_up&4;
1123 break; 1122 break;
1124 1123
1125 case WEAPON: 1124 case WEAPON:
1126 flag=(monster->pick_up&8)||QUERY_FLAG(monster,FLAG_USE_WEAPON); 1125 flag=(monster->pick_up&8)||QUERY_FLAG(monster,FLAG_USE_WEAPON);
1127 break; 1126 break;
1128 1127
1129 case ARMOUR: 1128 case ARMOUR:
1130 case SHIELD: 1129 case SHIELD:
1131 case HELMET: 1130 case HELMET:
1132 case BOOTS: 1131 case BOOTS:
1133 case GLOVES: 1132 case GLOVES:
1134 case GIRDLE: 1133 case GIRDLE:
1135 flag=(monster->pick_up&16)||QUERY_FLAG(monster,FLAG_USE_ARMOUR); 1134 flag=(monster->pick_up&16)||QUERY_FLAG(monster,FLAG_USE_ARMOUR);
1136 break; 1135 break;
1137 1136
1138 case SKILL: 1137 case SKILL:
1139 flag=QUERY_FLAG(monster,FLAG_CAN_USE_SKILL); 1138 flag=QUERY_FLAG(monster,FLAG_CAN_USE_SKILL);
1140 break; 1139 break;
1141 1140
1142 case RING: 1141 case RING:
1143 flag=QUERY_FLAG(monster,FLAG_USE_RING); 1142 flag=QUERY_FLAG(monster,FLAG_USE_RING);
1144 break; 1143 break;
1145 1144
1146 case WAND: 1145 case WAND:
1147 case HORN: 1146 case HORN:
1148 case ROD: 1147 case ROD:
1149 flag=QUERY_FLAG(monster,FLAG_USE_RANGE); 1148 flag=QUERY_FLAG(monster,FLAG_USE_RANGE);
1150 break; 1149 break;
1151 1150
1152 case SPELLBOOK: 1151 case SPELLBOOK:
1153 flag=(monster->arch!=NULL&&QUERY_FLAG((&monster->arch->clone),FLAG_CAST_SPELL)); 1152 flag=(monster->arch!=NULL&&QUERY_FLAG((&monster->arch->clone),FLAG_CAST_SPELL));
1154 break; 1153 break;
1155 1154
1156 case SCROLL: 1155 case SCROLL:
1157 flag = QUERY_FLAG(monster,FLAG_USE_SCROLL); 1156 flag = QUERY_FLAG(monster,FLAG_USE_SCROLL);
1158 break; 1157 break;
1159 1158
1160 case BOW: 1159 case BOW:
1161 case ARROW: 1160 case ARROW:
1162 flag=QUERY_FLAG(monster,FLAG_USE_BOW); 1161 flag=QUERY_FLAG(monster,FLAG_USE_BOW);
1163 break; 1162 break;
1164 } 1163 }
1165 /* Simplistic check - if the monster has a location to equip it, he will 1164 /* 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 1165 * pick it up. Note that this doesn't handle cases where an item may
1167 * use several locations. 1166 * use several locations.
1168 */ 1167 */
1169 for (i=0; i < NUM_BODY_LOCATIONS; i++) { 1168 for (i=0; i < NUM_BODY_LOCATIONS; i++) {
1170 if (monster->body_info[i] && item->body_info[i]) { 1169 if (monster->body_info[i] && item->body_info[i]) {
1171 flag=1; 1170 flag=1;
1172 break; 1171 break;
1173 } 1172 }
1174 } 1173 }
1175 1174
1176 if (((!(monster->pick_up&32))&&flag) || ((monster->pick_up&32)&&(!flag))) 1175 if (((!(monster->pick_up&32))&&flag) || ((monster->pick_up&32)&&(!flag)))
1177 return 1; 1176 return 1;
1178 return 0; 1177 return 0;
1179} 1178}
1180 1179
1181/* 1180/*
1182 * monster_apply_below(): 1181 * monster_apply_below():
… …
1187 1186
1188void monster_apply_below(object *monster) { 1187void monster_apply_below(object *monster) {
1189 object *tmp, *next; 1188 object *tmp, *next;
1190 1189
1191 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1190 for(tmp=monster->below;tmp!=NULL;tmp=next) {
1192 next=tmp->below; 1191 next=tmp->below;
1193 switch (tmp->type) { 1192 switch (tmp->type) {
1194 case CF_HANDLE: 1193 case CF_HANDLE:
1195 case TRIGGER: 1194 case TRIGGER:
1196 if (monster->will_apply&1) 1195 if (monster->will_apply&1)
1197 manual_apply(monster,tmp,0); 1196 manual_apply(monster,tmp,0);
1198 break; 1197 break;
1199 1198
1200 case TREASURE: 1199 case TREASURE:
1201 if (monster->will_apply&2) 1200 if (monster->will_apply&2)
1202 manual_apply(monster,tmp,0); 1201 manual_apply(monster,tmp,0);
1203 break; 1202 break;
1204 1203
1205 } 1204 }
1206 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1205 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1207 break; 1206 break;
1208 } 1207 }
1209} 1208}
1210 1209
1211/* 1210/*
1212 * monster_check_apply() is meant to be called after an item is 1211 * monster_check_apply() is meant to be called after an item is
… …
1224 1223
1225 int flag = 0; 1224 int flag = 0;
1226 1225
1227 if(item->type==SPELLBOOK&& 1226 if(item->type==SPELLBOOK&&
1228 mon->arch!=NULL&&(QUERY_FLAG((&mon->arch->clone),FLAG_CAST_SPELL))) { 1227 mon->arch!=NULL&&(QUERY_FLAG((&mon->arch->clone),FLAG_CAST_SPELL))) {
1229 SET_FLAG(mon, FLAG_CAST_SPELL); 1228 SET_FLAG(mon, FLAG_CAST_SPELL);
1230 return; 1229 return;
1231 } 1230 }
1232 1231
1233 /* If for some reason, this item is already applied, no more work to do */ 1232 /* If for some reason, this item is already applied, no more work to do */
1234 if(QUERY_FLAG(item,FLAG_APPLIED)) return; 1233 if(QUERY_FLAG(item,FLAG_APPLIED)) return;
1235 1234
1236 /* Might be better not to do this - if the monster can fire a bow, 1235 /* 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 1236 * 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. 1237 * which case, it would be nice to have ammo for it.
1239 */ 1238 */
1240 if(QUERY_FLAG(mon,FLAG_USE_BOW) && item->type==ARROW) { 1239 if(QUERY_FLAG(mon,FLAG_USE_BOW) && item->type==ARROW) {
1241 /* Check for the right kind of bow */ 1240 /* Check for the right kind of bow */
1242 object *bow; 1241 object *bow;
1243 for(bow=mon->inv;bow!=NULL;bow=bow->below) 1242 for(bow=mon->inv;bow!=NULL;bow=bow->below)
1244 if(bow->type==BOW && bow->race==item->race) { 1243 if(bow->type==BOW && bow->race==item->race) {
1245 SET_FLAG(mon, FLAG_READY_BOW); 1244 SET_FLAG(mon, FLAG_READY_BOW);
1246 LOG(llevMonster,"Found correct bow for arrows.\n"); 1245 LOG(llevMonster,"Found correct bow for arrows.\n");
1247 return; /* nothing more to do for arrows */ 1246 return; /* nothing more to do for arrows */
1248 } 1247 }
1249 } 1248 }
1250 1249
1251 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE) flag=1; 1250 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE) flag=1;
1252 /* Eating food gets hp back */ 1251 /* Eating food gets hp back */
1253 else if (item->type == FOOD && mon->will_apply & WILL_APPLY_FOOD) flag=1; 1252 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 */ 1263 /* Should do something more, like make sure this is a better item */
1265 else if (item->type == RING) 1264 else if (item->type == RING)
1266 flag=1; 1265 flag=1;
1267 else if ( item->type==WAND || item->type == ROD || item->type==HORN ) 1266 else if ( item->type==WAND || item->type == ROD || item->type==HORN )
1268 { 1267 {
1269 /* We never really 'ready' the wand/rod/horn, because that would mean the 1268 /* We never really 'ready' the wand/rod/horn, because that would mean the
1270 * weapon would get undone. 1269 * weapon would get undone.
1271 */ 1270 */
1272 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK)) 1271 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1273 { 1272 {
1274 SET_FLAG(mon, FLAG_READY_RANGE); 1273 SET_FLAG(mon, FLAG_READY_RANGE);
1275 SET_FLAG(item, FLAG_APPLIED); 1274 SET_FLAG(item, FLAG_APPLIED);
1276 } 1275 }
1277 return; 1276 return;
1278 } 1277 }
1279 else if (item->type == BOW) { 1278 else if (item->type == BOW) {
1280 /* We never really 'ready' the bow, because that would mean the 1279 /* We never really 'ready' the bow, because that would mean the
1281 * weapon would get undone. 1280 * weapon would get undone.
1282 */ 1281 */
1283 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK)) 1282 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1284 SET_FLAG(mon, FLAG_READY_BOW); 1283 SET_FLAG(mon, FLAG_READY_BOW);
1285 return; 1284 return;
1286 } 1285 }
1287 else if ( item->type == SKILL ) 1286 else if ( item->type == SKILL )
1288 { 1287 {
1289 /* 1288 /*
1290 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set, 1289 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set,
… …
1323 object *npc; 1322 object *npc;
1324 sint16 sx, sy; 1323 sint16 sx, sy;
1325 mapstruct *m; 1324 mapstruct *m;
1326 1325
1327 for(x = -3; x < 4; x++) 1326 for(x = -3; x < 4; x++)
1328 for(y = -3; y < 4; y++) { 1327 for(y = -3; y < 4; y++) {
1329 m = op->map; 1328 m = op->map;
1330 sx = op->x + x; 1329 sx = op->x + x;
1331 sy = op->y + y; 1330 sy = op->y + y;
1332 mflags = get_map_flags(m, &m, sx, sy, &sx, &sy); 1331 mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);
1333 /* If nothing alive on this space, no need to search the space. */ 1332 /* If nothing alive on this space, no need to search the space. */
1334 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE)) 1333 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE))
1335 continue; 1334 continue;
1336 1335
1337 for(npc = get_map_ob(m,sx,sy);npc!=NULL;npc=npc->above) 1336 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)) 1337 if(QUERY_FLAG(npc, FLAG_ALIVE)&&QUERY_FLAG(npc, FLAG_UNAGGRESSIVE))
1339 npc->enemy = op->enemy; 1338 npc->enemy = op->enemy;
1340 } 1339 }
1341} 1340}
1342 1341
1343 1342
1344int dist_att (int dir , object *ob, object *enemy, object *part, rv_vector *rv) { 1343int dist_att (int dir , object *ob, object *enemy, object *part, rv_vector *rv) {
1345 1344
… …
1353} 1352}
1354 1353
1355int run_att (int dir, object *ob, object *enemy,object *part, rv_vector *rv) { 1354int run_att (int dir, object *ob, object *enemy,object *part, rv_vector *rv) {
1356 1355
1357 if ((can_hit (part,enemy,rv) && ob->move_status <20) || ob->move_status <20) { 1356 if ((can_hit (part,enemy,rv) && ob->move_status <20) || ob->move_status <20) {
1358 ob->move_status++; 1357 ob->move_status++;
1359 return (dir); 1358 return (dir);
1360 } 1359 }
1361 else if (ob->move_status >20) 1360 else if (ob->move_status >20)
1362 ob->move_status = 0; 1361 ob->move_status = 0;
1363 return absdir (dir+4); 1362 return absdir (dir+4);
1364} 1363}
1365 1364
1366int hitrun_att (int dir, object *ob,object *enemy) { 1365int hitrun_att (int dir, object *ob,object *enemy) {
1367 if (ob->move_status ++ < 25) 1366 if (ob->move_status ++ < 25)
1368 return dir; 1367 return dir;
1369 else if (ob->move_status <50) 1368 else if (ob->move_status <50)
1370 return absdir (dir+4); 1369 return absdir (dir+4);
1371 else 1370 else
1372 ob->move_status = 0; 1371 ob->move_status = 0;
1373 return absdir(dir+4); 1372 return absdir(dir+4);
1374} 1373}
1375 1374
1376int wait_att (int dir, object *ob,object *enemy,object *part,rv_vector *rv) { 1375int wait_att (int dir, object *ob,object *enemy,object *part,rv_vector *rv) {
1377 1376
1378 int inrange = can_hit (part, enemy,rv); 1377 int inrange = can_hit (part, enemy,rv);
1379 1378
1380 if (ob->move_status || inrange) 1379 if (ob->move_status || inrange)
1381 ob->move_status++; 1380 ob->move_status++;
1382 1381
1383 if (ob->move_status == 0) 1382 if (ob->move_status == 0)
1384 return 0; 1383 return 0;
1385 else if (ob->move_status <10) 1384 else if (ob->move_status <10)
1386 return dir; 1385 return dir;
1387 else if (ob->move_status <15) 1386 else if (ob->move_status <15)
1388 return absdir(dir+4); 1387 return absdir(dir+4);
1389 ob->move_status = 0; 1388 ob->move_status = 0;
1390 return 0; 1389 return 0;
1391} 1390}
1392 1391
1393int disthit_att (int dir, object *ob, object *enemy, object *part,rv_vector *rv) { 1392int 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 1397 * 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 1398 * 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 1399 * server should try to be resilant enough to avoid the problem
1401 */ 1400 */
1402 if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away) 1401 if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away)
1403 return absdir(dir+4); 1402 return absdir(dir+4);
1404 return dist_att (dir,ob,enemy,part,rv); 1403 return dist_att (dir,ob,enemy,part,rv);
1405} 1404}
1406 1405
1407int wait_att2 (int dir, object *ob,object *enemy,object *part, rv_vector *rv) { 1406int wait_att2 (int dir, object *ob,object *enemy,object *part, rv_vector *rv) {
1408 if (rv->distance < 9) 1407 if (rv->distance < 9)
1409 return absdir (dir+4); 1408 return absdir (dir+4);
1410 return 0; 1409 return 0;
1411} 1410}
1412 1411
1413void circ1_move (object *ob) { 1412void circ1_move (object *ob) {
1414 static int circle [12] = {3,3,4,5,5,6,7,7,8,1,1,2}; 1413 static int circle [12] = {3,3,4,5,5,6,7,7,8,1,1,2};
… …
1478} 1477}
1479 1478
1480void check_earthwalls(object *op, mapstruct *m, int x, int y) { 1479void check_earthwalls(object *op, mapstruct *m, int x, int y) {
1481 object *tmp; 1480 object *tmp;
1482 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1481 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
1483 if (tmp->type == EARTHWALL) { 1482 if (tmp->type == EARTHWALL) {
1484 hit_player(tmp,op->stats.dam,op,AT_PHYSICAL,1); 1483 hit_player(tmp,op->stats.dam,op,AT_PHYSICAL,1);
1485 return; 1484 return;
1486 } 1485 }
1487 } 1486 }
1488} 1487}
1489 1488
1490void check_doors(object *op, mapstruct *m, int x, int y) { 1489void check_doors(object *op, mapstruct *m, int x, int y) {
1491 object *tmp; 1490 object *tmp;
1492 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1491 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
1493 if (tmp->type == DOOR) { 1492 if (tmp->type == DOOR) {
1494 hit_player(tmp,1000,op,AT_PHYSICAL,1); 1493 hit_player(tmp,1000,op,AT_PHYSICAL,1);
1495 return; 1494 return;
1496 } 1495 }
1497 }
1498}
1499
1500/* This replaces all the msglang stuff about which seems to be a lot of
1501 * unneeded complication - since the setup of that data is never re-used
1502 * (say 'hi' to monster, then 'yes', it would re-do the entire parse-message)
1503 * it seems to me to make more sense to just have simple function that returns
1504 * the 'text' portion of the message that it matches - this savees us a bunch
1505 * of malloc's and free's, as well as that setup.
1506 * This function takes the message to be parsed in 'msg', the text to
1507 * match in 'match', and returns the portion of the message. This
1508 * returned portion is in a malloc'd buf that should be freed.
1509 * Returns NULL if no match is found.
1510 * The player is passed too, so that quest-related messages can be checked too.
1511 */
1512static char *find_matching_message(object* pl, const char *msg, const char *match)
1513{
1514 const char *cp=msg, *cp1, *cp2;
1515 char *cp3, regex[MAX_BUF], gotmatch=0;
1516
1517 while (1) {
1518 if (strncmp(cp, "@match ", 7)) {
1519 LOG(llevDebug,"find_matching_message: Invalid message %s", msg);
1520 return NULL;
1521 }
1522 else {
1523 /* Find the end of the line, and copy the regex portion into it */
1524 cp2 = strchr(cp+7, '\n');
1525 strncpy(regex, cp+7, (cp2 - cp -7 ));
1526 regex[cp2 - cp -7] = 0;
1527
1528 /* Find the next match command */
1529 cp1 = strstr(cp+6, "\n@match");
1530
1531 /* Got a match - handle * as special case - proper regex would be .*,
1532 * but lots of messages don't use that form.
1533 */
1534 if (regex[0] == '*') gotmatch=1;
1535 else {
1536 char *pipe, *pnext=NULL;
1537 /* need to parse all the | seperators. Our re_cmp isn't
1538 * realy a fully blown regex parser.
1539 */
1540 for (pipe=regex; pipe != NULL; pipe = pnext) {
1541 pnext = strchr(pipe, '|');
1542 if (pnext) {
1543 *pnext = 0;
1544 pnext ++;
1545 }
1546 if (re_cmp(match, pipe)) {
1547 gotmatch = 1;
1548 break;
1549 }
1550 }
1551 } 1496 }
1552 if (gotmatch) {
1553 if (cp1) {
1554 cp3 = (char*) malloc(cp1 - cp2 + 1);
1555 strncpy(cp3, cp2+1, cp1 - cp2);
1556 cp3[cp1 - cp2] = 0;
1557 }
1558 else { /* if no next match, just want the rest of the string */
1559 cp3 = strdup_local(cp2+1);
1560 }
1561 return cp3;
1562 }
1563 gotmatch = 0;
1564 if (cp1) cp = cp1 + 1;
1565 else return NULL;
1566 }
1567 }
1568 /* Should never get reached */
1569}
1570
1571/* This function looks for an object or creature that is listening.
1572 * I've disabled the bit that has only the first npc monster listen -
1573 * we'll see how this works out. only the first npc listens, which
1574 * is sort of bogus since it uses the free_arr which has a preference
1575 * to certain directions.
1576 *
1577 * There is a rare even that the orig_map is used for - basically, if
1578 * a player says the magic word that gets him teleported off the map,
1579 * it can result in the new map putting the object count too high,
1580 * which forces the swap out of some other map. In some cases, the
1581 * map the player was just on now gets swapped out - thus, the
1582 * object on that map are no longer in memory. So check to see if the
1583 * players map changes, and if so, don't process any further.
1584 * If it does change, most likely we don't care about the results
1585 * of further conversation. Also, depending on the value of i,
1586 * the conversation would continue on the new map, which probably isn't
1587 * what is really wanted either.
1588 */
1589void communicate(object *op, const char *txt) {
1590 object *npc;
1591 int i, mflags;
1592 sint16 x, y;
1593 mapstruct *mp, *orig_map = op->map;
1594
1595 int flag=1; /*hasn't spoken to a NPC yet*/
1596 for(i = 0; i <= SIZEOFFREE2; i++) {
1597
1598 mp = op->map;
1599 x = op->x + freearr_x[i];
1600 y = op->y + freearr_y[i];
1601
1602 mflags = get_map_flags(mp, &mp, x, y, &x, &y);
1603 if (mflags & P_OUT_OF_MAP) continue;
1604
1605 for(npc = get_map_ob(mp,x,y); npc != NULL; npc = npc->above) {
1606 if (npc->type == MAGIC_EAR) {
1607 (void) talk_to_wall(op, npc, txt); /* Maybe exit after 1. success? */
1608 if (orig_map != op->map) {
1609 LOG(llevDebug,"Warning: Forced to swap out very recent map - MAX_OBJECTS should probably be increased\n");
1610 return;
1611 }
1612 }
1613 else if (flag) {
1614#if 0
1615 if (talk_to_npc(op, npc,txt))
1616 flag=0; /* Can be crowded */
1617#else
1618 talk_to_npc(op, npc,txt);
1619#endif
1620 if (orig_map != op->map) {
1621 LOG(llevDebug,"Warning: Forced to swap out very recent map - MAX_OBJECTS should probably be increased\n");
1622 return;
1623 }
1624 }
1625 }
1626 }
1627}
1628
1629static int do_talk_npc(object* op, object* npc, object* override, const char* txt)
1630{
1631 char* cp;
1632 char buf[MAX_BUF];
1633
1634 if(override->msg == NULL || *override->msg != '@')
1635 return 0;
1636
1637 cp = find_matching_message(op, override->msg, txt);
1638 if (cp) {
1639 sprintf(buf,"%s says:",query_name(npc));
1640 new_info_map(NDI_NAVY|NDI_UNIQUE, npc->map,buf);
1641 new_info_map(NDI_NAVY | NDI_UNIQUE, npc->map, cp);
1642 quest_apply_items(override,op->contr);
1643 free(cp);
1644 return 1;
1645 }
1646 return 0;
1647}
1648
1649int talk_to_npc(object *op, object *npc, const char *txt) {
1650 object *cobj;
1651
1652 /* Move this commone area up here - shouldn't cost much extra cpu
1653 * time, and makes the function more readable */
1654 /* Lauwenmark: Handle for plugin say event */
1655 if (op==npc) return 0;
1656 if (execute_event(npc, EVENT_SAY,op,NULL,txt,SCRIPT_FIX_ALL)!=0)
1657 return 0;
1658 /* Lauwenmark - Here we let the objects inside inventories hear and answer, too. */
1659 /* This allows the existence of "intelligent" weapons you can discuss with */
1660 for(cobj=npc->inv;cobj!=NULL; cobj = cobj->below)
1661 {
1662 if (execute_event(cobj, EVENT_SAY,op,NULL,txt,SCRIPT_FIX_ALL)!=0)
1663 return 0;
1664 }
1665 for ( cobj = npc->inv; cobj; cobj = cobj->below )
1666 if ( quest_is_override_compatible( cobj, op ) )
1667 if ( do_talk_npc( op, npc, cobj, txt ) )
1668 return 1;
1669 return do_talk_npc( op, npc, npc, txt );
1670}
1671
1672static int do_talk_wall(object* pl, object* npc, object* override, const char* txt)
1673{
1674 char* cp;
1675 if(override->msg == NULL || *override->msg != '@')
1676 return 0;
1677
1678 cp = find_matching_message(pl, override->msg, txt);
1679 if (!cp)
1680 return 0;
1681
1682 new_info_map(NDI_NAVY | NDI_UNIQUE, npc->map,cp);
1683 use_trigger(npc);
1684 quest_apply_items(npc, pl->contr);
1685 free(cp);
1686
1687 return 1;
1688}
1689
1690int talk_to_wall(object* pl, object *npc, const char *txt) {
1691
1692 object* inv;
1693
1694 for ( inv = npc->inv; inv; inv = inv->below)
1695 if ( quest_is_override_compatible(inv, pl ) )
1696 if ( do_talk_wall( pl, npc, inv, txt ) )
1697 return 1;
1698
1699 return do_talk_wall( pl, npc, npc, txt );;
1700} 1497}
1701 1498
1702/* find_mon_throw_ob() - modeled on find_throw_ob 1499/* find_mon_throw_ob() - modeled on find_throw_ob
1703 * This is probably overly simplistic as it is now - We want 1500 * This is probably overly simplistic as it is now - We want
1704 * monsters to throw things like chairs and other pieces of 1501 * monsters to throw things like chairs and other pieces of
… …
1716 * marked item and throw it to the enemy. 1513 * marked item and throw it to the enemy.
1717 */ 1514 */
1718 1515
1719 for(tmp=op->inv;tmp;tmp=tmp->below) { 1516 for(tmp=op->inv;tmp;tmp=tmp->below) {
1720 1517
1721 /* Can't throw invisible objects or items that are applied */ 1518 /* Can't throw invisible objects or items that are applied */
1722 if(tmp->invisible || QUERY_FLAG(tmp,FLAG_APPLIED)) continue; 1519 if(tmp->invisible || QUERY_FLAG(tmp,FLAG_APPLIED)) continue;
1723 1520
1724 if(QUERY_FLAG(tmp,FLAG_IS_THROWN)) 1521 if(QUERY_FLAG(tmp,FLAG_IS_THROWN))
1725 break; 1522 break;
1726 1523
1727 } 1524 }
1728 1525
1729#ifdef DEBUG_THROW 1526#ifdef DEBUG_THROW
1730 LOG(llevDebug,"%s chooses to throw: %s (%d)\n",op->name, 1527 LOG(llevDebug,"%s chooses to throw: %s (%d)\n",op->name,
1731 !(tmp)?"(nothing)":query_name(tmp),tmp?tmp->count:-1); 1528 !(tmp)?"(nothing)":query_name(tmp),tmp?tmp->count:-1);
1732#endif 1529#endif
1733 1530
1734 return tmp; 1531 return tmp;
1735} 1532}
1736 1533
… …
1771 1568
1772 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE 1569 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1773 * flag (which was already checked) in can_see_enmy (). Lets get out of here 1570 * flag (which was already checked) in can_see_enmy (). Lets get out of here
1774 */ 1571 */
1775 if(enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden))) 1572 if(enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
1776 return 0; 1573 return 0;
1777 1574
1778 /* use this for invis also */ 1575 /* use this for invis also */
1779 hide_discovery = op->stats.Int/5; 1576 hide_discovery = op->stats.Int/5;
1780 1577
1781 /* Determine Detection radii */ 1578 /* Determine Detection radii */
1782 if(!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */ 1579 if(!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */
1783 radius = (op->stats.Wis/5)+1>MIN_MON_RADIUS?(op->stats.Wis/5)+1:MIN_MON_RADIUS; 1580 radius = (op->stats.Wis/5)+1>MIN_MON_RADIUS?(op->stats.Wis/5)+1:MIN_MON_RADIUS;
1784 else { /* a level/INT/Dex adjustment for hiding */ 1581 else { /* a level/INT/Dex adjustment for hiding */
1785 object *sk_hide; 1582 object *sk_hide;
1786 int bonus = (op->level/2) + (op->stats.Int/5); 1583 int bonus = (op->level/2) + (op->stats.Int/5);
1787 1584
1788 if(enemy->type==PLAYER) { 1585 if(enemy->type==PLAYER) {
1789 if((sk_hide = find_skill_by_number(enemy,SK_HIDING))) 1586 if((sk_hide = find_skill_by_number(enemy,SK_HIDING)))
1790 bonus -= sk_hide->level; 1587 bonus -= sk_hide->level;
1791 else { 1588 else {
1792 LOG(llevError,"can_detect_enemy() got hidden player w/o hiding skill!\n"); 1589 LOG(llevError,"can_detect_enemy() got hidden player w/o hiding skill!\n");
1793 make_visible(enemy); 1590 make_visible(enemy);
1794 radius=radius<MIN_MON_RADIUS?MIN_MON_RADIUS:radius; 1591 radius=radius<MIN_MON_RADIUS?MIN_MON_RADIUS:radius;
1795 } 1592 }
1796 } 1593 }
1797 else /* enemy is not a player */ 1594 else /* enemy is not a player */
1798 bonus -= enemy->level; 1595 bonus -= enemy->level;
1799 1596
1800 radius += bonus/5; 1597 radius += bonus/5;
1801 hide_discovery += bonus*5; 1598 hide_discovery += bonus*5;
1802 } /* else creature has modifiers for hiding */ 1599 } /* else creature has modifiers for hiding */
1803 1600
1804 /* Radii stealth adjustment. Only if you are stealthy 1601 /* Radii stealth adjustment. Only if you are stealthy
1805 * will you be able to sneak up closer to creatures */ 1602 * will you be able to sneak up closer to creatures */
1806 if(QUERY_FLAG(enemy,FLAG_STEALTH)) 1603 if(QUERY_FLAG(enemy,FLAG_STEALTH))
1807 radius = radius/2, hide_discovery = hide_discovery/3; 1604 radius = radius/2, hide_discovery = hide_discovery/3;
1808 1605
1809 /* Radii adjustment for enemy standing in the dark */ 1606 /* Radii adjustment for enemy standing in the dark */
1810 if(op->map->darkness>0 && !stand_in_light(enemy)) { 1607 if(op->map->darkness>0 && !stand_in_light(enemy)) {
1811 /* on dark maps body heat can help indicate location with infravision 1608 /* on dark maps body heat can help indicate location with infravision
1812 * undead don't have body heat, so no benefit detecting them. 1609 * undead don't have body heat, so no benefit detecting them.
1813 */ 1610 */
1814 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK) && !is_true_undead(enemy)) 1611 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK) && !is_true_undead(enemy))
1815 radius += op->map->darkness/2; 1612 radius += op->map->darkness/2;
1816 else 1613 else
1817 radius -= op->map->darkness/2; 1614 radius -= op->map->darkness/2;
1818 1615
1819 /* op next to a monster (and not in complete darkness) 1616 /* op next to a monster (and not in complete darkness)
1820 * the monster should have a chance to see you. 1617 * the monster should have a chance to see you.
1821 */ 1618 */
1822 if(radius<MIN_MON_RADIUS && op->map->darkness<5 && rv->distance<=1) 1619 if(radius<MIN_MON_RADIUS && op->map->darkness<5 && rv->distance<=1)
1823 radius = MIN_MON_RADIUS; 1620 radius = MIN_MON_RADIUS;
1824 } /* if on dark map */ 1621 } /* if on dark map */
1825 1622
1826 /* Lets not worry about monsters that have incredible detection 1623 /* Lets not worry about monsters that have incredible detection
1827 * radii, we only need to worry here about things the player can 1624 * radii, we only need to worry here about things the player can
1828 * (potentially) see. This is 13, as that is the maximum size the player 1625 * (potentially) see. This is 13, as that is the maximum size the player
… …
1833 */ 1630 */
1834 if(radius>13) radius = 13; 1631 if(radius>13) radius = 13;
1835 1632
1836 /* Enemy in range! Now test for detection */ 1633 /* Enemy in range! Now test for detection */
1837 if ((int) rv->distance <= radius) { 1634 if ((int) rv->distance <= radius) {
1838 /* ah, we are within range, detected? take cases */ 1635 /* ah, we are within range, detected? take cases */
1839 if(!enemy->invisible) /* enemy in dark squares... are seen! */ 1636 if(!enemy->invisible) /* enemy in dark squares... are seen! */
1840 return 1; 1637 return 1;
1841 1638
1842 /* hidden or low-quality invisible */ 1639 /* hidden or low-quality invisible */
1843 if(enemy->hide && (rv->distance <= 1) && (RANDOM()%100<=hide_discovery)) { 1640 if(enemy->hide && (rv->distance <= 1) && (RANDOM()%100<=hide_discovery)) {
1844 make_visible(enemy); 1641 make_visible(enemy);
1845 /* inform players of new status */ 1642 /* inform players of new status */
1846 if(enemy->type==PLAYER && player_can_view(enemy,op)) 1643 if(enemy->type==PLAYER && player_can_view(enemy,op))
1847 new_draw_info_format(NDI_UNIQUE,0, enemy, 1644 new_draw_info_format(NDI_UNIQUE,0, enemy,
1848 "You are discovered by %s!",op->name); 1645 "You are discovered by %s!",&op->name);
1849 return 1; /* detected enemy */ 1646 return 1; /* detected enemy */
1850 } 1647 }
1851 else if (enemy->invisible) { 1648 else if (enemy->invisible) {
1852 /* Change this around - instead of negating the invisible, just 1649 /* Change this around - instead of negating the invisible, just
1853 * return true so that the mosnter that managed to detect you can 1650 * return true so that the mosnter that managed to detect you can
1854 * do something to you. Decreasing the duration of invisible 1651 * do something to you. Decreasing the duration of invisible
1855 * doesn't make a lot of sense IMO, as a bunch of stupid creatures 1652 * doesn't make a lot of sense IMO, as a bunch of stupid creatures
1856 * can then basically negate the spell. The spell isn't negated - 1653 * can then basically negate the spell. The spell isn't negated -
1857 * they just know where you are! 1654 * they just know where you are!
1858 */ 1655 */
1859 if ((RANDOM() % 50) <= hide_discovery) { 1656 if ((RANDOM() % 50) <= hide_discovery) {
1860 if (enemy->type == PLAYER) { 1657 if (enemy->type == PLAYER) {
1861 new_draw_info_format(NDI_UNIQUE,0, enemy, 1658 new_draw_info_format(NDI_UNIQUE,0, enemy,
1862 "You see %s noticing your position.", query_name(op)); 1659 "You see %s noticing your position.", query_name(op));
1863 } 1660 }
1864 return 1; 1661 return 1;
1865 } 1662 }
1866 } 1663 }
1867 } /* within range */ 1664 } /* within range */
1868 1665
1869 /* Wasn't detected above, so still hidden */ 1666 /* Wasn't detected above, so still hidden */
1870 return 0; 1667 return 0;
1871} 1668}
… …
1883 1680
1884 if(!op) return 0; 1681 if(!op) return 0;
1885 if(op->glow_radius > 0) return 1; 1682 if(op->glow_radius > 0) return 1;
1886 1683
1887 if(op->map) { 1684 if(op->map) {
1888 int x, y, x1, y1; 1685 int x, y, x1, y1;
1889 1686
1890 1687
1891 1688
1892 /* Check the spaces with the max light radius to see if any of them 1689 /* Check the spaces with the max light radius to see if any of them
1893 * have lights, and if any of them light the player enough, then return 1. 1690 * have lights, and if any of them light the player enough, then return 1.
1894 */ 1691 */
1895 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) { 1692 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) {
1896 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) { 1693 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) {
1897 m = op->map; 1694 m = op->map;
1898 nx = x; 1695 nx = x;
1899 ny = y; 1696 ny = y;
1900 1697
1901 if (get_map_flags(m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) continue; 1698 if (get_map_flags(m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) continue;
1902 1699
1903 x1 = abs(x - op->x)*abs(x - op->x); 1700 x1 = abs(x - op->x)*abs(x - op->x);
1904 y1 = abs(y - op->y)*abs(y - op->y); 1701 y1 = abs(y - op->y)*abs(y - op->y);
1905 if (isqrt(x1 + y1) < GET_MAP_LIGHT(m, nx, ny)) return 1; 1702 if (isqrt(x1 + y1) < GET_MAP_LIGHT(m, nx, ny)) return 1;
1906 } 1703 }
1907 } 1704 }
1908 } 1705 }
1909 return 0; 1706 return 0;
1910} 1707}
1911 1708
1912 1709
… …
1919int can_see_enemy (object *op, object *enemy) { 1716int can_see_enemy (object *op, object *enemy) {
1920 object *looker = op->head?op->head:op; 1717 object *looker = op->head?op->head:op;
1921 1718
1922 /* safety */ 1719 /* safety */
1923 if(!looker||!enemy||!QUERY_FLAG(looker,FLAG_ALIVE)) 1720 if(!looker||!enemy||!QUERY_FLAG(looker,FLAG_ALIVE))
1924 return 0; 1721 return 0;
1925 1722
1926 /* we dont give a full treatment of xrays here (shorter range than normal, 1723 /* we dont give a full treatment of xrays here (shorter range than normal,
1927 * see through walls). Should we change the code elsewhere to make you 1724 * see through walls). Should we change the code elsewhere to make you
1928 * blind even if you can xray? 1725 * blind even if you can xray?
1929 */ 1726 */
1930 if(QUERY_FLAG(looker,FLAG_BLIND) && !QUERY_FLAG(looker,FLAG_XRAYS)) 1727 if(QUERY_FLAG(looker,FLAG_BLIND) && !QUERY_FLAG(looker,FLAG_XRAYS))
1931 return 0; 1728 return 0;
1932 1729
1933 /* checking for invisible things */ 1730 /* checking for invisible things */
1934 if(enemy->invisible) { 1731 if(enemy->invisible) {
1935 /* HIDDEN ENEMY. by definition, you can't see hidden stuff! 1732 /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1936 * However,if you carry any source of light, then the hidden 1733 * However,if you carry any source of light, then the hidden
1937 * creature is seeable (and stupid) */ 1734 * creature is seeable (and stupid) */
1938 1735
1939 if(has_carried_lights(enemy)) { 1736 if(has_carried_lights(enemy)) {
1940 if(enemy->hide) { 1737 if(enemy->hide) {
1941 make_visible(enemy); 1738 make_visible(enemy);
1942 new_draw_info(NDI_UNIQUE,0, enemy, 1739 new_draw_info(NDI_UNIQUE,0, enemy,
1943 "Your light reveals your hiding spot!"); 1740 "Your light reveals your hiding spot!");
1944 } 1741 }
1945 return 1; 1742 return 1;
1946 } else if (enemy->hide) return 0; 1743 } else if (enemy->hide) return 0;
1947 1744
1948 /* Invisible enemy. Break apart the check for invis undead/invis looker 1745 /* Invisible enemy. Break apart the check for invis undead/invis looker
1949 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values, 1746 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
1950 * and making it a conditional makes the code pretty ugly. 1747 * and making it a conditional makes the code pretty ugly.
1951 */ 1748 */
1952 if (!QUERY_FLAG(looker,FLAG_SEE_INVISIBLE)) { 1749 if (!QUERY_FLAG(looker,FLAG_SEE_INVISIBLE)) {
1953 if (makes_invisible_to(enemy, looker)) return 0; 1750 if (makes_invisible_to(enemy, looker)) return 0;
1954 } 1751 }
1955 } else if(looker->type==PLAYER) /* for players, a (possible) shortcut */ 1752 } else if(looker->type==PLAYER) /* for players, a (possible) shortcut */
1956 if(player_can_view(looker,enemy)) return 1; 1753 if(player_can_view(looker,enemy)) return 1;
1957 1754
1958 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen 1755 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1959 * unless they carry a light or stand in light. Darkness doesnt 1756 * unless they carry a light or stand in light. Darkness doesnt

Diff Legend

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