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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.26 by root, Tue Apr 24 12:32:16 2007 UTC vs.
Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC

  * 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
  */
 int
 monster_use_skill (object *head, object *part, object *pl, int dir)
 {
   object *skill, *owner;
       int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
       if (dirdiff (dir, dir2) < 1)
         return 0;               /* Might hit owner with skill -thrown rocks for example ? */
     }
   if (QUERY_FLAG (head, FLAG_CONFUSED))
     dir = absdir (dir + rndm (3) + rndm (3) - 2);
   /* skill selection - monster will use the next unused skill.
    * well...the following scenario will allow the monster to
    * toggle between 2 skills. One day it would be nice to make
    * more skills available to monsters.
    */
-  for (skill = head->inv; skill != NULL; skill = skill->below)
+  for (skill = head->inv; skill; skill = skill->below)
     if (skill->type == SKILL && skill != head->chosen_skill)
       {
         head->chosen_skill = skill;
         break;
       }
     {
       LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
       CLEAR_FLAG (head, FLAG_READY_SKILL);
       return 0;
     }
   /* use skill */
   return do_skill (head, part, head->chosen_skill, dir, NULL);
 }
 /* Monster will use a ranged spell attack. */
 int
 monster_use_range (object *head, object *part, object *pl, int dir)
 {
   object *wand, *owner;
   int at_least_one = 0;
         return 0;               /* Might hit owner with spell */
     }
   if (QUERY_FLAG (head, FLAG_CONFUSED))
     dir = absdir (dir + rndm (3) + rndm (3) - 2);
-  for (wand = head->inv; wand != NULL; wand = wand->below)
+  for (wand = head->inv; wand; wand = wand->below)
     {
       if (wand->type == WAND)
         {
           /* Found a wand, let's see if it has charges left */
           at_least_one = 1;
   if (val > 0)
     return 1;
   else
     return 0;
 }
 int
 check_good_armour (object *who, object *item)
 {
   if (val > 0)
     return 1;
   else
     return 0;
 }
 /*
  * monster_check_pickup(): checks for items that monster can pick up.
  *
  * This function was seen be continueing looping at one point (tmp->below
  * became a recursive loop.  It may be better to call monster_check_apply
  * after we pick everything up, since that function may call others which
  * affect stacking on this space.
  */
 void
 monster_check_pickup (object *monster)
 {
   object *tmp, *next;
  * monster_can_pick(): If the monster is interested in picking up
  * the item, then return 0.  Otherwise 0.
  * Instead of pick_up, flags for "greed", etc, should be used.
  * I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
  */
 int
 monster_can_pick (object *monster, object *item)
 {
   int flag = 0;
   int i;
           case BOW:
           case ARROW:
             flag = QUERY_FLAG (monster, FLAG_USE_BOW);
             break;
       }
   /* Simplistic check - if the monster has a location to equip it, he will
    * pick it up.  Note that this doesn't handle cases where an item may
    * use several locations.
    */
   for (i = 0; i < NUM_BODY_LOCATIONS; i++)
  * monster_apply_below():
  * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
  * eager to apply things, encounters something apply-able,
  * then make him apply it
  */
 void
 monster_apply_below (object *monster)
 {
   object *tmp, *next;
  * a pointer to that object is returned, so it can be dropped.
  * (so that other monsters can pick it up and use it)
  * Note that as things are now, monsters never drop something -
  * they can pick up all that they can use.
  */
 /* Sept 96, fixed this so skills will be readied -b.t.*/
 void
 monster_check_apply (object *mon, object *item)
 {
   int flag = 0;
-  if (item->type == SPELLBOOK && mon->arch != NULL && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL)))
+  if (item->type == SPELLBOOK && mon->arch && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL)))
     {
       SET_FLAG (mon, FLAG_CAST_SPELL);
       return;
     }
   if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW)
     {
       /* Check for the right kind of bow */
       object *bow;
-      for (bow = mon->inv; bow != NULL; bow = bow->below)
+      for (bow = mon->inv; bow; bow = bow->below)
         if (bow->type == BOW && bow->race == item->race)
           {
             SET_FLAG (mon, FLAG_READY_BOW);
             LOG (llevMonster, "Found correct bow for arrows.\n");
             return;             /* nothing more to do for arrows */
        */
       SET_FLAG (mon, 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.
    */
   /* should only be applying this item, not unapplying it.
    * also, ignore status of curse so they can take off old armour.
    * monsters have some advantages after all.
    */
   manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
-  return;
 }
 void
 npc_call_help (object *op)
 {
           if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
             npc->enemy = op->enemy;
       }
 }
 int
 dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
 {
   if (can_hit (part, enemy, rv))
     return dir;
   if (rv->distance < 10)
     return absdir (dir + 4);
   else if (rv->distance > 18)
     return dir;
   return 0;
 }
 int
 run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
 {
   if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20)
     {
       ob->move_status++;
       return (dir);
     }
   else if (ob->move_status > 20)
     ob->move_status = 0;
   return absdir (dir + 4);
 }
 int
 hitrun_att (int dir, object *ob, object *enemy)
     return dir;
   else if (ob->move_status < 50)
     return absdir (dir + 4);
   else
     ob->move_status = 0;
   return absdir (dir + 4);
 }
 int
 wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
     return 0;
   else if (ob->move_status < 10)
     return dir;
   else if (ob->move_status < 15)
     return absdir (dir + 4);
   ob->move_status = 0;
   return 0;
 }
 int
    * at least one map has this set, and whatever the map contains, the
    * server should try to be resilant enough to avoid the problem
    */
   if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away)
     return absdir (dir + 4);
   return dist_att (dir, ob, enemy, part, rv);
 }
 int
 wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
 {
   if (rv->distance < 9)
     return absdir (dir + 4);
   return 0;
 }
 void
 circ1_move (object *ob)
 {
   static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };
   if (++ob->move_status > 11)
     ob->move_status = 0;
   if (!(move_object (ob, circle[ob->move_status])))
-    (void) move_object (ob, rndm (8) + 1);
+    move_object (ob, rndm (8) + 1);
 }
 void
 circ2_move (object *ob)
 {
   static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };
   if (++ob->move_status > 19)
     ob->move_status = 0;
   if (!(move_object (ob, circle[ob->move_status])))
-    (void) move_object (ob, rndm (8) + 1);
+    move_object (ob, rndm (8) + 1);
 }
 void
 pace_movev (object *ob)
 {
   if (ob->move_status++ > 6)
     ob->move_status = 0;
   if (ob->move_status < 4)
-    (void) move_object (ob, 5);
+    move_object (ob, 5);
   else
-    (void) move_object (ob, 1);
+    move_object (ob, 1);
 }
 void
 pace_moveh (object *ob)
 {
   if (ob->move_status++ > 6)
     ob->move_status = 0;
   if (ob->move_status < 4)
-    (void) move_object (ob, 3);
+    move_object (ob, 3);
   else
-    (void) move_object (ob, 7);
+    move_object (ob, 7);
 }
 void
 pace2_movev (object *ob)
 {
   if (ob->move_status++ > 16)
     ob->move_status = 0;
   if (ob->move_status < 6)
-    (void) move_object (ob, 5);
+    move_object (ob, 5);
   else if (ob->move_status < 8)
     return;
   else if (ob->move_status < 13)
-    (void) move_object (ob, 1);
+    move_object (ob, 1);
   else
     return;
 }
 void
 pace2_moveh (object *ob)
 {
   if (ob->move_status++ > 16)
     ob->move_status = 0;
   if (ob->move_status < 6)
-    (void) move_object (ob, 3);
+    move_object (ob, 3);
   else if (ob->move_status < 8)
     return;
   else if (ob->move_status < 13)
-    (void) move_object (ob, 7);
+    move_object (ob, 7);
   else
     return;
 }
 void
  * monsters to throw things like chairs and other pieces of
  * furniture, even if they are not good throwable objects.
  * Probably better to have the monster throw a throwable object
  * first, then throw any non equipped weapon.
  */
 object *
 find_mon_throw_ob (object *op)
 {
   object *tmp = NULL;
 /* determine if op stands in a lighted square. This is not a very
  * intellegent 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)
 {
   sint16 nx, ny;
   maptile *m;
   if (!op)
     return 0;
   if (op->glow_radius > 0)
     return 1;
   if (op->map)
     {
       int x, y, x1, y1;
       /* 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.
        */
       for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
               if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
                 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
 can_see_enemy (object *op, object *enemy)
 {
   object *looker = op->head ? op->head : op;

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.26 by root, Tue Apr 24 12:32:16 2007 UTC vs. Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC

Diff Legend

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.26 by root, Tue Apr 24 12:32:16 2007 UTC vs.
Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC