[ViewVC] Diff of: cvs/deliantra/server/server/spell

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC vs.
Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC

  * op is the spell object.
  */
 void
 check_spell_knockback (object *op)
 {
-  object *tmp, *tmp2;           /* object on the map */
   int weight_move;
   int frictionmod = 2;          /*poor man's physics - multipy targets weight by this amount */
   if (!op->weight)
     {                           /*shouldn't happen but if cone object has no weight drop out */
     {
       weight_move = op->weight + (op->weight * op->level) / 3;
       /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
     }
-  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
+  for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
       int num_sections = 1;
       /* don't move DM */
       if (QUERY_FLAG (tmp, FLAG_WIZ))
       /* don't move floors or immobile objects */
       if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
         continue;
       /* count the object's sections */
-      for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)
+      for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
         num_sections++;
       /* I'm not sure if it makes sense to divide by num_sections - bigger
        * objects should be harder to move, and we are moving the entire
        * object, not just the head, so the total weight should be relevant.
   new_bolt->duration++;
   new_bolt->stats.dam /= 2;     /* reduce daughter bolt damage */
   new_bolt->stats.dam++;
   tmp->stats.dam /= 2;          /* reduce father bolt damage */
   tmp->stats.dam++;
   if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
     update_turn_face (new_bolt);
 }
 /* move_bolt: moves bolt 'op'.  Basically, it just advances a space,
  * and checks for various things that may stop it.
  */
 void
 move_bolt (object *op)
 {
   int mflags;
   sint16 x, y;
   maptile *m;
   if (--op->duration < 0)
     {
-      op->destroy ();
+      op->drop_and_destroy ();
       return;
     }
   hit_map (op, 0, op->attacktype, 1);
           tmp->duration++;
           /* New forking code.  Possibly create forks of this object
            * going off in other directions.
            */
-          if (rndm (0, 99) < tmp->stats.Dex)
+          if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
-            {                   /* stats.Dex % of forking */
+            forklightning (op, tmp); /* stats.Dex % of forking */
-              forklightning (op, tmp);
-            }
           /* In this way, the object left behind sticks on the space, but
            * doesn't create any bolts that continue to move onward.
            */
           op->range = 0;
     return 0;
   /*  peterm:  level dependency for bolts  */
   tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
   tmp->attacktype = spob->attacktype;
   if (spob->slaying)
     tmp->slaying = spob->slaying;
   tmp->range = spob->range + SP_level_range_adjust (caster, spob);
   tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
   tmp->stats.Dex = spob->stats.Dex;
   tmp->stats.Con = spob->stats.Con;
   maptile *newmap;
   mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
   if (mflags & P_OUT_OF_MAP)
     {
-      tmp->destroy ();
+      tmp->drop_and_destroy ();
       return 0;
     }
   tmp->map = newmap;
   if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
     {
       if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
         {
-          tmp->destroy ();
+          tmp->drop_and_destroy ();
           return 0;
         }
       tmp->x = op->x;
       tmp->y = op->y;
 void
 explode_bullet (object *op)
 {
   object *tmp, *owner;
-  if (op->other_arch == NULL)
+  if (!op->other_arch)
     {
       LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
       op->destroy ();
       return;
     }
     }
   if (op->attacktype)
     {
       hit_map (op, 0, op->attacktype, 1);
       if (op->destroyed ())
         return;
     }
   /* other_arch contains what this explodes into */
   tmp->set_owner (op);
   tmp->skill = op->skill;
   owner = op->owner;
-  if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
+  if ((tmp->attacktype & AT_HOLYWORD
+       || tmp->attacktype & AT_GODPOWER)
+      && owner
+      && !tailor_god_spell (tmp, owner))
     {
       op->destroy ();
       return;
     }
   for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
       if (QUERY_FLAG (tmp, FLAG_ALIVE))
         {
           dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
+          // TODO: can't understand the following if's
           if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
             {
               if (!QUERY_FLAG (op, FLAG_REMOVED))
                 {
                   op->destroy ();
 /* move_cone: causes cone object 'op' to move a space/hit creatures */
 void
 move_cone (object *op)
 {
-  int i;
   /* if no map then hit_map will crash so just ignore object */
   if (!op->map)
     {
       LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
       op->set_speed (0);
     }
 #endif
   hit_map (op, 0, op->attacktype, 0);
+  if (!op->is_on_map ())
+    return;
   /* Check to see if we should push anything.
    * Spell objects with weight push whatever they encounter to some
    * degree.
    */
   if (op->weight)
+    {
-    check_spell_knockback (op);
+      check_spell_knockback (op);
-  if (op->destroyed ())
+      if (!op->is_on_map ())
-    return;
+        return;
+    }
-  if ((op->duration--) < 0)
+  if (op->duration-- < 0)
     {
       op->destroy ();
       return;
     }
   /* Object has hit maximum range, so don't have it move
     {
       op->range = 0;            /* just so it doesn't wrap */
       return;
     }
-  for (i = -1; i < 2; i++)
+  for (int i = -1; i <= 1; i++)
     {
       sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
       if (ok_to_put_more (op->map, x, y, op, op->attacktype))
         {
       success = 1;
       tmp = arch_to_object (spell->other_arch);
       tmp->set_owner (op);
       set_spell_skill (op, caster, spell, tmp);
-      tmp->level = caster_level (caster, spell);
+      tmp->level = casting_level (caster, spell);
       tmp->attacktype = spell->attacktype;
       /* holy word stuff */
       if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
         if (!tailor_god_spell (tmp, op))
   int mflags;
   sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
   maptile *m;
   mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
+  // when creating a bomb below ourself it should always work, even
+  // when movement is blocked (somehow we got here, somehow we are here,
+  // so we should also be able to make a bomb here). (originally added
+  // to fix create bomb traps in doors, which cast with dir=0).
+  if (dir)
+    {
-  if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
+      if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
-    {
+        {
-      new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
+          new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
-      return 0;
+          return 0;
+        }
     }
   tmp = arch_to_object (spell->other_arch);
   /*  level dependencies for bomb  */
     effect = arch_to_object (spell->other_arch);
   else
     return 0;
   /* tailor the effect by priest level and worshipped God */
-  effect->level = caster_level (caster, spell);
+  effect->level = casting_level (caster, spell);
   effect->attacktype = spell->attacktype;
   if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
     {
       if (tailor_god_spell (effect, op))
         new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
 /* op is a missile that needs to be moved */
 void
 move_missile (object *op)
 {
-  int i, mflags;
-  object *owner;
-  sint16 new_x, new_y;
-  maptile *m;
   if (op->range-- <= 0)
     {
+      op->drop_and_destroy ();
+      return;
+    }
+  mapxy pos (op);
+  pos.move (op->direction);
+  if (!pos.normalise ())
+    {
       op->destroy ();
       return;
     }
-  owner = op->owner;
+  mapspace &ms = pos.ms ();
-#if 0
-  /* It'd make things nastier if this wasn't here - spells cast by
-   * monster that are then killed would continue to survive
-   */
-  if (owner == NULL)
-    {
-      op->destroy ();
-      return;
-    }
-#endif
-  new_x = op->x + DIRX (op);
+  if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
-  new_y = op->y + DIRY (op);
-  mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
-  if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
     {
       hit_map (op, op->direction, AT_MAGIC, 1);
       /* Basically, missile only hits one thing then goes away.
        * we need to remove it if someone hasn't already done so.
        */
-      if (!op->destroyed ())
-        op->destroy ();
-      return;
-    }
-  op->remove ();
-  if (!op->direction || (mflags & P_OUT_OF_MAP))
-    {
       op->destroy ();
       return;
     }
+  if (!op->direction)
+    {
+      op->destroy ();
+      return;
+    }
-  i = spell_find_dir (m, new_x, new_y, op->owner);
+  int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
   if (i > 0 && i != op->direction)
     {
       op->direction = i;
       SET_ANIMATION (op, op->direction);
     }
-  m->insert (op, new_x, new_y, op);
+  pos.insert (op, op);
 }
 /****************************************************************************
  * Destruction
  ****************************************************************************/
   object *tmp = get_archetype (FORCE_NAME);
   tmp->speed = 0.01;
   tmp->stats.food = time;
   SET_FLAG (tmp, FLAG_IS_USED_UP);
-  tmp->glow_radius = radius;
-  if (tmp->glow_radius > MAX_LIGHT_RADII)
-    tmp->glow_radius = MAX_LIGHT_RADII;
+  tmp->glow_radius = min (MAX_LIGHT_RADIUS, radius);
   tmp = insert_ob_in_ob (tmp, op);
   if (tmp->glow_radius > op->glow_radius)
     op->glow_radius = tmp->glow_radius;
   else
     op->skill = NULL;
   op->change_skill (find_skill_by_name (op, op->skill));
-  for (i = -range; i < range; i++)
+  for (i = -range; i <= range; i++)
     {
-      for (j = -range; j < range; j++)
+      for (j = -range; j <= range; j++)
         {
           m = op->map;
           sx = op->x + i;
           sy = op->y + j;
                       (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
                     {
                       if (spell_ob->subtype == SP_DESTRUCTION)
                         {
                           hit_player (tmp, dam, op, spell_ob->attacktype, 0);
                           if (spell_ob->other_arch)
                             m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
                         }
                       else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
                         {
   /* We precompute some values here so that we don't have to keep
    * doing it over and over again.
    */
   god = find_god (determine_god (op));
-  level = caster_level (caster, spell);
+  level = casting_level (caster, spell);
   range = spell->range + SP_level_range_adjust (caster, spell);
   /* On the bright side, no monster should ever have a race of GOD_...
    * so even if the player doesn't worship a god, if race=GOD_.., it
    * won't ever match anything.
         /* If there is nothing living on this space, no need to go further */
         if (!(mflags & P_IS_ALIVE))
           continue;
         // players can only affect spaces that they can actually see
+        if (caster
-        if (caster && caster->contr
+            && caster->contr
-            && caster->contr->visibility_at (m, nx, ny) < 70)
+            && caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
           continue;
         for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)
           if (QUERY_FLAG (tmp, FLAG_MONSTER))
             break;
       }                         /* for y */
   return 1;
 }
 /* Move_ball_spell: This handles ball type spells that just sort of wander
  * about.  was called move_ball_lightning, but since more than the ball
  * lightning spell used it, that seemed misnamed.
  * op is the spell effect.
  * note that duration is handled by process_object() in time.c
  */
 void
 move_ball_spell (object *op)
 {
   int i, j, dam_save, dir, mflags;
   sint16 nx, ny, hx, hy;
   for (i = 1; i < 9; i++)
     {
       /* i bit 0: alters sign of offset
        * other bits (i / 2): absolute value of offset
        */
       int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
       int tmpdir = absdir (op->direction + offset);
       nx = op->x + freearr_x[tmpdir];
       ny = op->y + freearr_y[tmpdir];
         {
           dir = tmpdir;
           break;
         }
     }
   if (dir == 0)
     {
       nx = op->x;
       ny = op->y;
       m = op->map;
       if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
         {
           if (j)
             op->stats.dam = dam_save / 2;
           hit_map (op, j, op->attacktype, 1);
         }
       /* insert the other arch */
       if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
         m->insert (arch_to_object (op->other_arch), hx, hy, op);
   int adjustdir;
   maptile *m;
 #endif
   object *owner = op->env;
+  if (!owner) // MUST not happen, remove when true TODO
+    {
+      LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
+      op->destroy ();
+      return;
+    }
   if (!op->duration || !owner->is_on_map ())
     {
-      op->destroy ();
+      op->drop_and_destroy ();
       return;
     }
   op->duration--;
   int basedir = op->direction;
   if (!basedir)
+    {
-    /* spray in all directions! 8) */
+      /* spray in all directions! 8) */
-    basedir = (op->facing += op->state) % 8 + 1;
+      op->facing = (op->facing + op->state) & 7;
+      basedir = op->facing + 1;
+    }
 #if 0
   // this is bogus: it causes wrong places to be checked below
   // (a wall 2 cells away will block the effect...) and
   // doesn't work for SP_BULLET anyhow, so again tests the wrong
 {
   if (!spell->other_arch)
     return 0;
   object *tmp = archetype::get (SWARM_SPELL);
   set_spell_skill (op, caster, spell, tmp);
-  tmp->level      = caster_level (caster, spell);    /* needed later, to get level dep. right. */
+  tmp->level      = casting_level (caster, spell);    /* needed later, to get level dep. right. */
   tmp->spell      = spell->other_arch->instance ();
   tmp->attacktype = tmp->spell->attacktype;
   if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
     if (!tailor_god_spell (tmp, op))
   tmp->duration = SP_level_duration_adjust (caster, spell);
   for (int i = 0; i < spell->duration; i++)
     tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
+  tmp->invisible = 1;
+  tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
   tmp->direction = dir;
-  tmp->invisible = 1;
   tmp->facing    = rndm (1, 8); // initial firing direction
   tmp->state     = rndm (4) * 2 + 1; // direction increment
   op->insert (tmp);
   int dam, mflags;
   maptile *m;
   dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
-  if (!dir)
+  if (dir)
-    {
-      new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
-      return 0;
-    }
+    {
-  x = op->x + freearr_x[dir];
+      x = op->x + freearr_x[dir];
-  y = op->y + freearr_y[dir];
+      y = op->y + freearr_y[dir];
-  m = op->map;
+      m = op->map;
-  mflags = get_map_flags (m, &m, x, y, &x, &y);
+      mflags = get_map_flags (m, &m, x, y, &x, &y);
-  if (mflags & P_OUT_OF_MAP)
+      if (mflags & P_OUT_OF_MAP)
-    {
+        {
-      new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
+          new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
-      return 0;
+          return 0;
-    }
+        }
-  if (mflags & P_IS_ALIVE && spell->attacktype)
+      if (mflags & P_IS_ALIVE && spell->attacktype)
-    {
+        {
-      for (target = GET_MAP_OB (m, x, y); target; target = target->above)
+          for (target = GET_MAP_OB (m, x, y); target; target = target->above)
-        if (QUERY_FLAG (target, FLAG_MONSTER))
+            if (QUERY_FLAG (target, FLAG_MONSTER))
-          {
+              {
-            /* oky doky. got a target monster. Lets make a blinding attack */
+                /* oky doky. got a target monster. Lets make a blinding attack */
-            if (target->head)
+                if (target->head)
-              target = target->head;
+                  target = target->head;
-            (void) hit_player (target, dam, op, spell->attacktype, 1);
+                hit_player (target, dam, op, spell->attacktype, 1);
-            return 1;           /* one success only! */
+                return 1;           /* one success only! */
+              }
-          }
+        }
-    }
-  /* no live target, perhaps a wall is in the way? */
+      /* no live target, perhaps a wall is in the way? */
-  if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
+      if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
-    {
+        {
-      new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
+          new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
-      return 0;
+          return 0;
+        }
     }
   /* ok, looks groovy to just insert a new light on the map */
   tmp = arch_to_object (spell->other_arch);
   if (!tmp)
     {
       LOG (llevError, "Error: spell arch for cast_light() missing.\n");
       return 0;
     }
   tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
   if (tmp->glow_radius)
-    {
-      tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);
+    tmp->glow_radius = min (MAX_LIGHT_RADIUS, spell->range + SP_level_range_adjust (caster, spell));
-      if (tmp->glow_radius > MAX_LIGHT_RADII)
-        tmp->glow_radius = MAX_LIGHT_RADII;
-    }
+  if (dir)
-  m->insert (tmp, x, y, op);
+    m->insert (tmp, x, y, op);
+  else
+    caster->outer_env ()->insert (tmp);
   return 1;
 }
 /* cast_cause_disease:  this spell looks along <dir> from the
  * player and infects someone.
                 object *disease = arch_to_object (spell->other_arch);
                 disease->set_owner (op);
                 set_spell_skill (op, caster, spell, disease);
                 disease->stats.exp = 0;
-                disease->level = caster_level (caster, spell);
+                disease->level = casting_level (caster, spell);
                 /* do level adjustments */
                 if (disease->stats.wc)
                   disease->stats.wc += dur_mod / 2;

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC vs. Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC vs.
Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC