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.56 by root, Sat Dec 27 08:41:44 2008 UTC vs.
Revision 1.66 by root, Fri Sep 25 18:58:47 2009 UTC

… …
236{ 236{
237 /* Trim work - if no enemy, no need to do anything below */ 237 /* Trim work - if no enemy, no need to do anything below */
238 if (!enemy) 238 if (!enemy)
239 return 0; 239 return 0;
240 240
241 if (!op->flag [FLAG_SLEEP])
242 return 1;
243
241 int radius = max (op->stats.Wis, MIN_MON_RADIUS); 244 int radius = max (op->stats.Wis, MIN_MON_RADIUS);
242 245
243 if (op->flag [FLAG_BLIND]) 246 if (op->flag [FLAG_BLIND])
244 /* blinded monsters can only find nearby objects to attack */ 247 /* blinded monsters can only find nearby objects to attack */
245 radius = MIN_MON_RADIUS; 248 radius = MIN_MON_RADIUS;
… …
251 * and has an enemy. If the enemy has no carried light (or isnt 254 * and has an enemy. If the enemy has no carried light (or isnt
252 * glowing!) then the monster has trouble finding the enemy. 255 * glowing!) then the monster has trouble finding the enemy.
253 * Remember we already checked to see if the monster can see in 256 * Remember we already checked to see if the monster can see in
254 * the dark. */ 257 * the dark. */
255 radius = min (radius, MIN_MON_RADIUS + MAX_DARKNESS - op->map->darklevel ()); 258 radius = min (radius, MIN_MON_RADIUS + MAX_DARKNESS - op->map->darklevel ());
256 else if (!op->flag [FLAG_SLEEP])
257 return 1;
258 259
259 if (enemy->flag [FLAG_STEALTH]) 260 if (enemy->flag [FLAG_STEALTH])
260 radius = radius / 2 + 1; 261 radius = radius / 2 + 1;
261 262
262 /* enemy should already be on this map, so don't really need to check 263 /* enemy should already be on this map, so don't really need to check
… …
389 { 390 {
390 if (op->attack_movement & HI4) 391 if (op->attack_movement & HI4)
391 { 392 {
392 switch (op->attack_movement & HI4) 393 switch (op->attack_movement & HI4)
393 { 394 {
394 case (PETMOVE): 395 case PETMOVE:
395 pet_move (op); 396 pet_move (op);
396 break; 397 break;
397 398
398 case (CIRCLE1): 399 case CIRCLE1:
399 circ1_move (op); 400 circ1_move (op);
400 break; 401 break;
401 402
402 case (CIRCLE2): 403 case CIRCLE2:
403 circ2_move (op); 404 circ2_move (op);
404 break; 405 break;
405 406
406 case (PACEV): 407 case PACEV:
407 pace_movev (op); 408 pace_movev (op);
408 break; 409 break;
409 410
410 case (PACEH): 411 case PACEH:
411 pace_moveh (op); 412 pace_moveh (op);
412 break; 413 break;
413 414
414 case (PACEV2): 415 case PACEV2:
415 pace2_movev (op); 416 pace2_movev (op);
416 break; 417 break;
417 418
418 case (PACEH2): 419 case PACEH2:
419 pace2_moveh (op); 420 pace2_moveh (op);
420 break; 421 break;
421 422
422 case (RANDO): 423 case RANDO:
423 rand_move (op); 424 rand_move (op);
424 break; 425 break;
425 426
426 case (RANDO2): 427 case RANDO2:
427 move_randomly (op); 428 move_randomly (op);
428 break; 429 break;
429 } 430 }
430 431
431 return 0; 432 return 0;
… …
446 447
447 /* doppleganger code to change monster facing to that of the nearest 448 /* doppleganger code to change monster facing to that of the nearest
448 * player. Hmm. The code is here, but no monster in the current 449 * player. Hmm. The code is here, but no monster in the current
449 * arch set uses it. 450 * arch set uses it.
450 */ 451 */
451 if (op->race && strcmp (op->race, "doppleganger") == 0) 452 if (op->race == shstr_doppleganger)
452 { 453 {
453 op->face = enemy->face; 454 op->face = enemy->face;
454 op->name = enemy->name; 455 op->name = enemy->name;
455 } 456 }
456 457
… …
507 } /* If not scared */ 508 } /* If not scared */
508 509
509 part = rv.part; 510 part = rv.part;
510 dir = rv.direction; 511 dir = rv.direction;
511 512
512#if DEVEL
513 // if the enemy is a player, we have los. if los says we 513 // if the enemy is a player, we have los. if los says we
514 // can directly reach the player, we do not deviate. 514 // can directly reach the player, we do not deviate.
515 // for non-players, we never deviate 515 // for non-players, we never deviate
516 if (op->stats.Wis >= 8
516 if (enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED) 517 && enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED)
517 { 518 {
518 int sdir = 0; 519 int sdir = 0;
520 uint32_t &smell = op->ms ().smell;
519 521
520 for (int dir = 1; dir <= 8; ++dir) 522 for (int ndir = 1; ndir <= 8; ++ndir)
521 { 523 {
522 mapxy pos (op); pos.move (dir); 524 mapxy pos (op); pos.move (ndir);
525
523 if (pos.normalise ()) 526 if (pos.normalise ())
524 { 527 {
525 mapspace &ms = pos.ms (); 528 mapspace &ms = pos.ms ();
526 529
527 if (ms.smell > op->ms ().smell) 530 if (ms.smell > smell)
528 { 531 {
529 printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D 532 //printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D
530 op->ms ().smell = ms.smell - 1; 533 if (op->stats.Wis >= 10)
534 smell = ms.smell - 1; // smarter: tell others
535
531 sdir = dir; 536 sdir = ndir;
532 537
533 // perturbing the path might let the monster lose track, 538 // perturbing the path might let the monster lose track,
534 // but it will also wide the actual path, spreading information 539 // but it will also widen the actual path, spreading information
535 if (!rndm (20)) 540 if (op->stats.Wis >= 15 && !rndm (20)) // even smarter, deviate and spread?
536 sdir += absdir (1 - rndm (2) * 2); 541 sdir = absdir (sdir + 1 - rndm (2) * 2);
537 } 542 }
538 } 543 }
539 } 544 }
540 545
541 if (sdir) 546 if (sdir)
542 dir = sdir; 547 dir = sdir;
543 else 548 else if (smell)
549 {
544 // no better smell found, so assume the player jumped, and erase this smell 550 // no better smell found, so assume the player jumped, and erase this smell
545 {if (op->ms ().smell) printf ("erasing smell %d\n", op->ms ().smell);//D 551 //printf ("erasing smell %d\n", op->ms ().smell);//D
546 ordered_mapwalk_begin (op, -1, -1, 1, 1) 552 unordered_mapwalk (op, -1, -1, 1, 1)
547 if (m)
548 m->at (nx, ny).smell = 0; 553 m->at (nx, ny).smell = 0;
549 ordered_mapwalk_end
550 }//D 554 }
551 } 555 }
552
553#endif
554 556
555 if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY)) 557 if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
556 dir = absdir (dir + 4); 558 dir = absdir (dir + 4);
557 559
558 if (QUERY_FLAG (op, FLAG_CONFUSED)) 560 if (QUERY_FLAG (op, FLAG_CONFUSED))
… …
704 return 1; 706 return 1;
705 707
706 /* check all the parts of ob2 - just because we can't get to 708 /* check all the parts of ob2 - just because we can't get to
707 * its head doesn't mean we don't want to pound its feet 709 * its head doesn't mean we don't want to pound its feet
708 */ 710 */
709 for (more = ob2->more; more != NULL; more = more->more) 711 for (more = ob2->more; more; more = more->more)
710 { 712 {
711 get_rangevector (ob1, more, &rv1, 0); 713 get_rangevector (ob1, more, &rv1, 0);
712 if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2) 714 if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
713 return 1; 715 return 1;
714 } 716 }
… …
1195 flag = 1; 1197 flag = 1;
1196 1198
1197 else 1199 else
1198 switch (item->type) 1200 switch (item->type)
1199 { 1201 {
1200 case MONEY: 1202 case MONEY:
1201 case GEM: 1203 case GEM:
1202 flag = monster->pick_up & 2; 1204 flag = monster->pick_up & 2;
1203 break; 1205 break;
1204 1206
1205 case FOOD: 1207 case FOOD:
1206 flag = monster->pick_up & 4; 1208 flag = monster->pick_up & 4;
1207 break; 1209 break;
1208 1210
1209 case WEAPON: 1211 case WEAPON:
1210 flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON); 1212 flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1211 break; 1213 break;
1212 1214
1213 case ARMOUR: 1215 case ARMOUR:
1214 case SHIELD: 1216 case SHIELD:
1215 case HELMET: 1217 case HELMET:
1216 case BOOTS: 1218 case BOOTS:
1217 case GLOVES: 1219 case GLOVES:
1218 case GIRDLE: 1220 case GIRDLE:
1219 flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR); 1221 flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1220 break; 1222 break;
1221 1223
1222 case SKILL: 1224 case SKILL:
1223 flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL); 1225 flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1224 break; 1226 break;
1225 1227
1226 case RING: 1228 case RING:
1227 flag = QUERY_FLAG (monster, FLAG_USE_RING); 1229 flag = QUERY_FLAG (monster, FLAG_USE_RING);
1228 break; 1230 break;
1229 1231
1230 case WAND: 1232 case WAND:
1231 case HORN: 1233 case HORN:
1232 case ROD: 1234 case ROD:
1233 flag = QUERY_FLAG (monster, FLAG_USE_RANGE); 1235 flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1234 break; 1236 break;
1235 1237
1236 case SPELLBOOK: 1238 case SPELLBOOK:
1237 flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL); 1239 flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1238 break; 1240 break;
1239 1241
1240 case SCROLL: 1242 case SCROLL:
1241 flag = QUERY_FLAG (monster, FLAG_USE_SCROLL); 1243 flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1242 break; 1244 break;
1243 1245
1244 case BOW: 1246 case BOW:
1245 case ARROW: 1247 case ARROW:
1246 flag = QUERY_FLAG (monster, FLAG_USE_BOW); 1248 flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1247 break; 1249 break;
1248 } 1250 }
1249 1251
1250 /* Simplistic check - if the monster has a location to equip it, he will 1252 /* Simplistic check - if the monster has a location to equip it, he will
1251 * pick it up. Note that this doesn't handle cases where an item may 1253 * pick it up. Note that this doesn't handle cases where an item may
1252 * use several locations. 1254 * use several locations.
… …
1418} 1420}
1419 1421
1420void 1422void
1421npc_call_help (object *op) 1423npc_call_help (object *op)
1422{ 1424{
1423 int x, y, mflags; 1425 unordered_mapwalk (op, -7, -7, 7, 7)
1424 object *npc;
1425 sint16 sx, sy;
1426 maptile *m;
1427
1428 for (x = -3; x < 4; x++)
1429 for (y = -3; y < 4; y++)
1430 { 1426 {
1431 m = op->map; 1427 mapspace &ms = m->at (nx, ny);
1432 sx = op->x + x; 1428
1433 sy = op->y + y;
1434 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1435 /* If nothing alive on this space, no need to search the space. */ 1429 /* If nothing alive on this space, no need to search the space. */
1436 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE)) 1430 if (!(ms.flags () & P_IS_ALIVE))
1437 continue; 1431 continue;
1438 1432
1439 for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above) 1433 for (object *npc = ms.bot; npc; npc = npc->above)
1440 if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE)) 1434 if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1441 npc->enemy = op->enemy; 1435 npc->enemy = op->enemy;
1442 } 1436 }
1443} 1437}
1444 1438
1445int 1439int
1446dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1440dist_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1447{ 1441{
1448 if (can_hit (part, enemy, rv)) 1442 if (can_hit (part, enemy, rv))
1449 return dir; 1443 return dir;
1450 1444
1451 if (rv->distance < 10) 1445 if (rv->distance < 10)
… …
1455 1449
1456 return 0; 1450 return 0;
1457} 1451}
1458 1452
1459int 1453int
1460run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1454run_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1461{ 1455{
1462 if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20) 1456 if (can_hit (part, enemy, rv))
1463 {
1464 ob->move_status++;
1465 return (dir); 1457 return dir;
1466 } 1458 else
1467 else if (ob->move_status > 20)
1468 ob->move_status = 0;
1469
1470 return absdir (dir + 4); 1459 return absdir (dir + 4);
1471} 1460}
1472 1461
1473int 1462int
1474hitrun_att (int dir, object *ob, object *enemy) 1463hitrun_att (int dir, object *ob, object *enemy)
1475{ 1464{
… …
1484} 1473}
1485 1474
1486int 1475int
1487wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1476wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1488{ 1477{
1489
1490 int inrange = can_hit (part, enemy, rv); 1478 int inrange = can_hit (part, enemy, rv);
1491 1479
1492 if (ob->move_status || inrange) 1480 if (ob->move_status || inrange)
1493 ob->move_status++; 1481 ob->move_status++;
1494 1482
… …
1504} 1492}
1505 1493
1506int 1494int
1507disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1495disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1508{ 1496{
1509
1510 /* The logic below here looked plain wrong before. Basically, what should 1497 /* The logic below here looked plain wrong before. Basically, what should
1511 * happen is that if the creatures hp percentage falls below run_away, 1498 * happen is that if the creatures hp percentage falls below run_away,
1512 * the creature should run away (dir+4) 1499 * the creature should run away (dir+4)
1513 * I think its wrong for a creature to have a zero maxhp value, but 1500 * I think its wrong for a creature to have a zero maxhp value, but
1514 * at least one map has this set, and whatever the map contains, the 1501 * at least one map has this set, and whatever the map contains, the
… …
1688 * Returns 0 if enemy can not be detected, 1 if it is detected 1675 * Returns 0 if enemy can not be detected, 1 if it is detected
1689 */ 1676 */
1690int 1677int
1691can_detect_enemy (object *op, object *enemy, rv_vector * rv) 1678can_detect_enemy (object *op, object *enemy, rv_vector * rv)
1692{ 1679{
1693 int radius = MIN_MON_RADIUS, hide_discovery;
1694
1695 /* null detection for any of these condtions always */ 1680 /* null detection for any of these condtions always */
1696 if (!op || !enemy || !op->map || !enemy->map) 1681 if (!op || !enemy || !op->map || !enemy->map)
1697 return 0; 1682 return 0;
1698 1683
1699 /* If the monster (op) has no way to get to the enemy, do nothing */ 1684 /* If the monster (op) has no way to get to the enemy, do nothing */
… …
1701 return 0; 1686 return 0;
1702 1687
1703 get_rangevector (op, enemy, rv, 0); 1688 get_rangevector (op, enemy, rv, 0);
1704 1689
1705 /* Monsters always ignore the DM */ 1690 /* Monsters always ignore the DM */
1706 if (op->type != PLAYER && QUERY_FLAG (enemy, FLAG_WIZ)) 1691 if (!op->is_player () && QUERY_FLAG (enemy, FLAG_WIZ))
1707 return 0; 1692 return 0;
1708 1693
1709 /* simple check. Should probably put some range checks in here. */ 1694 /* simple check. Should probably put some range checks in here. */
1710 if (can_see_enemy (op, enemy)) 1695 if (can_see_enemy (op, enemy))
1711 return 1; 1696 return 1;
1712 1697
1713 /* The rest of this is for monsters. Players are on their own for 1698 /* The rest of this is for monsters. Players are on their own for
1714 * finding enemies! 1699 * finding enemies!
1715 */ 1700 */
1716 if (op->type == PLAYER) 1701 if (op->is_player ())
1717 return 0; 1702 return 0;
1718 1703
1719 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE 1704 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1720 * flag (which was already checked) in can_see_enmy (). Lets get out of here 1705 * flag (which was already checked) in can_see_enemy (). Lets get out of here
1721 */ 1706 */
1722 if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden))) 1707 if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
1723 return 0; 1708 return 0;
1724 1709
1710 int radius = MIN_MON_RADIUS;
1711
1725 /* use this for invis also */ 1712 /* use this for invis also */
1726 hide_discovery = op->stats.Int / 5; 1713 int hide_discovery = op->stats.Int / 5;
1727 1714
1728 /* Determine Detection radii */ 1715 /* Determine Detection radii */
1729 if (!enemy->flag [FLAG_HIDDEN]) /* to detect non-hidden (eg dark/invis enemy) */ 1716 if (!enemy->flag [FLAG_HIDDEN]) /* to detect non-hidden (eg dark/invis enemy) */
1730 radius = max (MIN_MON_RADIUS, op->stats.Wis / 5 + 1); 1717 radius = max (MIN_MON_RADIUS, op->stats.Wis / 3 + 1);
1731 else 1718 else
1732 { /* a level/INT/Dex adjustment for hiding */ 1719 { /* a level/INT/Dex adjustment for hiding */
1733 int bonus = op->level / 2 + op->stats.Int / 5; 1720 int bonus = op->level / 2 + op->stats.Int / 5;
1734 1721
1735 if (enemy->is_player ()) 1722 if (enemy->is_player ())
… …
1757 radius /= 2; 1744 radius /= 2;
1758 hide_discovery /= 3; 1745 hide_discovery /= 3;
1759 } 1746 }
1760 1747
1761 /* Radii adjustment for enemy standing in the dark */ 1748 /* Radii adjustment for enemy standing in the dark */
1762 if (op->map->darklevel () > 0 && !stand_in_light (enemy)) 1749 if (!stand_in_light (enemy))
1763 { 1750 {
1764 /* on dark maps body heat can help indicate location with infravision 1751 /* on dark maps body heat can help indicate location with infravision
1765 * undead don't have body heat, so no benefit detecting them. 1752 * undead don't have body heat, so no benefit detecting them.
1766 */ 1753 */
1767 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !is_true_undead (enemy)) 1754 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !is_true_undead (enemy))
… …
1770 radius -= op->map->darklevel () / 2; 1757 radius -= op->map->darklevel () / 2;
1771 1758
1772 /* op next to a monster (and not in complete darkness) 1759 /* op next to a monster (and not in complete darkness)
1773 * the monster should have a chance to see you. 1760 * the monster should have a chance to see you.
1774 */ 1761 */
1775 if (radius < MIN_MON_RADIUS && op->map->darklevel () < 5 && rv->distance <= 1) 1762 if (radius < MIN_MON_RADIUS && op->map->darklevel () < MAX_DARKNESS && rv->distance <= 1)
1776 radius = MIN_MON_RADIUS; 1763 radius = MIN_MON_RADIUS;
1777 } /* if on dark map */ 1764 } /* if on dark map */
1778 1765
1779 /* Lets not worry about monsters that have incredible detection 1766 /* Lets not worry about monsters that have incredible detection
1780 * radii, we only need to worry here about things the player can 1767 * radii, we only need to worry here about things the player can
… …
1828 /* Wasn't detected above, so still hidden */ 1815 /* Wasn't detected above, so still hidden */
1829 return 0; 1816 return 0;
1830} 1817}
1831 1818
1832/* determine if op stands in a lighted square. This is not a very 1819/* determine if op stands in a lighted square. This is not a very
1833 * intellegent algorithm. For one thing, we ignore los here, SO it 1820 * intelligent algorithm. For one thing, we ignore los here, SO it
1834 * is possible for a bright light to illuminate a player on the 1821 * is possible for a bright light to illuminate a player on the
1835 * other side of a wall (!). 1822 * other side of a wall (!).
1836 */ 1823 */
1837int 1824int
1838stand_in_light (object *op) 1825stand_in_light (object *op)
1839{ 1826{
1840 if (op) 1827 if (op)
1841 { 1828 {
1829 if (!op->is_on_map ())
1830 return 0;
1831
1832 if (op->map->darklevel () <= 0)
1833 return 1;
1834
1842 if (op->glow_radius > 0) 1835 if (op->glow_radius > 0)
1843 return 1; 1836 return 1;
1844 1837
1845 if (op->map) 1838 if (op->map)
1846 unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS) 1839 unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
… …
1884 { 1877 {
1885 /* HIDDEN ENEMY. by definition, you can't see hidden stuff! 1878 /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1886 * However,if you carry any source of light, then the hidden 1879 * However,if you carry any source of light, then the hidden
1887 * creature is seeable (and stupid) */ 1880 * creature is seeable (and stupid) */
1888 1881
1889 if (has_carried_lights (enemy)) 1882 if (enemy->has_carried_lights ())
1890 { 1883 {
1891 if (enemy->flag [FLAG_HIDDEN]) 1884 if (enemy->flag [FLAG_HIDDEN])
1892 { 1885 {
1893 make_visible (enemy); 1886 make_visible (enemy);
1894 new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!"); 1887 new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");
… …
1918 * we care about the enemy maps status, not the looker. 1911 * we care about the enemy maps status, not the looker.
1919 * only relevant for tiled maps, but it is possible that the 1912 * only relevant for tiled maps, but it is possible that the
1920 * enemy is on a bright map and the looker on a dark - in that 1913 * enemy is on a bright map and the looker on a dark - in that
1921 * case, the looker can still see the enemy 1914 * case, the looker can still see the enemy
1922 */ 1915 */
1923 if (enemy->map->darklevel () > 0
1924 && !stand_in_light (enemy) 1916 if (!stand_in_light (enemy)
1925 && (!QUERY_FLAG (looker, FLAG_SEE_IN_DARK) || !is_true_undead (looker) || !QUERY_FLAG (looker, FLAG_XRAYS))) 1917 && (!QUERY_FLAG (looker, FLAG_SEE_IN_DARK) || !is_true_undead (looker) || !QUERY_FLAG (looker, FLAG_XRAYS)))
1926 return 0; 1918 return 0;
1927 1919
1928 return 1; 1920 return 1;
1929} 1921}

Diff Legend

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