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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.72 by root, Fri Nov 6 12:27:06 2009 UTC vs.
Revision 1.82 by root, Sun Mar 28 16:17:28 2010 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
  * the terms of the Affero GNU General Public License as published by the
  * Free Software Foundation, either version 3 of the License, or (at your
  * option) any later version.
  * Currently, only move_monster calls this function.
  * Fix function so that we always make calls to get_rangevector
  * if we have a valid target - function as not doing so in
  * many cases.
  */
-object *
+static object *
 find_enemy (object *npc, rv_vector * rv)
 {
   object *attacker, *tmp = NULL;
   attacker = npc->attacked_by;  /* save this for later use. This can be a attacker. */
 /* Sees if this monster should wake up.
  * Currently, this is only called from move_monster, and
  * if enemy is set, then so should be rv.
  * returns 1 if the monster should wake up, 0 otherwise.
  */
-int
+static int
 check_wakeup (object *op, object *enemy, rv_vector *rv)
 {
   /* Trim work - if no enemy, no need to do anything below */
   if (!enemy)
     return 0;
     }
   return 0;
 }
-int
+static int
 move_randomly (object *op)
 {
   /* Give up to 15 chances for a monster to move randomly */
   for (int i = 0; i < 15; i++)
-    if (move_object (op, rndm (8) + 1))
+    if (op->move (rndm (8) + 1))
       return 1;
   return 0;
 }
       next = tmp->below;
       if (monster_can_pick (monster, tmp))
         {
           tmp->remove ();
           tmp = insert_ob_in_ob (tmp, monster);
-          (void) monster_check_apply (monster, tmp);
+          monster_check_apply (monster, tmp);
         }
       /* We could try to re-establish the cycling, of the space, but probably
        * not a big deal to just bail out.
        */
       if (next && next->destroyed ())
         return;
   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])))
+  if (!(ob->move (circle[ob->move_status])))
-    move_object (ob, rndm (8) + 1);
+    ob->move (rndm (8) + 1);
 }
 static 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])))
+  if (!(ob->move (circle[ob->move_status])))
-    move_object (ob, rndm (8) + 1);
+    ob->move (rndm (8) + 1);
 }
 static void
 pace_movev (object *ob)
 {
   if (ob->move_status++ > 6)
     ob->move_status = 0;
   if (ob->move_status < 4)
-    move_object (ob, 5);
+    ob->move (5);
   else
-    move_object (ob, 1);
+    ob->move (1);
 }
 static void
 pace_moveh (object *ob)
 {
   if (ob->move_status++ > 6)
     ob->move_status = 0;
   if (ob->move_status < 4)
-    move_object (ob, 3);
+    ob->move (3);
   else
-    move_object (ob, 7);
+    ob->move (7);
 }
 static void
 pace2_movev (object *ob)
 {
   if (ob->move_status++ > 16)
     ob->move_status = 0;
   if (ob->move_status < 6)
-    move_object (ob, 5);
+    ob->move (5);
   else if (ob->move_status < 8)
     return;
   else if (ob->move_status < 13)
-    move_object (ob, 1);
+    ob->move (1);
   else
     return;
 }
 static void
 {
   if (ob->move_status++ > 16)
     ob->move_status = 0;
   if (ob->move_status < 6)
-    move_object (ob, 3);
+    ob->move (3);
   else if (ob->move_status < 8)
     return;
   else if (ob->move_status < 13)
-    move_object (ob, 7);
+    ob->move (7);
   else
     return;
 }
 static void
 rand_move (object *ob)
 {
-  if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(rndm (9)))))
+  if (ob->move_status < 1 || ob->move_status > 8 || !(ob->move (ob->move_status || !(rndm (9)))))
     for (int i = 0; i < 5; i++)
-      if (move_object (ob, ob->move_status = rndm (8) + 1))
+      if (ob->move (ob->move_status = rndm (8) + 1))
         return;
 }
 #define MAX_KNOWN_SPELLS 20
 /* Returns a randomly selected spell.    This logic is still
  * less than ideal.  This code also only seems to deal with
  * wizard spells, as the check is against sp, and not grace.
  * can mosnters know cleric spells?
  */
-object *
+static object *
 monster_choose_random_spell (object *monster)
 {
   object *altern[MAX_KNOWN_SPELLS];
   int i = 0;
  * part is the part of the monster we are checking against.
  * pl is the target.
  * dir is the direction to case.
  * rv is the vector which describes where the enemy is.
  */
-int
+static int
 monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
 {
   object *spell_item;
   object *owner;
   rv_vector rv1;
   head->spellitem = NULL;
   return cast_spell (part, part, dir, spell_item, NULL);
 }
-int
+static int
 monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
 {
   object *scroll;
   object *owner;
   rv_vector rv1;
  * 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
+static int
 monster_use_skill (object *head, object *part, object *pl, int dir)
 {
   object *skill, *owner;
   if (!(dir = path_to_player (part, pl, 0)))
     }
   if (QUERY_FLAG (head, FLAG_CONFUSED))
     dir = absdir (dir + rndm (3) + rndm (3) - 2);
+  object *new_skill = 0;
-  /* skill selection - monster will use the next unused skill.
+  // skill selection - monster will use the last unused skill
-   * well...the following scenario will allow the monster to
+  // and rotate, eventually cycling through all skills.
-   * toggle between 2 skills. One day it would be nice to make
-   * more skills available to monsters.
-   */
   for (skill = head->inv; skill; skill = skill->below)
     if (skill->type == SKILL && skill != head->chosen_skill)
-      {
+      new_skill = skill;
+  if (new_skill)
-        head->chosen_skill = skill;
+    splay (head->chosen_skill = new_skill);
-        break;
-      }
-  if (!skill && !head->chosen_skill)
+  else if (!head->chosen_skill)
     {
       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
+static int
 monster_use_range (object *head, object *part, object *pl, int dir)
 {
   object *wand, *owner;
   int at_least_one = 0;
         }
       else if (wand->type == ROD || wand->type == HORN)
         {
           /* Found rod/horn, let's use it if possible */
           at_least_one = 1;
-          if (wand->stats.hp < MAX (wand->inv->stats.sp, wand->inv->stats.grace))
+          if (wand->stats.hp < max (wand->inv->stats.sp, wand->inv->stats.grace))
             continue;
           /* drain charge before casting spell - can be a case where the
            * spell destroys the monster, and rod, so if done after, results
            * in crash.
   LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
   CLEAR_FLAG (head, FLAG_READY_RANGE);
   return 0;
 }
-int
+static int
 monster_use_bow (object *head, object *part, object *pl, int dir)
 {
   object *owner;
   if (!(dir = path_to_player (part, pl, 0)))
 }
 void
 npc_call_help (object *op)
 {
-  unordered_mapwalk (op, -7, -7, 7, 7)
+  unordered_mapwalk (mapwalk_buf, op, -7, -7, 7, 7)
     {
       mapspace &ms = m->at (nx, ny);
       /* If nothing alive on this space, no need to search the space. */
       if (!(ms.flags () & P_IS_ALIVE))
        *
        * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
        * overflow might produce monsters with negative hp.
        */
-      op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));
+      op->last_heal += (int) ((float) (8 * op->stats.Con) / op->speed);
-      op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
+      op->stats.hp = min ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
       op->last_heal %= 32;
       /* So if the monster has gained enough HP that they are no longer afraid */
       if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short)(((float)op->run_away / 100.f) * (float)op->stats.maxhp))
         CLEAR_FLAG (op, FLAG_RUN_AWAY);
        *
        * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
        * overflow might produce monsters with negative sp.
        */
-      op->last_sp += (int) ((float) (8 * op->stats.Pow) / fabsf (op->speed));
+      op->last_sp += (int) ((float) (8 * op->stats.Pow) / op->speed);
       op->stats.sp = min (op->stats.sp + op->last_sp / 128, op->stats.maxsp);   /* causes Pow/16 sp/tick */
       op->last_sp %= 128;
     }
   /* this should probably get modified by many more values.
         dir = sdir;
       else if (smell)
         {
           // no better smell found, so assume the player jumped, and erase this smell
           //printf ("erasing smell %d\n", op->ms ().smell);//D
-          unordered_mapwalk (op, -1, -1, 1, 1)
+          unordered_mapwalk (mapwalk_buf, op, -1, -1, 1, 1)
             m->at (nx, ny).smell = 0;
         }
     }
 //+GPL
   if (!dir)
     return 0;
   if (!QUERY_FLAG (op, FLAG_STAND_STILL))
     {
-      if (move_object (op, dir))        /* Can the monster move directly toward player? */
+      if (op->move (dir))        /* Can the monster move directly toward player? */
         {
           /* elmex: Turn our monster after it moved if it has DISTATT attack */
           if ((op->attack_movement & LO4) == DISTATT)
             op->direction = pre_att_dir;
           for (diff = 1; diff <= maxdiff; diff++)
             {
               /* try different detours */
               int m = 1 - rndm (2) * 2;      /* Try left or right first? */
-              if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
+              if (op->move (absdir (dir + diff * m)) || op->move (absdir (dir - diff * m)))
                 return 0;
             }
         }
     }                           /* if monster is not standing still */
       if (op->glow_radius > 0)
         return 1;
       if (op->map)
-        unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
+        unordered_mapwalk (mapwalk_buf, op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
           {
             /* 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 = m->at (nx, ny).light;

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.72 by root, Fri Nov 6 12:27:06 2009 UTC vs. Revision 1.82 by root, Sun Mar 28 16:17:28 2010 UTC

Diff Legend

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.72 by root, Fri Nov 6 12:27:06 2009 UTC vs.
Revision 1.82 by root, Sun Mar 28 16:17:28 2010 UTC