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

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.118 by root, Tue Nov 10 04:38:45 2009 UTC vs.
Revision 1.145 by root, Tue Jan 3 11:25:35 2012 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,2011,2012 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.
 /* did_make_save_item just checks to make sure the item actually
  * made its saving throw based on the tables.  It does not take
  * any further action (like destroying the item).
  */
 static int
-did_make_save_item (object *op, int type, object *originator)
+did_make_save_item (object *op, uint32_t type, object *originator)
 {
-  int i, roll, saves = 0, attacks = 0, number;
+  int saves = 0, attacks = 0;
   materialtype_t *mt = op->material;
+  // destroying objects without material has many bad effects
+  if (mt == MATERIAL_NULL)
+    return 1;
-  roll = rndm (1, 20);
+  int roll = rndm (1, 20);
   /* the attacktypes have no meaning for object saves
    * If the type is only magic, don't adjust type - basically, if
    * pure magic is hitting an object, it should save.  However, if it
    * is magic teamed with something else, then strip out the
    * magic type, and instead let the fire, cold, or whatever component
-   * destroy the item.  Otherwise, you get the case of poisoncloud
+   * destroy the item. Otherwise, you get the case of poisoncloud
    * destroying objects because it has magic attacktype.
    */
   if (type != AT_MAGIC)
     type &= ~(AT_CONFUSION | AT_DRAIN | AT_GHOSTHIT | AT_POISON | AT_SLOW |
               AT_PARALYZE | AT_TURN_UNDEAD | AT_FEAR | AT_DEPLETE | AT_DEATH |
               AT_COUNTERSPELL | AT_HOLYWORD | AT_BLIND | AT_LIFE_STEALING | AT_MAGIC);
   if (type ==  0) return TRUE;
   if (roll == 20) return TRUE;
   if (roll ==  1) return FALSE;
-  for (number = 0; number < NROFATTACKS; number++)
+  for_all_bits_sparse_32 (type, number)
     {
-      i = 1 << number;
-      if (!(i & type))
-        continue;
       attacks++;
       if (op->resist[number] == 100)
         saves++;
       else if (roll >= mt->save[number] - op->magic - op->resist[number] / 100)
         saves++;
       else if ((20 - mt->save[number]) / 3 > originator->stats.dam)
 cancellation (object *op)
 {
   if (op->invisible)
     return;
-  if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ)
+  if (op->flag [FLAG_ALIVE] || op->type == CONTAINER || op->type == THROWN_OBJ)
     {
       /* Recurse through the inventory */
       for (object *tmp = op->inv; tmp; tmp = tmp->below)
         if (!did_make_save_item (tmp, AT_CANCELLATION, op))
           cancellation (tmp);
     {
       /* Nullify this object. This code could probably be more complete */
       /* in what abilities it should cancel */
       op->magic = 0;
-      CLEAR_FLAG (op, FLAG_DAMNED);
+      op->clr_flag (FLAG_DAMNED);
-      CLEAR_FLAG (op, FLAG_CURSED);
+      op->clr_flag (FLAG_CURSED);
-      CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
+      op->clr_flag (FLAG_KNOWN_MAGICAL);
-      CLEAR_FLAG (op, FLAG_KNOWN_CURSED);
+      op->clr_flag (FLAG_KNOWN_CURSED);
       if (object *pl = op->visible_to ())
         esrv_update_item (UPD_FLAGS, pl, op);
     }
 }
  * calling cancellation, etc.)
  */
 void
 save_throw_object (object *op, int type, object *originator)
 {
+  op = op->head_ ();
   if (!did_make_save_item (op, type, originator))
     {
       object *env = op->env;
       int x = op->x, y = op->y;
       maptile *m = op->map;
        * object with +/- glow_radius and an "other_arch" to change to.
        * (and please note that we cant fail our save and reach this
        * function if the object doesnt contain a material that can burn.
        * So forget lighting magical swords on fire with this!) -b.t.
        */
-      if (type & (AT_FIRE | AT_ELECTRICITY)
+      if (type & (AT_FIRE | AT_ELECTRICITY))
-          && (QUERY_FLAG (op, FLAG_IS_LIGHTABLE)
-              || op->type == LAMP
-              || op->type == TORCH
-          ))
+        {
-        {
+          // seems LAMPs and TORCHes are always IS_LIGHTABLE?
-          switch (op->type)
+          if (op->type == LAMP || op->type == TORCH)
             {
-              case LAMP:
-              case TORCH:
-                // turn on a lamp
-                apply_lamp (op, true);
+              apply_lamp (op, true); // turn on a lamp
-                break;
+              return;
-              default:
-                // for instance icecubes:
-                if (op->other_arch)
-                  {
-                    const char *arch = op->other_arch->archname;
-                    if (op->decrease ())
-                      fix_stopped_item (op, m, originator);
-                    if ((op = archetype::get (arch)))
-                      {
-                        if (env)
-                          env->insert (op);
-                        else
-                          m->insert (op, x, y, originator);
-                      }
-                  }
             }
+          else if (op->flag [FLAG_IS_LIGHTABLE])
+            {
+              if (op->other_arch)
+                {
+                  const char *arch = op->other_arch->archname;
+                  if (op->decrease ())
+                    fix_stopped_item (op, m, originator);
+                  if ((op = archetype::get (arch)))
+                    {
+                      if (env)
+                        env->insert (op);
+                      else
+                        m->insert (op, x, y, originator);
+                    }
+                }
-          return;
+              return;
+            }
         }
       if (type & AT_CANCELLATION)
         {                       /* Cancellation. */
           cancellation (op);
           fix_stopped_item (op, m, originator);
           return;
-        }
-      if (op->nrof > 1)
-        {
-          if (op->decrease (rndm (0, op->nrof - 1)))
-            fix_stopped_item (op, m, originator);
-        }
-      else
-        {
-          // drop everything to the ground, if possible
-          op->insert_at (originator);
-          op->drop_and_destroy ();
         }
       if (type & (AT_FIRE | AT_ELECTRICITY))
         if (env)
           {
-            op = archetype::get (shstr_burnout);
+            object *op = archetype::get (shstr_burnout);
             op->x = env->x, op->y = env->y;
             env->insert (op);
           }
         else
           replace_insert_ob_in_map (shstr_burnout, originator);
+      if (op->nrof > 1)
+        {
+          if (op->decrease (rndm (0, op->nrof - 1)))
+            fix_stopped_item (op, m, originator);
+        }
+      else
+        {
+          // drop everything to the ground, if possible
+          op->insert_at (originator);
+          op->drop_and_destroy ();
+        }
       return;
     }
   /* The value of 50 is arbitrary. */
-  if (type & AT_COLD && (op->resist[ATNR_COLD] < 50) && !QUERY_FLAG (op, FLAG_NO_PICK) && rndm (2))
+  if (type & AT_COLD && (op->resist[ATNR_COLD] < 50) && !op->flag [FLAG_NO_PICK] && rndm (2))
     {
       archetype *at = archetype::find (shstr_icecube);
       if (at == NULL)
         return;
         return;
       object *tmp = present_arch (at, op->map, op->x, op->y);
       if (!tmp)
         {
-          tmp = arch_to_object (at);
+          tmp = at->instance ();
           tmp->x = op->x, tmp->y = op->y;
           /* This was in the old (pre new movement code) -
            * icecubes have slow_move set to 1 - don't want
            * that for ones we create.
            */
  * type is the attacktype of the object.
  * full_hit is set if monster area does not matter.
  * returns 1 if it hits something, 0 otherwise.
  */
 int
-hit_map (object *op, int dir, int type, int full_hit)
+hit_map (object *op, int dir, uint32_t type, int full_hit)
 {
   maptile *map;
   sint16 x, y;
   int retflag = 0;              /* added this flag..  will return 1 if it hits a monster */
-  if (QUERY_FLAG (op, FLAG_FREED))
+  if (op->flag [FLAG_FREED])
     {
       LOG (llevError, "BUG: hit_map(): free object\n");
       return 0;
     }
-  if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL)
+  if (op->flag [FLAG_REMOVED] || op->env != NULL)
     {
       LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n", &op->arch->archname, &op->name);
       return 0;
     }
        * This is one of the few cases where on_same_map should not be used.
        */
       if (tmp->map != pos.m || tmp->x != pos.x || tmp->y != pos.y)
         continue;
-      if (QUERY_FLAG (tmp, FLAG_ALIVE))
+      if (tmp->flag [FLAG_ALIVE])
         {
           hit_player (tmp, op->stats.dam, op, type, full_hit);
           retflag |= 1;
           if (op->destroyed ())
        * NO_PASS set, it is also immune - you can't destroy walls.  Note
        * that weak walls have is_alive set, which prevent objects from
        * passing over/through them.  We don't care what type of movement
        * the wall blocks - if it blocks any type of movement, can't be
        * destroyed right now.
+       * Without the material check the server completely fails to work,
+       * objects detsroy themselves, floors get destroyed etc. etc.
        */
-      else if (op->stats.dam > 0 && !tmp->move_block)
+      else if (op->stats.dam > 0 && !tmp->move_block && tmp->material != MATERIAL_NULL)
         {
           save_throw_object (tmp, type, op);
           if (op->destroyed ())
             break;
     {
       int mtype;
       switch (hitter->current_weapon->weapontype)
         {
-          case WEAP_HIT:
+          case WEAP_HIT:    mtype = ATM_BASIC;  break;
-            mtype = ATM_BASIC;
+          case WEAP_SLASH:  mtype = ATM_SLASH;  break;
-            break;
+          case WEAP_PIERCE: mtype = ATM_PIERCE; break;
-          case WEAP_SLASH:
+          case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;
-            mtype = ATM_SLASH;
+          case WEAP_SLICE:  mtype = ATM_SLICE;  break;
-            break;
+          case WEAP_STAB:   mtype = ATM_STAB;   break;
-          case WEAP_PIERCE:
+          case WEAP_WHIP:   mtype = ATM_WHIP;   break;
-            mtype = ATM_PIERCE;
+          case WEAP_CRUSH:  mtype = ATM_CRUSH;  break;
-            break;
+          case WEAP_BLUD:   mtype = ATM_BLUD;   break;
-          case WEAP_CLEAVE:
+          default:          mtype = ATM_BASIC;  break;
-            mtype = ATM_CLEAVE;
-            break;
-          case WEAP_SLICE:
-            mtype = ATM_SLICE;
-            break;
-          case WEAP_STAB:
-            mtype = ATM_STAB;
-            break;
-          case WEAP_WHIP:
-            mtype = ATM_WHIP;
-            break;
-          case WEAP_CRUSH:
-            mtype = ATM_CRUSH;
-            break;
-          case WEAP_BLUD:
-            mtype = ATM_BLUD;
-            break;
-          default:
-            mtype = ATM_BASIC;
-            break;
         }
       for (i = 0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1; i++)
         if (dam < attack_mess[mtype][i].level || attack_mess[mtype][i + 1].level == -1)
           {
 }
 static int
 get_attack_mode (object **target, object **hitter, int *simple_attack)
 {
-  if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED))
+  if ((*target)->flag [FLAG_FREED] || (*hitter)->flag [FLAG_FREED])
     {
       LOG (llevError, "BUG: get_attack_mode(): freed object\n");
       return 1;
     }
     {
       *simple_attack = 1;
       return 0;
     }
-  if (QUERY_FLAG (*target, FLAG_REMOVED)
+  if ((*target)->flag [FLAG_REMOVED]
-      || QUERY_FLAG (*hitter, FLAG_REMOVED)
+      || (*hitter)->flag [FLAG_REMOVED]
       || !(*hitter)->map
       || !on_same_map (*hitter, *target))
     {
       LOG (llevError | logBacktrace, "BUG: hitter (%s) with no relation to target (%s)\n",
            (*hitter)->debug_desc (), (*target)->debug_desc ());
    */
   int new_mode;
   if (hitter->env == target || target->env == hitter)
     new_mode = 1;
-  else if (QUERY_FLAG (hitter, FLAG_REMOVED) || QUERY_FLAG (target, FLAG_REMOVED)
+  else if (hitter->flag [FLAG_REMOVED] || target->flag [FLAG_REMOVED]
            || hitter->map == NULL || !on_same_map (hitter, target))
     return 1;
   else
     new_mode = 0;
  * monster).
  */
 static void
 thrown_item_effect (object *hitter, object *victim)
 {
-  if (!QUERY_FLAG (hitter, FLAG_ALIVE))
+  if (!hitter->flag [FLAG_ALIVE])
     {
       /* May not need a switch for just 2 types, but this makes it
        * easier for expansion.
        */
       switch (hitter->type)
         {
             case POTION:
               /* should player get a save throw instead of checking magic protection? */
-              if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_MAGIC] < 60))
+              if (victim->flag [FLAG_ALIVE] && !victim->flag [FLAG_UNDEAD] && (victim->resist[ATNR_MAGIC] < 60))
-                (void) apply_potion (victim, hitter);
+                apply_potion (victim, hitter);
               break;
             case POISON:       /* poison drinks */
               /* As with potions, should monster get a save? */
-              if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_POISON] < 60))
+              if (victim->flag [FLAG_ALIVE] && !victim->flag [FLAG_UNDEAD] && (victim->resist[ATNR_POISON] < 60))
                 apply_poison (victim, hitter);
               break;
               /* Removed case statements that did nothing.
                * food may be poisonous, but monster must be willing to eat it,
 /* determine if the object is an 'aimed' missile */
 static int
 is_aimed_missile (object *op)
 {
   /* I broke what used to be one big if into a few nested
    * ones so that figuring out the logic is at least possible.
    */
   if (op && (op->move_type & MOVE_FLYING))
     if (op->type == ARROW || op->type == THROWN_OBJ)
       if ((attacker = hitter->owner) == NULL)
         attacker = hitter;
       /* A player who saves but hasn't quit still could have objects
        * owned by him - need to handle that case to avoid crashes.
        */
-      if (QUERY_FLAG (attacker, FLAG_REMOVED))
+      if (attacker->flag [FLAG_REMOVED])
         attacker = hitter;
     }
-  else if (!QUERY_FLAG (hitter, FLAG_ALIVE))
+  else if (!hitter->flag [FLAG_ALIVE])
     return 0;
   /* determine the condtions under which we make an attack.
    * Add more cases, as the need occurs. */
   if (!can_see_enemy (attacker, target))
     {
       /* target is unseen */
-      if (target->invisible || QUERY_FLAG (attacker, FLAG_BLIND))
+      if (target->invisible || attacker->flag [FLAG_BLIND])
         adjust -= 10;
       /* dark map penalty for the hitter (lacks infravision if we got here). */
       else if (!stand_in_light (target))
         adjust -= target->map->darklevel ();
     }
-  if (QUERY_FLAG (attacker, FLAG_SCARED))
+  if (attacker->flag [FLAG_SCARED])
     adjust -= 3;
-  if (QUERY_FLAG (target, FLAG_UNAGGRESSIVE))
+  if (target->flag [FLAG_UNAGGRESSIVE])
     adjust += 1;
-  if (QUERY_FLAG (target, FLAG_SCARED))
+  if (target->flag [FLAG_SCARED])
     adjust += 1;
-  if (QUERY_FLAG (attacker, FLAG_CONFUSED))
+  if (attacker->flag [FLAG_CONFUSED])
     adjust -= 3;
   /* if we attack at a different 'altitude' its harder */
   if ((attacker->move_type & target->move_type) == 0)
     adjust -= 2;
   /*
    * A little check to make it more difficult to dance forward and back
    * to avoid ever being hit by monsters.
    */
-  if (!simple_attack && QUERY_FLAG (op, FLAG_MONSTER) && op->speed_left > abs (op->speed) * -0.3f)
+  if (!simple_attack && op->flag [FLAG_MONSTER] && op->speed_left > op->speed * -0.3f)
     {
       /* Decrease speed BEFORE calling process_object.  Otherwise, an
        * infinite loop occurs, with process_object calling move_monster,
        * which then gets here again.  By decreasing the speed before
        * we call process_object, the 'if' statement above will fail.
       if (!simple_attack)
         {
           /* If you hit something, the victim should *always* wake up.
            * Before, invisible hitters could avoid doing this.
            * -b.t. */
-          if (QUERY_FLAG (op, FLAG_SLEEP))
+          if (op->flag [FLAG_SLEEP])
-            CLEAR_FLAG (op, FLAG_SLEEP);
+            op->clr_flag (FLAG_SLEEP);
           /* If the victim can't see the attacker, it may alert others
            * for help. */
           if (op->type != PLAYER && !can_see_enemy (op, hitter) && !op->owner && rndm (0, op->stats.Int))
             npc_call_help (op);
         }
       /* 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)
+      max_it (hitdam, 1);
-        hitdam = 1;
       type = hitter->attacktype;
       /* Ok, because some of the brainfucks of the good *sigh* old *sigh*
        * Crossfire we have to default the attacktype here to AT_PHYSICAL.
        */
       if (!type)
         type = AT_PHYSICAL;
       /* Handle monsters that hit back */
-      if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))
+      if (!simple_attack && op->flag [FLAG_HITBACK] && hitter->flag [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);
 }
 int
 attack_ob (object *op, object *hitter)
 {
-  hitter = hitter->head_ ();
-  return attack_ob_simple (op, hitter, hitter->stats.dam, hitter->stats.wc);
+  return attack_ob_simple (op, hitter->head_ (), hitter->stats.dam, hitter->stats.wc);
 }
 /* op is the arrow, tmp is what is stopping the arrow.
  *
  * Returns 1 if op was inserted into tmp's inventory, 0 otherwise.
       return 0;
     }
   if (hit_something && op->speed >= 10.0)
-    op->speed -= 1.0;
+    op->set_speed (op->speed - 1.f);
   /* Missile missed victim - reassemble missile */
   if (container)
     {
       hitter->remove ();
    * this creature.  The function(s) that call us have already
    * adjusted the creatures HP total, so that is negative.
    */
   maxdam = dam + op->stats.hp + 1;
-  if (QUERY_FLAG (op, FLAG_BLOCKSVIEW))
+  if (op->flag [FLAG_BLOCKSVIEW])
     update_all_los (op->map, op->x, op->y);     /* makes sure los will be recalculated */
   if (op->type == DOOR)
     {
       op->set_speed (0.1f);
       op->speed_left = -0.05f;
       return maxdam;
     }
-  if (QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER)
+  if (op->flag [FLAG_FRIENDLY] && op->type != PLAYER)
     {
       op->drop_and_destroy ();
       return maxdam;
     }
       else if (owner->chosen_skill)
         {
           skop  = owner->chosen_skill;
           skill = skop->skill;
         }
-      else if (QUERY_FLAG (owner, FLAG_READY_WEAPON) && owner->current_weapon)
+      else if (owner->flag [FLAG_READY_WEAPON] && owner->current_weapon)
         skill = owner->current_weapon->skill;
       else
         {
+          LOG (llevError | logBacktrace,
-          LOG (llevError, "BUG: kill_object - unable to find skill that killed monster\n"
+               "BUG: kill_object - unable to find skill that killed monster\n"
-                          "op: %s\n"           "hitter: %s\n"          "owner: %s\n",
+               "op: %s\n"         "hitter: %s\n"         "op: %s\n",
-                          owner->debug_desc (), hitter->debug_desc (), op->debug_desc ());
+               op->debug_desc (), hitter->debug_desc (), op->debug_desc ());
           skill = 0;
         }
       /* We have the skill we want to credit to - now find the object this goes
        * to. Make sure skop is an actual skill, and not a skill tool!
   if (!skill && skop)
     skill = skop->skill;
   /* If you didn't kill yourself, and your not the wizard */
-  if (owner != op && !QUERY_FLAG (op, FLAG_WIZ))
+  if (owner != op && !op->flag [FLAG_WIZ])
     {
       int exp;
       /* Really don't give much experience for killing other players */
       // schmorp: temporarily? reduce the amount of exp gained for pking enourmously
         }                       /* else part of a party */
     }                           /* end if person didn't kill himself */
   if (op->type != PLAYER)
     {
-      if (QUERY_FLAG (op, FLAG_FRIENDLY))
+      if (op->flag [FLAG_FRIENDLY])
         {
           object *owner1 = op->owner;
           if (owner1 && owner1->type == PLAYER)
             {
  * modify it.
  */
 /* Oct 95 - altered the following slightly for MULTIPLE_GODS hack
  * which needs new attacktype AT_HOLYWORD to work . b.t. */
 int
-hit_player (object *op, int dam, object *hitter, int type, int full_hit)
+hit_player (object *op, int dam, object *hitter, uint32_t type, int full_hit)
 {
-  int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);
+  int magic = type & AT_MAGIC;
-  int maxattacktype, attacknum;
   int body_attack = op && op->head;     /* Did we hit op's head? */
+  int maxdam = 0, ndam = 0, attacktype = 1;
+  int maxattacktype;
   int simple_attack;
   int rtn_kill = 0;
   int friendlyfire;
   if (get_attack_mode (&op, &hitter, &simple_attack))
     return 0;
   /* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */
-  if (QUERY_FLAG (op, FLAG_WIZ) || QUERY_FLAG (op, FLAG_NO_DAMAGE))
+  if (op->flag [FLAG_WIZ] || op->flag [FLAG_NO_DAMAGE])
     return 0;
   // only allow pk for hostile players
   if (op->type == PLAYER)
     {
             break;
           }
     }
-  if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)
+  if (!op->flag [FLAG_ALIVE] || op->stats.hp < 0)
     {
       /* FIXME: If a player is killed by a rune in a door, the
        * destroyed() check above doesn't return, and might get here.
        */
       object *god;
       if ((!hitter->slaying
            || (!(op->race && hitter->slaying.contains (op->race))
                && !(op->name && hitter->slaying.contains (op->name))))
-          && (!QUERY_FLAG (op, FLAG_UNDEAD)
+          && (!op->flag [FLAG_UNDEAD]
               || (hitter->title
                   && (god = find_god (determine_god (hitter))) != NULL
                   && god->race.contains (shstr_undead))))
         return 0;
     }
   maxattacktype = type;         /* initialise this to something */
-  for (attacknum = 0; attacknum < NROFATTACKS; attacknum++, attacktype = 1 << attacknum)
+  for_all_bits_sparse_32 (type, attacknum)
     {
+      uint32_t attacktype = 1 << attacknum;
       /* Magic isn't really a true attack type - it gets combined with other
        * attack types.  As such, skip it over.  However, if magic is
        * the only attacktype in the group, then still attack with it
        */
       if ((attacktype == AT_MAGIC) && (type & ~AT_MAGIC))
       /* Go through and hit the player with each attacktype, one by one.
        * hit_player_attacktype only figures out the damage, doesn't inflict
        * it.  It will do the appropriate action for attacktypes with
        * effects (slow, paralization, etc.
        */
-      if (type & attacktype)
-        {
-          ndam = hit_player_attacktype (op, hitter, dam, attacknum, magic);
+      ndam = hit_player_attacktype (op, hitter, dam, attacknum, magic);
-          /* the >= causes us to prefer messages from special attacks, if
+      /* the >= causes us to prefer messages from special attacks, if
-           * the damage is equal.
+       * the damage is equal.
-           */
+       */
-          if (ndam >= maxdam)
+      if (ndam >= maxdam)
-            {
+        {
-              maxdam = ndam;
+          maxdam = ndam;
-              maxattacktype = 1 << attacknum;
+          maxattacktype = 1 << attacknum;
-            }
         }
     }
   /* if this is friendly fire then do a set % of damage only
    * Note - put a check in to make sure this attack is actually
   // keep a refcount for a long time and I see no usefulness
   // for an non-active objetc to know its enemy.
   if (op->active)
     if (hitter->owner)
       op->enemy = hitter->owner;
-    else if (QUERY_FLAG (hitter, FLAG_ALIVE))
+    else if (hitter->flag [FLAG_ALIVE])
       op->enemy = hitter;
-  if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE) && op->type != PLAYER)
+  if (op->flag [FLAG_UNAGGRESSIVE] && op->type != PLAYER)
     {
       /* The unaggressives look after themselves 8) */
-      CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
+      op->clr_flag (FLAG_UNAGGRESSIVE);
       npc_call_help (op);
     }
   if (magic && did_make_save (op, op->level, 0))
     maxdam = maxdam / 2;
   attack_message (maxdam, maxattacktype, op, hitter);
   op->stats.hp -= maxdam;
   /* Eneq(@csd.uu.se): Check to see if monster runs away. */
-  if ((op->stats.hp >= 0) &&
+  if (op->stats.hp >= 0
-      (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
+      && (op->flag [FLAG_MONSTER] || op->type == PLAYER)
-      op->stats.hp < (signed short) (((float) op->run_away / (float) 100) * (float) op->stats.maxhp))
+      && op->stats.hp * 100 < op->stats.maxhp * op->run_away)
     {
-      if (QUERY_FLAG (op, FLAG_MONSTER))
+      if (op->flag [FLAG_MONSTER])
-        SET_FLAG (op, FLAG_RUN_AWAY);
+        op->set_flag (FLAG_RUN_AWAY);
       else
         scare_creature (op, hitter);
     }
-  if (QUERY_FLAG (op, FLAG_TEAR_DOWN))
+  if (op->flag [FLAG_TEAR_DOWN])
     {
       if (maxdam)
         tear_down_wall (op);
       return maxdam;            /* nothing more to do for wall */
   /* Used to be ghosthit removal - we now use the ONE_HIT flag.  Note
    * that before if the player was immune to ghosthit, the monster
    * remained - that is no longer the case.
    */
-  if (QUERY_FLAG (hitter, FLAG_ONE_HIT))
+  if (hitter->flag [FLAG_ONE_HIT])
     hitter->drop_and_destroy ();
   /* Lets handle creatures that are splitting now */
-  else if (type & AT_PHYSICAL && !QUERY_FLAG (op, FLAG_FREED) && QUERY_FLAG (op, FLAG_SPLITTING))
+  else if (type & AT_PHYSICAL && !op->flag [FLAG_FREED] && op->flag [FLAG_SPLITTING])
     {
-      int i;
-      int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);
+      int friendly = op->flag [FLAG_FRIENDLY];
-      int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);
+      int unaggressive = op->flag [FLAG_UNAGGRESSIVE];
       object *owner = op->owner;
       if (!op->other_arch)
         {
           LOG (llevError, "SPLITTING without other_arch error.\n");
           return maxdam;
         }
       op->remove ();
-      for (i = 0; i < op->stats.food; i++)
+      for (int i = 0; i < op->stats.food; i++)
         {                       /* This doesn't handle op->more yet */
-          object *tmp = arch_to_object (op->other_arch);
+          object *tmp = op->other_arch->instance ();
-          int j;
           tmp->stats.hp = op->stats.hp;
           if (friendly)
             {
               if (owner)
                 tmp->set_owner (owner);
             }
           if (unaggressive)
-            SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
+            tmp->set_flag (FLAG_UNAGGRESSIVE);
-          j = find_first_free_spot (tmp, op->map, op->x, op->y);
+          int j = find_first_free_spot (tmp, op->map, op->x, op->y);
           if (j == -1)          /* No spot to put this monster */
             tmp->destroy ();
           else
             {
 poison_player (object *op, object *hitter, int dam)
 {
   archetype *at = archetype::find (shstr_poisoning);
   object *tmp = present_arch_in_ob (at, op);
-  if (tmp == NULL)
+  if (!tmp)
     {
-      if ((tmp = arch_to_object (at)) == NULL)
+      tmp = insert_ob_in_ob (at->instance (), op);
-        LOG (llevError, "Failed to clone arch poisoning.\n");
+      /*  peterm:  give poisoning some teeth.  It should
+       * be able to kill things better than it does:
+       * damage should be dependent something--I choose to
+       * do this:  if it's a monster, the damage from the
+       * poisoning goes as the level of the monster/2.
+       * If anything else, goes as damage.
+       */
+      if (hitter->flag [FLAG_ALIVE])
+        tmp->stats.dam += hitter->level / 2;
       else
-        {
-          tmp = insert_ob_in_ob (tmp, op);
-          /*  peterm:  give poisoning some teeth.  It should
-           * be able to kill things better than it does:
-           * damage should be dependent something--I choose to
-           * do this:  if it's a monster, the damage from the
-           * poisoning goes as the level of the monster/2.
-           * If anything else, goes as damage.
-           */
-          if (QUERY_FLAG (hitter, FLAG_ALIVE))
-            tmp->stats.dam += hitter->level / 2;
-          else
-            tmp->stats.dam = dam;
+        tmp->stats.dam = dam;
-          tmp->set_owner (hitter);     /*  so we get credit for poisoning kills */
+      tmp->set_owner (hitter);     /*  so we get credit for poisoning kills */
-          if (hitter->skill && hitter->skill != tmp->skill)
+      if (hitter->skill && hitter->skill != tmp->skill)
-            {
-              tmp->skill = hitter->skill;
+        tmp->skill = hitter->skill;
-            }
-          tmp->stats.food += dam;       /*  more damage, longer poisoning */
+      tmp->stats.food += dam;       /*  more damage, longer poisoning */
-          if (op->type == PLAYER)
+      if (op->type == PLAYER)
-            {
+        {
-              /* player looses stats, maximum is -10 of each */
+          /* player looses stats, maximum is -10 of each */
-              tmp->stats.Con = max (-(dam / 4 + 1), -10);
+          tmp->stats.Con = max (-(dam / 4 + 1), -10);
-              tmp->stats.Str = max (-(dam / 3 + 2), -10);
+          tmp->stats.Str = max (-(dam / 3 + 2), -10);
-              tmp->stats.Dex = max (-(dam / 6 + 1), -10);
+          tmp->stats.Dex = max (-(dam / 6 + 1), -10);
-              tmp->stats.Int = max (-(dam / 7    ), -10);
+          tmp->stats.Int = max (-(dam / 7    ), -10);
-              SET_FLAG (tmp, FLAG_APPLIED);
+          tmp->set_flag (FLAG_APPLIED);
-              op->update_stats ();
+          op->update_stats ();
-              new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");
+          new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");
-              op->play_sound (tmp->sound);
+          op->play_sound (tmp->sound);
-            }
+        }
-          if (hitter->type == PLAYER)
+      if (hitter->type == PLAYER)
-            new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);
+        new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);
-          else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
+      else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
-            new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);
+        new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);
-        }
       tmp->speed_left = 0;
     }
   else
     tmp->stats.food++;
 slow_player (object *op, object *hitter, int dam)
 {
   archetype *at = archetype::find (shstr_slowness);
   object *tmp;
-  if (at == NULL)
+  if (!at)
     LOG (llevError, "Can't find slowness archetype.\n");
   if ((tmp = present_arch_in_ob (at, op)) == NULL)
     {
-      tmp = arch_to_object (at);
+      tmp = at->instance ();
       tmp = insert_ob_in_ob (tmp, op);
       new_draw_info (NDI_UNIQUE, 0, op, "The world suddenly moves very fast!");
     }
   else
     tmp->stats.food++;
-  SET_FLAG (tmp, FLAG_APPLIED);
+  tmp->set_flag (FLAG_APPLIED);
   tmp->speed_left = 0;
   op->update_stats ();
 }
 void
   int maxduration;
   tmp = present_in_ob_by_name (FORCE, shstr_confusion, op);
   if (!tmp)
     {
-      tmp = get_archetype (FORCE_NAME);
+      tmp = archetype::get (FORCE_NAME);
       tmp = insert_ob_in_ob (tmp, op);
     }
   /* Duration added per hit and max. duration of confusion both depend
    *  on the player's resistance
    */
-  tmp->speed = 0.05;
+  tmp->set_speed (0.05);
   tmp->subtype = FORCE_CONFUSION;
   tmp->duration = 8 + max (1, 5 * (100 - op->resist[ATNR_CONFUSION]) / 100);
   tmp->name = shstr_confusion;
   maxduration = max (2, 30 * (100 - op->resist[ATNR_CONFUSION]) / 100);
   if (tmp->duration > maxduration)
     tmp->duration = maxduration;
-  if (op->type == PLAYER && !QUERY_FLAG (op, FLAG_CONFUSED))
+  if (op->type == PLAYER && !op->flag [FLAG_CONFUSED])
     new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very confused!");
-  SET_FLAG (op, FLAG_CONFUSED);
+  op->set_flag (FLAG_CONFUSED);
 }
 void
 blind_player (object *op, object *hitter, int dam)
 {
-  object *tmp, *owner;
   /* Save some work if we know it isn't going to affect the player */
   if (op->resist[ATNR_BLIND] == 100)
     return;
-  tmp = present_in_ob (BLINDNESS, op);
+  object *tmp = present_in_ob (BLINDNESS, op);
   if (!tmp)
     {
-      tmp = get_archetype (shstr_blindness);
+      tmp = archetype::get (shstr_blindness);
-      SET_FLAG (tmp, FLAG_BLIND);
+      tmp->set_flag (FLAG_BLIND);
-      SET_FLAG (tmp, FLAG_APPLIED);
+      tmp->set_flag (FLAG_APPLIED);
-      /* use floats so we don't lose too much precision due to rounding errors.
+      // use floats so we don't lose too much precision due to rounding errors.
-       * speed is a float anyways.
+      tmp->set_speed (lerp<float> (op->resist [ATNR_BLIND], 0, 100, tmp->speed, MIN_ACTIVE_SPEED));
-       */
-      tmp->speed = tmp->speed * (100.0 - (float) op->resist[ATNR_BLIND]) / 100;
       tmp = insert_ob_in_ob (tmp, op);
       change_abil (op, tmp);    /* Mostly to display any messages */
       op->update_stats ();          /* This takes care of some other stuff */
-      if (hitter->owner)
-        owner = hitter->owner;
-      else
-        owner = hitter;
-      new_draw_info_format (NDI_UNIQUE, 0, owner, "Your attack blinds %s!", query_name (op));
+      new_draw_info_format (NDI_UNIQUE, 0, hitter->outer_owner (), "Your attack blinds %s!", query_name (op));
     }
   tmp->stats.food += dam;
-  if (tmp->stats.food > 10)
+  min_it (tmp->stats.food, 10);
-    tmp->stats.food = 10;
 }
 void
 paralyze_player (object *op, object *hitter, int dam)
 {
    */
   /* Do this as a float - otherwise, rounding might very well reduce this to 0 */
   float effect = dam * 3.f * (100.f - op->resist[ATNR_PARALYZE]) / 100.f;
-  op->speed_left -= fabs (op->speed) * effect;
+  op->speed_left -= op->speed * effect;
   /* tmp->stats.food+=(signed short) effect/op->speed; */
   /* max number of ticks to be affected for. */
   float max = (100 - op->resist[ATNR_PARALYZE]) / 2;
-  if (op->speed_left < -(fabs (op->speed) * max))
+  max_it (op->speed_left, -op->speed * max);
-    op->speed_left = -(fabs (op->speed) * max);
-/*      tmp->stats.food = (signed short) (max / fabs (op->speed)); */
+/*      tmp->stats.food = (signed short) (max / op->speed); */
 }
 /* Attempts to kill 'op'.  hitter is the attack object, dam is
  * the computed damaged.
  */
    **  field of the deathstriking object  */
   int atk_lev, def_lev, kill_lev;
   if (hitter->slaying)
-    if (!((QUERY_FLAG (op, FLAG_UNDEAD) && hitter->slaying.contains (shstr_undead))
+    if (!((op->flag [FLAG_UNDEAD] && hitter->slaying.contains (shstr_undead))
         || (op->race && hitter->slaying.contains (op->race))))
       return;
   def_lev = op->level;
   if (def_lev < 1)
            * Second, just getting hit doesn't mean it always affects
            * you.  Third, you still get a saving through against the
            * effect.
            */
           if (op->has_active_speed ()
-              && (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER)
+              && (op->flag [FLAG_MONSTER] || op->type == PLAYER)
               && !(rndm (0, (attacknum == ATNR_SLOW ? 6 : 3) - 1))
               && !did_make_save (op, level_diff, op->resist[attacknum] / 10))
             {
               /* Player has been hit by something */
                 scare_creature (op, hitter);
               else if (attacknum == ATNR_CANCELLATION)
                 cancellation (op);
               else if (attacknum == ATNR_DEPLETE)
                 op->drain_stat ();
-              else if (attacknum == ATNR_BLIND && !QUERY_FLAG (op, FLAG_UNDEAD) && !QUERY_FLAG (op, FLAG_GENERATOR))
+              else if (attacknum == ATNR_BLIND && !op->flag [FLAG_UNDEAD] && !op->flag [FLAG_GENERATOR])
                 blind_player (op, hitter, dam);
             }
           dam = 0;            /* These are all effects and don't do real damage */
         }
             {
               for (object *tmp = op->inv; tmp; tmp = tmp->below)
                 {
                   if (tmp->invisible)
                     continue;
-                  if (!QUERY_FLAG (tmp, FLAG_APPLIED) || (tmp->resist[ATNR_ACID] >= 10))
+                  if (!tmp->flag [FLAG_APPLIED] || (tmp->resist[ATNR_ACID] >= 10))
                     /* >= 10% acid res. on items will protect these */
                     continue;
                   if (!(tmp->materials & M_IRON))
                     continue;
                   if (tmp->magic < -4)        /* Let's stop at -5 */
             rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
           if (op->stats.exp <= rate)
             {
               if (op->type == GOLEM)
-                dam = 999;    /* Its force is "sucked" away. 8) */
+                dam = 9998;    /* Its force is "sucked" away. 8) */
               else
                 /* If we can't drain, lets try to do physical damage */
                 dam = hit_player_attacktype (op, hitter, dam, ATNR_PHYSICAL, magic);
             }
           else
                * exp, but the wiz would still lose exp!  If drainee is a wiz,
                * nothing happens.
                * Try to credit the owner.  We try to display player -> player drain
                * attacks, hence all the != PLAYER checks.
                */
-              if (!op_on_battleground (hitter, NULL, NULL) && !QUERY_FLAG (op, FLAG_WIZ))
+              if (!op_on_battleground (hitter, NULL, NULL) && !op->flag [FLAG_WIZ])
                 {
                   object *owner = hitter->owner;
                   if (owner && owner != hitter)
                     {
                       if (op->type != PLAYER || owner->type != PLAYER)
                         change_exp (owner, op->stats.exp / (rate * 2),
-                                    hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, SK_EXP_TOTAL);
+                                    hitter->chosen_skill ? hitter->chosen_skill->skill : shstr (), SK_EXP_TOTAL);
                     }
                   else if (op->type != PLAYER || hitter->type != PLAYER)
                     change_exp (hitter, op->stats.exp / (rate * 2),
-                                hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, 0);
+                                hitter->chosen_skill ? hitter->chosen_skill->skill : shstr (), 0);
-                  change_exp (op, -op->stats.exp / rate, NULL, 0);
+                  change_exp (op, -op->stats.exp / rate, shstr (), 0);
                 }
               dam = 1;        /* Drain is an effect.  Still return 1 - otherwise, if you have pure
                                * drain attack, you won't know that you are actually sucking out EXP,
                                * as the messages will say you missed
         }
         break;
       case ATNR_TURN_UNDEAD:
         {
-          if (QUERY_FLAG (op, FLAG_UNDEAD))
+          if (op->flag [FLAG_UNDEAD])
             {
               object *owner = hitter->owner ? (object *)hitter->owner : hitter;
               object *god = find_god (determine_god (owner));
               int div = 1;
            * damage it does do to the player.  Given that,
            * it only does 1/10'th normal damage (hence the divide by
            * 1000).
            */
           /* You can't steal life from something undead */
-          if ((op->type == GOLEM) || (QUERY_FLAG (op, FLAG_UNDEAD)))
+          if ((op->type == GOLEM) || (op->flag [FLAG_UNDEAD]))
             return 0;
           /* If drain protection is higher than life stealing, use that */
           if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
             dam = (dam * (100 - op->resist[ATNR_DRAIN])) / 3000;

Diff Legend

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

Comparing deliantra/server/server/attack.C (file contents): Revision 1.118 by root, Tue Nov 10 04:38:45 2009 UTC vs. Revision 1.145 by root, Tue Jan 3 11:25:35 2012 UTC

Diff Legend

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.118 by root, Tue Nov 10 04:38:45 2009 UTC vs.
Revision 1.145 by root, Tue Jan 3 11:25:35 2012 UTC