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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.108 by root, Tue Jan 3 11:25:37 2012 UTC vs.
Revision 1.115 by root, Sun Jan 29 02:47:06 2017 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 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
       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.
           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
           sint16 dx, dy;
           dx = op->x + freearr_x[i];
           dy = op->y + freearr_y[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 ();
 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 ())
   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 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
 /****************************************************************************
  * 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)
 {
   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
       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.
       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)
         {
   target_x = op->x + freearr_x[absdir (basedir + adjustdir)];
   target_y = op->y + freearr_y[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_y = target_y - freearr_y[basedir];
 }
 /*  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.
   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;
                     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;

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.108 by root, Tue Jan 3 11:25:37 2012 UTC vs. Revision 1.115 by root, Sun Jan 29 02:47:06 2017 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.108 by root, Tue Jan 3 11:25:37 2012 UTC vs.
Revision 1.115 by root, Sun Jan 29 02:47:06 2017 UTC