[ViewVC] Diff of: cvs/deliantra/server/server/monster.C

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.96 by root, Wed Nov 16 23:42:02 2016 UTC vs.
Revision 1.101 by root, Wed Dec 5 19:03:27 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
  * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
         npc->enemy = npc->owner->enemy;
     }
   /* periodically, a monster may change its target.  Also, if the object
    * has been destroyed, etc, clear the enemy.
    * TODO: this should be changed, because it invokes to attack forced or
    * attacked monsters to leave the attacker alone, before it is destroyed
    */
   /* I had removed the random target leave, this invokes problems with friendly
    * objects, getting attacked and defending herself - they don't try to attack
    * again then but perhaps get attack on and on
    * If we include a aggravated flag in , we can handle evil vs evil and good vs good
    * too. */
   if (npc->enemy)
     {
  * of direction, revisit them after looking at all the other spaces.
  *
  * Note that being this may skip some number of spaces, it will
  * not necessarily find the nearest living creature - it basically
  * chooses one from within a 3 space radius, and since it skips
  * the first few directions, it could very well choose something
  * 3 spaces away even though something directly north is closer.
  *
  * this function is map tile aware.
  */
 object *
   for (i = 0; i < SIZEOFFREE; i++)
     {
       /* modified to implement smart searching using search_arr
        * guidance array to determine direction of search order
        */
-      nx = npc->x + freearr_x[search_arr[i]];
+      nx = npc->x + DIRX (search_arr[i]);
-      ny = npc->y + freearr_y[search_arr[i]];
+      ny = npc->y + DIRY (search_arr[i]);
       m = npc->map;
       mflags = get_map_flags (m, &m, nx, ny, &nx, &ny);
       if (mflags & P_OUT_OF_MAP)
       return tmp;
     }
   /* Here is the main enemy selection.
    * We want this: if there is an enemy, attack him until its not possible or
    * one of both is dead.
    * If we have no enemy and we are...
    * a monster: try to find a player, a pet or a friendly monster
    * a friendly: only target a monster which is targeting you first or targeting a player
    * a neutral: fight a attacker (but there should be none), then do nothing
     radius = MIN_MON_RADIUS;
   else if (op->map
            && !enemy->invisible
            && !stand_in_light (enemy)
            && (!op->flag[FLAG_SEE_IN_DARK] || !op->flag [FLAG_SEE_INVISIBLE]))
     /* This covers the situation where the monster is in the dark
      * and has an enemy. If the enemy has no carried light (or isnt
      * glowing!) then the monster has trouble finding the enemy.
      * Remember we already checked to see if the monster can see in
      * the dark. */
     min_it (radius, MIN_MON_RADIUS + MAX_DARKNESS - op->map->darklevel ());
   if (enemy->flag [FLAG_STEALTH])
     radius = radius / 2 + 1;
           flag = 1;
           break;
         }
     }
-  if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
+  if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && !flag))
     return 1;
   return 0;
 }
  * affect stacking on this space.
  */
 static void
 monster_check_pickup (object *monster)
 {
-  object *tmp, *next;
-  for (tmp = monster->below; tmp != NULL; tmp = next)
+  for (object *next, *tmp = monster->below; tmp; tmp = next)
     {
       next = tmp->below;
       if (monster_can_pick (monster, tmp))
         {
           tmp->remove ();
           tmp = insert_ob_in_ob (tmp, monster);
           monster_check_apply (monster, tmp);
   val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL]) / 5;
   val += (item->magic - other_armour->magic) * 3;
   /* for the other protections, do weigh them very much in the equation -
    * it is the armor protection which is most important, because there is
    * no good way to know what the player may attack the monster with.
    * So if the new item has better protection than the old, give that higher
    * value.  If the reverse, then decrease the value of this item some.
    */
   for (i = 1; i < NROFATTACKS; i++)
     {
       mon->set_flag (FLAG_READY_SKILL);
       return;
     }
   /* if we don't match one of the above types, return now.
    * can_apply_object will say that we can apply things like flesh,
    * bolts, and whatever else, because it only checks against the
    * body_info locations.
    */
   if (!flag)
     return;
   object *owner;
   rv_vector rv1;
   /* If you want monsters to cast spells over friends, this spell should
    * be removed.  It probably should be in most cases, since monsters still
    * don't care about residual effects (ie, casting a cone which may have a
    * clear path to the player, the side aspects of the code will still hit
    * other monsters)
    */
   if (!(dir = path_to_player (part, pl, 0)))
     return 0;
   object *owner;
   rv_vector rv1;
   /* If you want monsters to cast spells over friends, this spell should
    * be removed.  It probably should be in most cases, since monsters still
    * don't care about residual effects (ie, casting a cone which may have a
    * clear path to the player, the side aspects of the code will still hit
    * other monsters)
    */
   if (!(dir = path_to_player (part, pl, 0)))
     return 0;
 /* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
  * Note that monsters do not need the skills SK_MELEE_WEAPON and
  * SK_MISSILE_WEAPON to make those respective attacks, if we
  * required that we would drastically increase the memory
  * requirements of CF!!
  *
  * The skills we are treating here are all but those. -b.t.
  *
  * At the moment this is only useful for throwing, perhaps for
  * stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
  */
 static int
   if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
     {
       /* last heal is in funny units.  Dividing by speed puts
        * the regeneration rate on a basis of time instead of
        * #moves the monster makes.  The scaling by 8 is
        * to capture 8th's of a hp fraction regens
        */
       uint32_t last_heal = op->last_heal + op->stats.Con * 8 / op->speed;
       op->stats.hp = min (op->stats.hp + last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
       op->last_heal = last_heal % 32;
   if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
     {
       /* last_sp is in funny units. Dividing by speed puts
        * the regeneration rate on a basis of time instead of
        * #moves the monster makes. The scaling by 8 is
        * to capture 8th's of a sp fraction regens
        */
       uint32_t last_sp = op->last_sp + op->stats.Pow * 8 / op->speed;
       op->stats.sp = min (op->stats.sp + last_sp / 128, op->stats.maxsp);   /* causes Pow/16 sp/tick */
       op->last_sp = last_sp % 128;
         {
           get_rangevector (part, enemy, &rv1, 0x1);
           dir = rv1.direction;
           /* hm, not sure about this part - in original was a scared flag here too
            * but that we test above... so can be old code here
            */
           if (op->flag [FLAG_RUN_AWAY])
             dir = absdir (dir + 4);
           if (op->flag [FLAG_CONFUSED])
   return 0;
 }
 /* determine if we can 'detect' the enemy. Check for walls blocking the
  * los. Also, just because its hidden/invisible, we may be sensitive/smart
  * enough (based on Wis & Int) to figure out where the enemy is. -b.t.
  * modified by MSW to use the get_rangevector so that map tiling works
  * properly.  I also so odd code in place that checked for x distance
  * OR y distance being within some range - that seemed wrong - both should
  * be within the valid range. MSW 2001-08-05
  * Returns 0 if enemy can not be detected, 1 if it is detected
    */
   if (op->is_player ())
     return 0;
   /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
    * flag (which was already checked) in can_see_enemy (). Lets get out of here
    */
   if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
     return 0;
   int radius = MIN_MON_RADIUS;
       radius += bonus / 5;
       hide_discovery += bonus * 5;
     }                           /* else creature has modifiers for hiding */
   /* Radii stealth adjustment. Only if you are stealthy
    * will you be able to sneak up closer to creatures */
   if (enemy->flag [FLAG_STEALTH])
     {
       radius /= 2;
       hide_discovery /= 3;
       if (op->flag [FLAG_SEE_IN_DARK] && !is_true_undead (enemy))
         radius += op->map->darklevel () / 2;
       else
         radius -= op->map->darklevel () / 2;
       /* op next to a monster (and not in complete darkness)
        * the monster should have a chance to see you.
        */
       if (radius < MIN_MON_RADIUS && op->map->darklevel () < MAX_DARKNESS && rv->distance <= 1)
         radius = MIN_MON_RADIUS;
     }                           /* if on dark map */
   /* Wasn't detected above, so still hidden */
   return 0;
 }
 /* determine if op stands in a lighted square. This is not a very
  * intelligent algorithm. For one thing, we ignore los here, SO it
  * is possible for a bright light to illuminate a player on the
  * other side of a wall (!).
  */
 int
 stand_in_light (object *op)
 {
   if (op)
             /* Check the spaces with the max light radius to see if any of them
              * have lights, and if any of them light the player enough, then return 1.
              */
             int light = ms.light;
-            if (expect_false (light > 0) && idistance (dx, dy) <= light)
+            if (ecb_expect_false (light > 0) && idistance (dx, dy) <= light)
               return 1;
           }
     }
   return 0;
 }
 /* assuming no walls/barriers, lets check to see if its *possible*
  * to see an enemy. Note, "detection" is different from "seeing".
  * See can_detect_enemy() for more details. -b.t.
  * return 0 if can't be seen, 1 if can be
  */
 int
   /* safety */
   if (!looker || !enemy || !looker->flag [FLAG_ALIVE])
     return 0;
   /* we dont give a full treatment of xrays here (shorter range than normal,
    * see through walls). Should we change the code elsewhere to make you
    * blind even if you can xray?
    */
   if (looker->flag [FLAG_BLIND] && !looker->flag [FLAG_XRAYS])
     return 0;
   /* checking for invisible things */
   if (enemy->invisible)
     {
       /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
        * However,if you carry any source of light, then the hidden
        * creature is seeable (and stupid) */
       if (enemy->has_carried_lights ())
         {
     }
   else if (looker->is_player ())      /* for players, a (possible) shortcut */
     if (player_can_view (looker, enemy))
       return 1;
   /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
    * unless they carry a light or stand in light. Darkness doesnt
    * inhibit the undead per se (but we should give their archs
    * CAN_SEE_IN_DARK, this is just a safety
    * we care about the enemy maps status, not the looker.
    * only relevant for tiled maps, but it is possible that the
    * enemy is on a bright map and the looker on a dark - in that
    * case, the looker can still see the enemy
    */

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.96 by root, Wed Nov 16 23:42:02 2016 UTC vs. Revision 1.101 by root, Wed Dec 5 19:03:27 2018 UTC

Diff Legend

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.96 by root, Wed Nov 16 23:42:02 2016 UTC vs.
Revision 1.101 by root, Wed Dec 5 19:03:27 2018 UTC