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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.100 by root, Fri Apr 9 02:45:17 2010 UTC vs.
Revision 1.116 by root, Sat Sep 16 22:17:42 2017 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the Affero GNU General Public License
  * and the GNU General Public License along with this program. If not, see
  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
 /* This file contains all the spell attack code.  Grouping this code
  * together should hopefully make it easier to find the relevent bits
   for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
       int num_sections = 1;
       /* don't move DM */
-      if (QUERY_FLAG (tmp, FLAG_WIZ))
+      if (tmp->flag [FLAG_WIZ])
         return;
       /* don't move parts of objects */
       if (tmp->head)
         continue;
       /* 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)))
+      if (tmp->flag [FLAG_IS_FLOOR] || (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
         continue;
       /* count the object's sections */
       for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
         num_sections++;
       if (tmp->move_type & MOVE_FLYING)
         frictionmod = 1;        /* flying objects loose the friction modifier */
       if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
         {                       /* move it. */
           /* move_object is really for monsters, but looking at
            * the move_object function, it appears that it should
            * also be safe for objects.
            * This does return if successful or not, but
            * I don't see us doing anything useful with that information
            * right now.
     new_dir = -1;
   /* check the new dir for a wall and in the map */
   t_dir = absdir (tmp->direction + new_dir);
-  if (get_map_flags (tmp->map, &m, tmp->x + freearr_x[t_dir], tmp->y + freearr_y[t_dir], &sx, &sy) & P_OUT_OF_MAP)
+  if (get_map_flags (tmp->map, &m, tmp->x + DIRX (t_dir), tmp->y + DIRY (t_dir), &sx, &sy) & P_OUT_OF_MAP)
     return;
   if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
     return;
   if (--op->range < 0)
     op->range = 0;
   else
     {
-      x = op->x + DIRX (op);
+      x = op->x + DIRX (op->direction);
-      y = op->y + DIRY (op);
+      y = op->y + DIRY (op->direction);
       m = op->map;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
         return;
        * on the space.  So only call reflwall if we think the data it returns
        * will be useful.
        */
       if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
         {
-          if (!QUERY_FLAG (op, FLAG_REFLECTING))
+          if (!op->flag [FLAG_REFLECTING])
             return;
           /* Since walls don't run diagonal, if the bolt is in
            * one of 4 main directions, it just reflects back in the
            * opposite direction.  However, if the bolt is travelling
               /* Need to check for P_OUT_OF_MAP: if the bolt is tavelling
                * over a corner in a tiled map, it is possible that
                * op->direction is within an adjacent map but either
                * op->direction-1 or op->direction+1 does not exist.
                */
-              mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction - 1)],
+              mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction - 1)),
-                                      op->y + freearr_y[absdir (op->direction - 1)], &x, &y);
+                                      op->y + DIRY (absdir (op->direction - 1)), &x, &y);
               left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
-              mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction + 1)],
+              mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction + 1)),
-                                      op->y + freearr_y[absdir (op->direction + 1)], &x, &y);
+                                      op->y + DIRY (absdir (op->direction + 1)), &x, &y);
               right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
               if (left == right)
                 op->direction = absdir (op->direction + 4);
               else if (left)
           tmp->speed_left = -0.1f;
           /* To make up for the decrease at the top of the function */
           tmp->duration++;
           /* New forking code.  Possibly create forks of this object
            * going off in other directions.
            */
           if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
             forklightning (op, tmp); /* stats.Dex % of forking */
           /* In this way, the object left behind sticks on the space, but
   tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
   tmp->stats.Dex = spob->stats.Dex;
   tmp->stats.Con = spob->stats.Con;
   tmp->direction = dir;
-  if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+  if (tmp->flag [FLAG_IS_TURNABLE])
     SET_ANIMATION (tmp, dir);
   tmp->set_owner (op);
   set_spell_skill (op, caster, spob, tmp);
-  tmp->x = op->x + DIRX (tmp);
+  tmp->x = op->x + DIRX (tmp->direction);
-  tmp->y = op->y + DIRY (tmp);
+  tmp->y = op->y + DIRY (tmp->direction);
   tmp->map = op->map;
   maptile *newmap;
   mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
   if (mflags & P_OUT_OF_MAP)
   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))
+      if (!tmp->flag [FLAG_REFLECTING])
         {
           tmp->drop_and_destroy ();
           return 0;
         }
     {
       for (i = 1; i < 9; i++)
         {
           sint16 dx, dy;
-          dx = op->x + freearr_x[i];
+          dx = op->x + DIRX (i);
-          dy = op->y + freearr_y[i];
+          dy = op->y + DIRY (i);
           /* ok_to_put_more already does things like checks for walls,
            * out of map, etc.
            */
           if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
             {
               object *tmp = op->clone ();
   if (!(mflags & P_IS_ALIVE))
     return;
   for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
-      if (QUERY_FLAG (tmp, FLAG_ALIVE))
+      if (tmp->flag [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))
+              if (!op->flag [FLAG_REMOVED])
                 {
                   op->destroy ();
                   return;
                 }
             }
 move_bullet (object *op)
 {
 #if 0
   /* We need a better general purpose way to do this */
   /* peterm:  added to make comet leave a trail of burnouts
      it's an unadulterated hack, but the effect is cool.      */
   if (op->stats.sp == SP_METEOR)
     {
       replace_insert_ob_in_map ("fire_trail", op);
       if (op->destroyed ())
   tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
   tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
   tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
   tmp->direction = dir;
-  if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+  if (tmp->flag [FLAG_IS_TURNABLE])
     SET_ANIMATION (tmp, dir);
   tmp->set_owner (op);
   set_spell_skill (op, caster, spob, tmp);
-  tmp->x   = op->x + freearr_x[dir];
+  tmp->x   = op->x + DIRX (dir);
-  tmp->y   = op->y + freearr_y[dir];
+  tmp->y   = op->y + DIRY (dir);
   tmp->map = op->map;
   maptile *newmap;
   mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
   if (mflags & P_OUT_OF_MAP)
       return 0;
     }
   if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
     {
-      if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
+      if (!tmp->flag [FLAG_REFLECTING])
         {
           tmp->destroy ();
           return 0;
         }
       op->set_speed (0);
       return;
     }
   /* lava saves it's life, but not yours  :) */
-  if (QUERY_FLAG (op, FLAG_LIFESAVE))
+  if (op->flag [FLAG_LIFESAVE])
     {
       hit_map (op, 0, op->attacktype, 0);
       return;
     }
   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);
       return;
     }
   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)];
+      sint16 x = op->x + DIRX (absdir (op->stats.sp + i)), y = op->y + DIRY (absdir (op->stats.sp + i));
       if (ok_to_put_more (op->map, x, y, op, op->attacktype))
         {
           object *tmp = op->clone ();
   MoveType movetype;
   if (!spell->other_arch)
     return 0;
-  if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)
+  if (op->type == PLAYER && op->flag [FLAG_UNDEAD] && op->attacktype & AT_TURN_UNDEAD)
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");
+      op->failmsg ("Your undead nature prevents you from turning undead!");
       return 0;
     }
   if (!dir)
     {
             d = 8;
           else
             continue;
         }
-      x = op->x + freearr_x[d];
+      x = op->x + DIRX (d);
-      y = op->y + freearr_y[d];
+      y = op->y + DIRY (d);
       if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)
         continue;
       if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
    */
   if (archetype *at = archetype::find (SPLINT))
     {
       for (int i = 1; i < 9; i++)
         {
-          if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
+          if (out_of_map (op->map, op->x + DIRX (i), op->y + DIRX (i)))
             continue;
           object *tmp = at->instance ();
           tmp->direction = i;
           tmp->range = op->range;
           tmp->attacktype = op->attacktype;
           tmp->set_owner (op);
           if (op->skill && op->skill != tmp->skill)
             tmp->skill = op->skill;
-          if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+          if (tmp->flag [FLAG_IS_TURNABLE])
             SET_ANIMATION (tmp, i);
-          op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
+          op->map->insert (tmp, op->x + DIRX (i), op->y + DIRX (i), op);
           move_bullet (tmp);
         }
     }
   explode_bullet (op);
 int
 create_bomb (object *op, object *caster, int dir, object *spell)
 {
   object *tmp;
   int mflags;
-  sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
+  sint16 dx = op->x + DIRX (dir), dy = op->y + DIRY (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
   // 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))
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
+          op->failmsg ("There is something in the way.");
           return 0;
         }
     }
   tmp = spell->other_arch->instance ();
   if (dir == 0)
     return NULL;
   for (dist = 1; dist < range; dist++)
     {
-      x = op->x + freearr_x[dir] * dist;
+      x = op->x + DIRX (dir) * dist;
-      y = op->y + freearr_y[dir] * dist;
+      y = op->y + DIRY (dir) * dist;
       mp = op->map;
       mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
         return NULL;
       if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
         return NULL;
       if (mflags & P_IS_ALIVE)
         for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
-          if (QUERY_FLAG (target, FLAG_MONSTER))
+          if (target->flag [FLAG_MONSTER])
             return target;
     }
   return NULL;
 }
-/* cast_smite_arch() - the priest points to a creature and causes
+/* cast_smite_spell() - the priest points to a creature and causes
  * a 'godly curse' to decend.
  * usual params -
  * op = player
  * caster = object casting the spell.
  * dir = direction being cast
  * spell = spell object
 int
 cast_smite_spell (object *op, object *caster, int dir, object *spell)
 {
   object *effect, *target;
   object *god = find_god (determine_god (op));
-  int range;
-  range = spell->range + SP_level_range_adjust (caster, spell);
   target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
   /* Bunch of conditions for casting this spell.  Note that only
    * require a god if this is a cleric spell (requires grace).
    * This makes this spell much more general purpose - it can be used
    * by wizards also, which is good, because I think this is a very
    * interesting spell.
    * if it is a cleric spell, you need a god, and the creature
       || target->flag [FLAG_REFL_SPELL]
       || (!god && spell->stats.grace)
       || (god && target->title == god->name)
       || (god && target->race.contains (god->race)))
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");
+      op->failmsg ("Your request is unheeded.");
       return 0;
     }
   if (spell->other_arch)
     effect = spell->other_arch->instance ();
     {
       if (tailor_god_spell (effect, op))
         new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
       else
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");
+          op->failmsg ("Your request is ignored.");
           return 0;
         }
     }
   /* size of the area of destruction */
   if (effect->attacktype & AT_DEATH)
     {
       effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
       /* casting death spells at undead isn't a good thing */
-      if (QUERY_FLAG (target, FLAG_UNDEAD))
+      if (target->flag [FLAG_UNDEAD])
         {
           if (random_roll (0, 2, op, PREFER_LOW))
             {
               new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
               effect->x = op->x;
 /****************************************************************************
  * Destruction
  ****************************************************************************/
 /* make_object_glow() - currently only makes living objects glow.
  * we do this by creating a force and inserting it in the
  * object. if time is 0, the object glows permanently. To truely
  * make this work for non-living objects, we would have to
  * give them the capability to have an inventory. b.t.
  */
 static int
 make_object_glow (object *op, int radius, int time)
 {
   /* some things are unaffected... */
   if (op->path_denied & PATH_LIGHT)
     return 0;
-  object *tmp = get_archetype (FORCE_NAME);
+  object *tmp = archetype::get (FORCE_NAME);
-  tmp->speed = 0.01;
+  tmp->set_speed (0.01);
   tmp->stats.food = time;
-  SET_FLAG (tmp, FLAG_IS_USED_UP);
+  tmp->set_flag (FLAG_IS_USED_UP);
   tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
   tmp = insert_ob_in_ob (tmp, op);
   if (tmp->glow_radius > op->glow_radius)
     op->set_glow_radius (tmp->glow_radius);
   int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
   int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
   int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
   bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
-  /* destruction doesn't use another spell object, so we need
-   * update op's skill pointer so that exp is properly awarded.
-   */
-  const shstr skill = op->skill;
-  if (caster == op)
-    op->skill = spell_ob->skill;
-  else if (caster->skill)
-    op->skill = caster->skill;
-  else
-    op->skill = 0;
-  op->change_skill (find_skill_by_name (op, op->skill));
   dynbuf buf;
   unordered_mapwalk (buf, op, -range, -range, range, range)
     {
       mapspace &ms = m->at (nx, ny);
                   }
               }
           }
     }
-  op->skill = skill;
   return 1;
 }
 /***************************************************************************
  *
   object *tmp, *force;
   tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
   if (!tmp)
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
+      op->failmsg ("There is no one in that direction to curse.");
       return 0;
     }
   tmp = tmp->head_ ();
         }
     }
   if (!force)
     {
-      force = get_archetype (FORCE_NAME);
+      force = archetype::get (FORCE_NAME);
       force->subtype = FORCE_CHANGE_ABILITY;
       if (spell_ob->race)
         force->name = spell_ob->race;
       else
       return 1;
     }
   force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
-  force->speed = 1.f;
   force->speed_left = -1.f;
-  SET_FLAG (force, FLAG_APPLIED);
+  force->set_speed (1.f);
+  force->set_flag (FLAG_APPLIED);
   if (god)
     {
       if (spell_ob->last_grace)
         force->path_repelled = god->path_repelled;
   unordered_mapwalk (buf, op, -range, -range, range, range)
     {
       mapspace &ms = m->at (nx, ny);
       /* If there is nothing living on this space, no need to go further */
-      if (!ms.flags () & P_IS_ALIVE)
+      if (!(ms.flags () & P_IS_ALIVE))
         continue;
       // players can only affect spaces that they can actually see
       if (caster
           && caster->contr
       /* Make sure the race is OK.  Likewise, only effect undead if spell specifically allows it */
       if (race && head->race && !strstr (race, head->race))
         continue;
-      if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
+      if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
         continue;
       /* Now do a bunch of stuff related to saving throws */
       best_at = -1;
       if (spell->attacktype)
       /* Done with saving throw.  Now start affecting the monster */
       done_one = 0;
       /* aggravation */
-      if (QUERY_FLAG (spell, FLAG_MONSTER))
+      if (spell->flag [FLAG_MONSTER])
         {
-          CLEAR_FLAG (head, FLAG_SLEEP);
+          head->clr_flag (FLAG_SLEEP);
           remove_friendly_object (head);
           done_one = 1;
           head->enemy = op;
         }
       /* calm monsters */
-      if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
+      if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
         {
-          SET_FLAG (head, FLAG_UNAGGRESSIVE);
+          head->set_flag (FLAG_UNAGGRESSIVE);
           head->enemy = NULL;
           done_one = 1;
         }
       /* berserk monsters */
-      if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
+      if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
         {
-          SET_FLAG (head, FLAG_BERSERK);
+          head->set_flag (FLAG_BERSERK);
           done_one = 1;
         }
       /* charm */
-      if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
+      if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
         {
           INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
           /* Prevent uncontrolled outbreaks of self replicating monsters.
              Typical use case is charm, go somwhere, use aggravation to make hostile.
              This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
-          CLEAR_FLAG (head, FLAG_GENERATOR);
+          head->clr_flag (FLAG_GENERATOR);
           head->set_owner (op);
           set_spell_skill (op, caster, spell, head);
           add_friendly_object (head);
           head->attack_movement = PETMOVE;
           done_one = 1;
        * 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];
+      nx = op->x + DIRX (tmpdir);
-      ny = op->y + freearr_y[tmpdir];
+      ny = op->y + DIRY (tmpdir);
       if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny))))
         {
           dir = tmpdir;
           break;
         }
       m = op->map;
     }
   m->insert (op, nx, ny, op);
   dam_save = op->stats.dam;     /* save the original dam: we do halfdam on
                                    surrounding squares */
   /* loop over current square and neighbors to hit.
    * if this has an other_arch field, we insert that in
    * the surround spaces.
    */
   for (j = 0; j < 9; j++)
     {
-      hx = nx + freearr_x[j];
+      hx = nx + DIRX (j);
-      hy = ny + freearr_y[j];
+      hy = ny + DIRY (j);
       m = op->map;
       mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
       if (mflags & P_OUT_OF_MAP)
   i = spell_find_dir (op->map, op->x, op->y, op->owner);
   if (i >= 0)
     {                           /* we have a preferred direction!  */
       /* pick another direction if the preferred dir is blocked. */
-      if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||
+      if (get_map_flags (op->map, &m, nx + DIRX (i), ny + DIRY (i), &hx, &hy) & P_OUT_OF_MAP ||
           OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
         i = absdir (i + rndm (0, 2) - 1);     /* -1, 0, +1 */
       op->direction = i;
     }
 }
 /* move_swarm_spell: peterm
  * This is an implementation of the swarm spell.  It was written for
  * meteor swarm, but it could be used for any swarm. A swarm spell
  * is a special type of object that casts swarms of other types
  * of spells.  Which spell it casts is flexible. It fires the spells
  * from a set of squares surrounding the caster, in a given direction.
  */
 void
 move_swarm_spell (object *op)
 {
 #if 0
   // space.
   // should be fixed later, but correctness before features...
   // (schmorp)
   /* new offset calculation to make swarm element distribution
    * more uniform
    */
   if (op->duration)
     {
       if (basedir & 1)
         {
   else
     {
       adjustdir = 0;            /* fire the last one from forward. */
     }
-  target_x = op->x + freearr_x[absdir (basedir + adjustdir)];
+  target_x = op->x + DIRX (absdir (basedir + adjustdir));
-  target_y = op->y + freearr_y[absdir (basedir + adjustdir)];
+  target_y = op->y + DIRY (absdir (basedir + adjustdir));
   /* back up one space so we can hit point-blank targets, but this
    * necessitates extra out_of_map check below
    */
-  origin_x = target_x - freearr_x[basedir];
+  origin_x = target_x - DIRX (basedir);
-  origin_y = target_y - freearr_y[basedir];
+  origin_y = target_y - DIRY (basedir);
   /* spell pointer is set up for the spell this casts.  Since this
    * should just be a pointer to the spell in some inventory,
    * it is unlikely to disappear by the time we need it.  However,
 }
 /*  fire_swarm:
  *  The following routine creates a swarm of objects.  It actually
  *  sets up a specific swarm object, which then fires off all
  *  the parts of the swarm.
  *
  *  op:  the owner
  *  caster: the caster (owner, wand, rod, scroll)
  *  dir: the direction everything will be fired in
  *  spell - the spell that is this spell.
   dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
   if (dir)
     {
-      x = op->x + freearr_x[dir];
+      x = op->x + DIRX (dir);
-      y = op->y + freearr_y[dir];
+      y = op->y + DIRY (dir);
       m = op->map;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
+          op->failmsg ("Nothing is there.");
           return 0;
         }
       if (mflags & P_IS_ALIVE && spell->attacktype)
         {
           for (target = GET_MAP_OB (m, x, y); target; target = target->above)
-            if (QUERY_FLAG (target, FLAG_MONSTER))
+            if (target->flag [FLAG_MONSTER])
               {
                 /* oky doky. got a target monster. Lets make a blinding attack */
                 if (target->head)
                   target = target->head;
         }
       /* no live target, perhaps a wall is in the way? */
       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.");
+          op->failmsg ("Something is in the way.");
           return 0;
         }
     }
   /* ok, looks groovy to just insert a new light on the map */
   return 1;
 }
 /* cast_cause_disease:  this spell looks along <dir> from the
  * player and infects someone.
  * op is the player/monster, caster is the object, dir is the direction
  * to cast, disease_arch is the specific disease, and type is the spell number
  * perhaps this should actually be in disease.c?
  */
 int
   maptile *m;
   x = op->x;
   y = op->y;
   /* If casting from a scroll, no direction will be available, so refer to the
    * direction the player is pointing.
    */
   if (!dir)
     dir = op->facing;
   dur_mod = SP_level_duration_adjust (caster, spell);
   /* search in a line for a victim */
   for (i = 1; i < range; i++)
     {
-      x = op->x + i * freearr_x[dir];
+      x = op->x + i * DIRX (dir);
-      y = op->y + i * freearr_y[dir];
+      y = op->y + i * DIRY (dir);
       m = op->map;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
       /* Only bother looking on this space if there is something living here */
       if (mflags & P_IS_ALIVE)
         {
           /* search this square for a victim */
           for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
-            if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
+            if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
               {                 /* found a victim */
                 object *disease = spell->other_arch->instance ();
                 disease->set_owner (op);
                 set_spell_skill (op, caster, spell, disease);
                     if (disease->last_sp < 1)
                       disease->last_sp = 1;
                   }
-                if (disease->stats.dam  ) disease->stats.dam   += copysign (disease->stats.dam  , dam_mod);
+                if (disease->stats.dam  ) disease->stats.dam   += copysignl (disease->stats.dam  , dam_mod);
-                if (disease->stats.maxsp) disease->stats.maxsp += copysign (disease->stats.maxsp, dam_mod);
+                if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
                 if (disease->stats.ac   ) disease->stats.ac    += dam_mod;
                 if (disease->last_eat   ) disease->last_eat    -= dam_mod;
                 if (disease->stats.hp   ) disease->stats.hp    -= dam_mod;
                 if (disease->stats.sp   ) disease->stats.sp    -= dam_mod;
                 if (infect_object (walk, disease, 1))
                   {
                     op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
                     disease->destroy ();      /* don't need this one anymore */
-                    walk->map->insert (get_archetype (shstr_detect_magic), x, y, op);
+                    walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
                     return 1;
                   }
                 disease->destroy ();
               }

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.100 by root, Fri Apr 9 02:45:17 2010 UTC vs. Revision 1.116 by root, Sat Sep 16 22:17:42 2017 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.100 by root, Fri Apr 9 02:45:17 2010 UTC vs.
Revision 1.116 by root, Sat Sep 16 22:17:42 2017 UTC