[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.125 by root, Sun Nov 29 09:41:28 2009 UTC

 /* 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)
        * 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. */
  * 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 */
        * 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;
   /*
    * 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 && QUERY_FLAG (op, 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.
  * 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))
                   && 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
   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) &&
+      && (QUERY_FLAG (op, 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))
         SET_FLAG (op, FLAG_RUN_AWAY);
       else
   if (QUERY_FLAG (hitter, 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))
     {
-      int i;
       int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);
       int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);
       object *owner = op->owner;
       if (!op->other_arch)
           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);
-          int j;
           tmp->stats.hp = op->stats.hp;
           if (friendly)
             {
             }
           if (unaggressive)
             SET_FLAG (tmp, 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
             {
    */
   /* 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.
  */

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.125 by root, Sun Nov 29 09:41:28 2009 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.125 by root, Sun Nov 29 09:41:28 2009 UTC