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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.131 by root, Fri Apr 23 04:32:47 2010 UTC vs.
Revision 1.149 by root, Sat Dec 1 20:22:13 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
- * 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 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>
  */
 #include <global.h>
 #include <object.h>
   if (!(random_roll (0, 3, op, PREFER_HIGH)))
     {
       op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
       op->play_sound (sound_find ("ob_explode"));
       wand->destroy ();
-      object *tmp = get_archetype (shstr_fireball);
+      object *tmp = archetype::get (shstr_fireball);
       tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
       if (!tmp->stats.dam)
         tmp->stats.dam = 1;
   /* Can't get any money for these objects */
   missile->value = 0;
   missile->set_flag (FLAG_IDENTIFIED);
-  if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
+  cast_create_obj (op, caster, missile, dir);
+  if (!dir
+      && op->type == PLAYER
+      && !missile->destroyed ())
     pick_up (op, missile);
   return 1;
 }
 /*  allows the choice of what sort of food object to make.
  *  If spellparam is NULL, it will create food dependent on level  --PeterM*/
 int
 cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
     }
   maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
   for (r = 1; r < maxrange; r++)
     {
-      sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
+      sint16 x = op->x + r * DIRX (dir), y = op->y + r * DIRY (dir);
       m = op->map;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
   /* Remove the switch with 90% duplicate code - just handle the differences with
    * and if statement or two.
    */
   op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
-  /* max duration */
+  /* limit duration */
-  if (op->invisible > 1000)
+  min_it (op->invisible, 1000);
-    op->invisible = 1000;
   if (op->type == PLAYER)
     {
       op->contr->invis_race = spell_ob->race;
       if (spell_ob->flag [FLAG_MAKE_INVIS])
         op->contr->tmp_invis = 0;
       else
         op->contr->tmp_invis = 1;
-      op->contr->hidden = 0;
     }
   if (makes_invisible_to (op, op))
     new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
   else
   op->destroy ();
 }
 /* Word of recall causes the player to return 'home'.
  * we put a force into the player object, so that there is a
  * time delay effect.
  */
 int
 cast_word_of_recall (object *op, object *caster, object *spell_ob)
 {
     {
       new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
       return 1;
     }
-  object *dummy = get_archetype (FORCE_NAME);
+  object *dummy = archetype::get (FORCE_NAME);
   int time = max (1, spell_ob->duration - SP_level_duration_adjust (caster, spell_ob));
   /* value of speed really doesn't make much difference, as long as it is
    * positive.  Lower value may be useful so that the problem doesn't
       x = op->x;
       y = op->y;
     }
   else
     {
-      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;
   if ((spell_ob->move_block || x != op->x || y != op->y) &&
   /* If this is a spellcasting wall, need to insert the spell object */
   if (tmp->other_arch && tmp->other_arch->type == SPELL)
     insert_ob_in_ob (tmp->other_arch->instance (), tmp);
   /*  This code causes the wall to extend some distance in
    * each direction, or until an obstruction is encountered.
    * posblocked and negblocked help determine how far the
    * created wall can extend, it won't go extend through
    * blocked spaces.
    */
   maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
     {
       int dir2;
       dir2 = (dir < 4) ? (dir + 2) : dir - 2;
-      x = tmp->x + i * freearr_x[dir2];
+      x = tmp->x + i * DIRX (dir2);
-      y = tmp->y + i * freearr_y[dir2];
+      y = tmp->y + i * DIRY (dir2);
       m = tmp->map;
       if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
           ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
         {
         }
       else
         posblocked = 1;
-      x = tmp->x - i * freearr_x[dir2];
+      x = tmp->x - i * DIRX (dir2);
-      y = tmp->y - i * freearr_y[dir2];
+      y = tmp->y - i * DIRY (dir2);
       m = tmp->map;
       if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
           ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
         {
           return 0;
         }
       for (dist = 0; dist < count; dist++)
         {
-          mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
+          mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
           if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
             break;
           if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
        * by such squares).  Also, there are probably treasure rooms and
        * lots of other maps that protect areas with no magic, but the
        * areas themselves don't contain no magic spaces.
        */
       /* This call here is really just to normalize the coordinates */
-      mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, &sx, &sy);
+      mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, &sx, &sy);
       if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
         {
           new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");
           return 1;             /* Maybe the penalty should be more severe... */
         }
        * spaces that blocked the players view.
        */
       for (dist = 0; dist < maxdist; dist++)
         {
-          mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
+          mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
           if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
             break;
           if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
       /* If the destination is blocked, keep backing up until we
        * find a place for the player.
        */
       for (; dist > 0; dist--)
         {
-          if (get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist,
+          if (get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist,
                              &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))
             continue;
           if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
           return 0;
         }
     }
   /* Actually move the player now */
-  if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
+  if (!(op = op->map->insert (op, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, op)))
     return 1;
   op->speed_left = -5. * op->speed;       /* Freeze them for a short while */
   return 1;
   new_draw_info_format (NDI_UNIQUE, 0, op,
                         "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
                         TICK2TIME (duration));
-  force = get_archetype (FORCE_NAME);
+  force = archetype::get (FORCE_NAME);
   force->subtype = FORCE_CHANGE_ABILITY;
   force->duration = duration;
   if (spell_ob->race)
     force->name = spell_ob->race;
   force->speed_left = -1.0;
   force->set_flag (FLAG_APPLIED);
   /* Now start processing the effects.  First, protections */
   for (i = 0; i < NROFATTACKS; i++)
-    {
-      if (spell_ob->resist[i])
+    if (spell_ob->resist[i])
-        {
-          force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
+      force->resist[i] = min (100, spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob));
-          if (force->resist[i] > 100)
-            force->resist[i] = 100;
-        }
-    }
   if (spell_ob->stats.hp)
     force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
   if (tmp->type == PLAYER)
         }
     }
   if (force == NULL)
     {
-      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
         force->name = spell_ob->name;
         {
           new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
         }
       return 0;
     }
   force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
   force->speed = 1.0;
   force->speed_left = -1.0;
   force->set_flag (FLAG_APPLIED);
 /* Alchemy code by Mark Wedel
  *
  * This code adds a new spell, called alchemy.  Alchemy will turn
  * objects to pyrite ("false gold"), henceforth called gold nuggets.
  *
  * The value of the gold nuggets being about 90% of that of the item
  * itself.  It uses the value of the object before charisma adjustments,
  * because the nuggets themselves will be will be adjusted by charisma
  * when sold.
  *
             }
           value -= rndm (value >> 4);
           value = min (value, value_max);
-          for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
+          for (int i = 0; i < ecb_array_length (nugget); ++i)
             if (int nrof = value / nugget [i]->value)
               {
                 value -= nrof * nugget[i]->value;
                 object *tmp = nugget[i]->instance ();
 int
 remove_curse (object *op, object *caster, object *spell)
 {
   int success = 0, was_one = 0;
+  int num_uncurse = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
+  op->splay_marked ();
+  int typeflag = spell->last_sp ? FLAG_DAMNED : FLAG_CURSED;
-  for (object *tmp = op->inv; tmp; tmp = tmp->below)
+  for (object *tmp = op->inv; tmp && num_uncurse; tmp = tmp->below)
-    if (tmp->flag [FLAG_APPLIED] &&
+    if (!tmp->invisible && tmp->flag [typeflag])
-        ((tmp->flag [FLAG_CURSED] && spell->flag [FLAG_CURSED]) ||
-         (tmp->flag [FLAG_DAMNED] && spell->flag [FLAG_DAMNED])))
       {
-        was_one++;
+        ++was_one;
         if (tmp->level <= casting_level (caster, spell))
           {
-            success++;
+            ++success;
-            if (spell->flag [FLAG_DAMNED])
+            --num_uncurse;
-              tmp->clr_flag (FLAG_DAMNED);
+            tmp->clr_flag (typeflag);
             tmp->clr_flag (FLAG_CURSED);
             tmp->clr_flag (FLAG_KNOWN_CURSED);
             tmp->value = 0;     /* Still can't sell it */
             if (object *pl = tmp->visible_to ())
       }
   if (op->type == PLAYER)
     {
       if (success)
-        new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
+        new_draw_info (NDI_UNIQUE, 0, op, "You realise that some of your items look shinier now. H<You successfully removed some curses.>");
       else
         {
           if (was_one)
-            new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
+            new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove any curse. H<The spell was not strong enough.>");
           else
-            new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
+            new_draw_info (NDI_UNIQUE, 0, op, "You are not having any cursed items. H<Epic fail.>");
         }
     }
   return success;
 }
 /* Identifies objects in the players inventory/on the ground */
 int
 cast_identify (object *op, object *caster, object *spell)
 {
-  object *tmp;
   dynbuf_text &buf = msg_dynbuf; buf.clear ();
   int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
+  op->splay_marked ();
-  for (tmp = op->inv; tmp; tmp = tmp->below)
+  for (object *tmp = op->inv; tmp; tmp = tmp->below)
     {
       if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
         {
           identify (tmp);
    * stuff on the floor.  Only identify stuff on the floor if the spell
    * was not fully used.
    */
   if (num_ident)
     {
-      for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
+      for (object *tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
         if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
           {
             identify (tmp);
             if (object *pl = tmp->visible_to ())
 int
 cast_detection (object *op, object *caster, object *spell, object *skill)
 {
   object *tmp, *last, *god, *detect;
-  int done_one, range, mflags, floor, level;
+  int done_one, range, floor, level;
   sint16 x, y, nx, ny;
   maptile *m;
   /* We precompute some values here so that we don't have to keep
    * doing it over and over again.
   sint16 x, y;
   maptile *m;
   int mflags;
   m = op->map;
-  x = op->x + freearr_x[dir];
+  x = op->x + DIRX (dir);
-  y = op->y + freearr_y[dir];
+  y = op->y + DIRY (dir);
   mflags = get_map_flags (m, &m, x, y, &x, &y);
   if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
     {
   object *tmp, *head, *next;
   int mflags;
   maptile *m;
   sint16 sx, sy;
-  sx = op->x + freearr_x[dir];
+  sx = op->x + DIRX (dir);
-  sy = op->y + freearr_y[dir];
+  sy = op->y + DIRY (dir);
   m = op->map;
   mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
   if (mflags & P_OUT_OF_MAP)
     return;
       /* don't attack our own spells */
       if (tmp->owner && tmp->owner == op->owner)
         continue;
       /* Basically, if the object is magical and not counterspell,
        * we will more or less remove the object.  Don't counterspell
        * monsters either.
        */
       if (head->attacktype & AT_MAGIC
           && !(head->attacktype & AT_COUNTERSPELL)
           && !head->flag [FLAG_MONSTER]
   op->failmsg ("You are not standing over an altar!");
   return 0;
 }
 /* animate_weapon -
  * Generalization of staff_to_snake.  Makes a golem out of the caster's weapon.
  * The golem is based on the archetype specified, modified by the caster's level
  * and the attributes of the weapon.  The weapon is inserted in the golem's
  * inventory so that it falls to the ground when the golem dies.
  * This code was very odd - code early on would only let players use the spell,
  * yet the code wass full of player checks.  I've presumed that the code
  * that only let players use it was correct, and removed all the other
  * player checks. MSW 2003-01-06
   /* if no direction specified, pick one */
   if (!dir)
     dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
   m = op->map;
-  x = op->x + freearr_x[dir];
+  x = op->x + DIRX (dir);
-  y = op->y + freearr_y[dir];
+  y = op->y + DIRY (dir);
   /* if there's no place to put the golem, abort */
   if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
       || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
     {
   /* Improve weapon's armour value according to best save vs. physical of its material */
   if (a > 14)
     a = 14;
-  tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
+  tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.f - (float) tmp->resist[ATNR_PHYSICAL]) / (30.f - 2.f * a));
   /* Determine golem's speed */
-  tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
+  tmp->set_speed (min (3.33f, 0.4f + 0.1f * SP_level_range_adjust (caster, spell)));
   if (!spell->race)
     {
       sprintf (buf, "animated %s", &weapon->name);
       tmp->name = buf;
 /* move aura function.  An aura is a part of someone's inventory,
  * which he carries with him, but which acts on the map immediately
  * around him.
  * Aura parameters:
  * duration:  duration counter.
  * attacktype:  aura's attacktype
  * other_arch:  archetype to drop where we attack
  */
 void
 move_aura (object *aura)
 {
   /* auras belong in inventories */
   object *env   = aura->env;
   object *owner = aura->owner;
   /* no matter what we've gotta remove the aura...
    * we'll put it back if its time isn't up.
    */
   aura->remove ();
   /* exit if we're out of gas */
   if (aura->duration-- < 0)
       aura->destroy ();
       return;
     }
   /* we need to jump out of the inventory for a bit
    * in order to hit the map conveniently.
    */
   aura->insert_at (env, aura);
   for (int i = 1; i < 9; i++)
     {

Diff Legend

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

Comparing deliantra/server/server/spell_effect.C (file contents): Revision 1.131 by root, Fri Apr 23 04:32:47 2010 UTC vs. Revision 1.149 by root, Sat Dec 1 20:22:13 2018 UTC

Diff Legend

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.131 by root, Fri Apr 23 04:32:47 2010 UTC vs.
Revision 1.149 by root, Sat Dec 1 20:22:13 2018 UTC