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

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.15 by root, Thu Sep 14 20:46:10 2006 UTC vs.
Revision 1.19 by root, Sat Sep 16 22:24:13 2006 UTC

-/*
- * static char *rcsid_attack_c =
- *   "$Id: attack.C,v 1.15 2006/09/14 20:46:10 root Exp $";
- */
 /*
     CrossFire, A Multiplayer game for X-windows
     Copyright (C) 2002 Mark Wedel & Crossfire Development Team
     Copyright (C) 1992 Frank Tore Johansen
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-    The authors can be reached via e-mail to crossfire-devel@real-time.com
+    The authors can be reached via e-mail to <crossfire@schmorp.de>
 */
 #include <assert.h>
 #include <global.h>
 #include <living.h>
 #include <material.h>
 {
   if (!did_make_save_item (op, type, originator))
     {
       object *env = op->env;
       int x = op->x, y = op->y;
-      mapstruct *m = op->map;
+      maptile *m = op->map;
       op = stop_item (op);
       if (op == NULL)
         return;
   /* The value of 50 is arbitrary. */
   if (type & AT_COLD && (op->resist[ATNR_COLD] < 50) && !QUERY_FLAG (op, FLAG_NO_PICK) && (RANDOM () & 2))
     {
       object *tmp;
-      archetype *at = find_archetype ("icecube");
+      archetype *at = archetype::find ("icecube");
       if (at == NULL)
         return;
       op = stop_item (op);
 int
 hit_map (object *op, int dir, int type, int full_hit)
 {
   object *tmp, *next;
-  mapstruct *map;
+  maptile *map;
   sint16 x, y;
   int retflag = 0;              /* added this flag..  will return 1 if it hits a monster */
-  tag_t op_tag, next_tag = 0;
   if (QUERY_FLAG (op, FLAG_FREED))
     {
       LOG (llevError, "BUG: hit_map(): free object\n");
       return 0;
     }
       return 0;
     }
   if (op->head)
     op = op->head;
-  op_tag = op->count;
   map = op->map;
   x = op->x + freearr_x[dir];
   y = op->y + freearr_y[dir];
       update_object (op, UP_OBJ_FACE);
       type &= ~AT_CHAOS;
     }
   next = get_map_ob (map, x, y);
-  if (next)
-    next_tag = next->count;
   while (next)
     {
-      if (was_destroyed (next, next_tag))
+      if (next->destroyed ())
         {
           /* There may still be objects that were above 'next', but there is no
            * simple way to find out short of copying all object references and
            * tags into a temporary array before we start processing the first
            * object.  That's why we just abort.
         }
       tmp = next;
       next = tmp->above;
-      if (next)
+      if (tmp->destroyed ())
-        next_tag = next->count;
-      if (QUERY_FLAG (tmp, FLAG_FREED))
         {
           LOG (llevError, "BUG: hit_map(): found freed object\n");
           break;
         }
       if (QUERY_FLAG (tmp, FLAG_ALIVE))
         {
           hit_player (tmp, op->stats.dam, op, type, full_hit);
           retflag |= 1;
-          if (was_destroyed (op, op_tag))
+          if (op->destroyed ())
             break;
         }
       /* Here we are potentially destroying an object.  If the object has
        * NO_PASS set, it is also immune - you can't destroy walls.  Note
        * destroyed right now.
        */
       else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block)
         {
           save_throw_object (tmp, type, op);
-          if (was_destroyed (op, op_tag))
+          if (op->destroyed ())
             break;
         }
     }
   return 0;
 void
 attack_message (int dam, int type, object *op, object *hitter)
 {
   char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];
   int i, found = 0;
-  mapstruct *map;
+  maptile *map;
   object *next, *tmp;
   /* put in a few special messages for some of the common attacktypes
    *  a player might have.  For example, fire, electric, cold, etc
    *  [garbled 20010919]
 attack_ob_simple (object *op, object *hitter, int base_dam, int base_wc)
 {
   int simple_attack, roll, dam = 0;
   uint32 type;
   shstr op_name;
-  tag_t op_tag, hitter_tag;
   if (get_attack_mode (&op, &hitter, &simple_attack))
     goto error;
   if (hitter->current_weapon)
     if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
       return RESULT_INT (0);
   if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
     return RESULT_INT (0);
-  op_tag = op->count;
-  hitter_tag = hitter->count;
   /*
    * A little check to make it more difficult to dance forward and back
    * to avoid ever being hit by monsters.
    */
        * which then gets here again.  By decreasing the speed before
        * we call process_object, the 'if' statement above will fail.
        */
       op->speed_left--;
       process_object (op);
-      if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
+      if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
         goto error;
     }
   op_name = op->name;
            * when they hit the victim.  For things like thrown daggers,
            * this sets 'hitter' to the actual dagger, and not the
            * wrapper object.
            */
           thrown_item_effect (hitter, op);
-          if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))
+          if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
             goto leave;
         }
       /* Need to do at least 1 damage, otherwise there is no point
        * to go further and it will cause FPE's below.
        */
       if (hitdam <= 0)
         hitdam = 1;
       type = hitter->attacktype;
       if (!type)
         type = AT_PHYSICAL;
       /* Handle monsters that hit back */
       if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))
         {
           if (op->attacktype & AT_ACID && hitter->type == PLAYER)
             new_draw_info (NDI_UNIQUE, 0, hitter, "You are splashed by acid!\n");
           hit_player (hitter, random_roll (0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);
-          if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
+          if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
             goto leave;
         }
       /* In the new attack code, it should handle multiple attack
        * types in its area, so remove it from here.
        */
       dam = hit_player (op, random_roll (1, hitdam, hitter, PREFER_HIGH), hitter, type, 1);
-      if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
+      if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
         goto leave;
     }                           /* end of if hitter hit op */
   /* if we missed, dam=0 */
   /*attack_message(dam, type, op, hitter); */
 object *
 hit_with_arrow (object *op, object *victim)
 {
   object *container, *hitter;
   int hit_something = 0;
-  tag_t victim_tag, hitter_tag;
   sint16 victim_x, victim_y;
   /* Disassemble missile */
   if (op->inv)
     {
     }
   /* Try to hit victim */
   victim_x = victim->x;
   victim_y = victim->y;
-  victim_tag = victim->count;
-  hitter_tag = hitter->count;
   hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);
   /* Arrow attacks door, rune of summoning is triggered, demon is put on
    * arrow, move_apply() calls this function, arrow sticks in demon,
    * attack_ob_simple() returns, and we've got an arrow that still exists
    * but is no longer on the map. Ugh. (Beware: Such things can happen at
    * other places as well!)
    */
-  if (was_destroyed (hitter, hitter_tag) || hitter->env != NULL)
+  if (hitter->destroyed () || hitter->env != NULL)
     {
       if (container)
         {
           remove_ob (container);
           free_object (container);
           remove_ob (container);
           free_object (container);
         }
       /* Try to stick arrow into victim */
-      if (!was_destroyed (victim, victim_tag) && stick_arrow (hitter, victim))
+      if (!victim->destroyed () && stick_arrow (hitter, victim))
         return NULL;
       /* Else try to put arrow on victim's map square
        * remove check for P_WALL here.  If the arrow got to this
        * space, that is good enough - with the new movement code,
 {
   int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);
   int maxattacktype, attacknum;
   int body_attack = op && op->head;     /* Did we hit op's head? */
   int simple_attack;
-  tag_t op_tag, hitter_tag;
   int rtn_kill = 0;
   int friendlyfire;
   if (get_attack_mode (&op, &hitter, &simple_attack))
     return 0;
     {
       object *owner = get_owner (hitter);
       if (!owner)
         owner = hitter;
       if (owner->type == PLAYER && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) && op != owner)
-        {
-          return 0;
+        return 0;
-        }
     }
 #endif
-  op_tag = op->count;
-  hitter_tag = hitter->count;
   if (body_attack)
     {
       /* slow and paralyze must hit the head.  But we don't want to just
        * return - we still need to process other attacks the spell still
        * attack so we don't cancel out things like magic bullet.
        */
       if (type & (AT_PARALYZE | AT_SLOW))
         {
           type &= ~(AT_PARALYZE | AT_SLOW);
           if (!type || type == AT_MAGIC)
             return 0;
         }
     }
       for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
         if (tmp->type == RUNE || tmp->type == TRAP)
           {
             spring_trap (tmp, hitter);
-            if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))
+            if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
               return 0;
             break;
           }
     }
   if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)
     {
       /* FIXME: If a player is killed by a rune in a door, the
-       * was_destroyed() check above doesn't return, and might get here.
+       * destroyed() check above doesn't return, and might get here.
        */
       LOG (llevDebug, "victim (arch %s, name %s) already dead in " "hit_player()\n", &op->arch->name, &op->name);
       return 0;
     }
 void
 poison_player (object *op, object *hitter, int dam)
 {
-  archetype *at = find_archetype ("poisoning");
+  archetype *at = archetype::find ("poisoning");
   object *tmp = present_arch_in_ob (at, op);
   if (tmp == NULL)
     {
       if ((tmp = arch_to_object (at)) == NULL)
 }
 void
 slow_player (object *op, object *hitter, int dam)
 {
-  archetype *at = find_archetype ("slowness");
+  archetype *at = archetype::find ("slowness");
   object *tmp;
   if (at == NULL)
     {
       LOG (llevError, "Can't find slowness archetype.\n");

Diff Legend

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

Comparing deliantra/server/server/attack.C (file contents): Revision 1.15 by root, Thu Sep 14 20:46:10 2006 UTC vs. Revision 1.19 by root, Sat Sep 16 22:24:13 2006 UTC

Diff Legend

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.15 by root, Thu Sep 14 20:46:10 2006 UTC vs.
Revision 1.19 by root, Sat Sep 16 22:24:13 2006 UTC