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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.91 by root, Sun Jan 11 00:31:52 2009 UTC vs.
Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992,2007 Frank Tore Johansen
  *
- * Deliantra is free software: you can redistribute it and/or modify
+ * Deliantra is free software: you can redistribute it and/or modify it under
- * it under the terms of the GNU General Public License as published by
+ * the terms of the Affero GNU General Public License as published by the
- * the Free Software Foundation, either version 3 of the License, or
+ * Free Software Foundation, either version 3 of the License, or (at your
- * (at your option) any later version.
+ * 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 GNU General Public License
+ * You should have received a copy of the Affero GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * 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>
                    dir ? 0 : INS_BELOW_ORIGINATOR);
   return dir;
 }
+static bool
+mergable_owner (object *o1, object *o2)
+{
+  if (o1 == o2)
+    return 1;
+  if (!o1 || !o2)
+    return 0;
+  if (o1->flag [FLAG_FRIENDLY] != o1->flag [FLAG_FRIENDLY])
+    return 0;
+  if (o1->is_player () || o2->is_player ())
+    return 0;
+  return 1;
+}
 /* Returns true if it is ok to put spell *op on the space/may provided.
  * immune_stop is basically the attacktype of the spell (why
  * passed as a different value, not sure of).  If immune_stop
  * has the AT_MAGIC bit set, and there is a counterwall
  * on the space, the object doesn't get placed.  if immune stop
  * does not have AT_MAGIC, then counterwalls do not effect the spell.
- *
  */
 int
 ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
 {
   if (!xy_normalise (m, x, y))
   mapspace &ms = m->at (x, y);
   ms.update ();
   if (OB_TYPE_MOVE_BLOCK (op, ms.move_block))
     return 0;
+  int max_effects = 5; // max. number of similar spells per mapspace
   for (object *tmp = ms.bot; tmp; tmp = tmp->above)
     {
       /* If there is a counterspell on the space, and this
        * object is using magic, don't progress.  I believe we could
                                               // (and those shouldn't go away from
                                               //  sanctuary) see also: permanent lava
           && (immune_stop & AT_MAGIC))
         return 0;
-      /* This is to prevent 'out of control' spells.  Basically, this
-       * limits one spell effect per space per spell.  This is definately
-       * needed for performance reasons, and just for playability I believe.
-       * there are no such things as multispaced spells right now, so
-       * we don't need to worry about the head.
-       */
-      if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) && (tmp->subtype == op->subtype))
-        return 0;
-      /*
-       * Combine similar spell effects into one spell effect. Needed for
-       * performance reasons with meteor swarm and the like, but also for
-       * playability reasons.
-       */
-      if (tmp->arch == op->arch /* no harm if not comparing by name here */
-          && tmp->type == op->type
+      if (tmp->type == op->type)
-          && tmp->subtype == op->subtype
-          && tmp->owner == op->owner
-          && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
         {
-          tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
+          if (tmp->subtype == op->subtype
-          tmp->range = MAX (tmp->range, op->range);
+              && tmp->arch == op->arch /* no harm if not comparing by name here */)
-          tmp->duration = MAX (tmp->duration, op->duration);
+            {
+              /* This is to prevent 'out of control' spells.  Basically, this
+               * limits one spell effect per space per spell.  This is definately
+               * needed for performance reasons, and just for playability I believe.
+               * there are no such things as multispaced spells right now, so
+               * we don't need to worry about the head.
+               */
+              if (tmp->stats.maxhp == op->stats.maxhp)
+                return 0;
+              /*
+               * Combine similar spell effects into one spell effect. Needed for
+               * performance reasons with meteor swarm and the like, but also for
+               * playability reasons.
+               */
+              if (((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
+                if (mergable_owner (tmp, op))
+                  {
+                    // if same owner, then combine, but reduce advantage of multiple spells
+                    max_it (tmp->stats.dam, op->stats.dam);
+                    max_it (tmp->range    , op->range);
+                    max_it (tmp->duration , op->duration);
+                    return 0;
+                  }
+            }
+          // if there are too many spell effects on this space,
+          // then don't allow more of them, for performance reasons.
+          if (tmp->type == SPELL_EFFECT
+              && !--max_effects)
-          return 0;
+            return 0;
         }
       /* Perhaps we should also put checks in for no magic and unholy
        * ground to prevent it from moving along?
        */
 /* put_a_monster: puts a monster named monstername near by
  * op.  This creates the treasures for the monsters, and
  * also deals with multipart monsters properly.
  */
-void
+static void
 put_a_monster (object *op, const char *monstername)
 {
   object *tmp, *head = NULL, *prev = NULL;
   archetype *at;
   int dir;
  * Note that this is not used by any spells (summon evil monsters
  * use to call this, but best I can tell, that spell/ability was
  * never used.  This is however used by various failures on the
  * players part (alchemy, reincarnation, etc)
  */
 int
 summon_hostile_monsters (object *op, int n, const char *monstername)
 {
   int i;
  * at casting a prayer.
  * op is the player.
  * failure is basically how much grace they had.
  * power is how much grace the spell would normally take to cast.
  */
-void
+static void
 prayer_failure (object *op, int failure, int power)
 {
   const char *godname;
   object *tmp;
           tmp->insert_at (op);
         }
     }
 }
-int
+static int
-cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
+cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *spellparam)
 {
-  int success;
-  object *spell;
   if (!spell_ob->other_arch)
     {
       LOG (llevError, "cast_party_spell: empty other arch\n");
       return 0;
     }
-  spell = arch_to_object (spell_ob->other_arch);
+  object *spell = arch_to_object (spell_ob->other_arch);
   /* Always cast spell on caster */
-  success = cast_spell (op, caster, dir, spell, stringarg);
+  int success = cast_spell (op, caster, dir, spell, spellparam);
-  if (caster->contr->party == NULL)
+  if (!op->contr || !op->contr->party)
     {
       spell->remove ();
       return success;
     }
   for_all_players (pl)
-    if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
+    if ((pl->ob->contr->party == op->contr->party)
+        && on_same_map (pl->ob, op)
+        && pl->ob != op)
-      cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
+      cast_spell (pl->ob, caster, pl->ob->facing, spell, spellparam);
   spell->remove ();
   return success;
 }
  *    same as op.
  * dir is the direction to cast in.  Note in some cases, if the spell
  *    is self only, dir really doesn't make a difference.
  * spell_ob is the spell object that is being cast.  From that,
  *    we can determine what to do.
- * stringarg is any options that are being used.  It can be NULL.  Almost
+ * spellparam is any options that are being used.  It can be NULL.  Almost
  *    certainly, only players will set it.  It is basically used as optional
  *    parameters to a spell (eg, item to create, information for marking runes,
  *    etc.
  * returns 1 on successful cast, or 0 on error.  These values should really
  * be swapped, so that 0 is successful, and non zero is failure, with a code
  * if it is a player casting the spell (op->type == PLAYER, op == caster),
  * this function will decrease the mana/grace appropriately.  For other
  * objects, the caller should do what it considers appropriate.
  */
 int
-cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
+cast_spell (object *op, object *caster, int dir, object *spell_ob, char *spellparam)
 {
   const char *godname;
   int success = 0;
   object *skill = NULL;
         }
       op->change_skill (skill);      /* needed for proper exp credit */
     }
-  if (INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
+  if (INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (spellparam)))
     return RESULT_INT (0);
   switch (spell_ob->subtype)
     {
       /* The order of case statements is same as the order they show up
-       * in in spells.h.
+       * in spells.h.
        */
       case SP_RAISE_DEAD:
-        success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
+        success = cast_raise_dead_spell (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_RUNE:
-        success = write_rune (op, caster, spell_ob, dir, stringarg);
+        success = write_rune (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_MAKE_MARK:
-        success = write_mark (op, spell_ob, stringarg);
+        success = write_mark (op, spell_ob, spellparam);
         break;
       case SP_BOLT:
         success = fire_bolt (op, caster, dir, spell_ob, skill);
         break;
       case SP_DIMENSION_DOOR:
         /* dimension door needs the actual caster, because that is what is
          * moved.
          */
-        success = dimension_door (op, caster, spell_ob, dir);
+        success = dimension_door (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_MAGIC_MAPPING:
         if (op->type == PLAYER)
           {
       case SP_HEALING:
         success = cast_heal (op, caster, spell_ob, dir);
         break;
       case SP_CREATE_FOOD:
-        success = cast_create_food (op, caster, spell_ob, dir, stringarg);
+        success = cast_create_food (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_EARTH_TO_DUST:
         success = cast_earth_to_dust (op, caster, spell_ob);
         break;
       case SP_CURSE:
         success = cast_curse (op, caster, spell_ob, dir);
         break;
       case SP_SUMMON_MONSTER:
-        success = summon_object (op, caster, spell_ob, dir, stringarg);
+        success = summon_object (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_CHARGING:
         success = recharge (op, caster, spell_ob);
         break;
         /* in rune.c */
         success = dispel_rune (op, caster, spell_ob, skill, dir);
         break;
       case SP_CREATE_MISSILE:
-        success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
+        success = cast_create_missile (op, caster, spell_ob, dir, spellparam);
         break;
       case SP_CONSECRATE:
         success = cast_consecrate (op, caster, spell_ob);
         break;
       case SP_AURA:
         success = create_aura (op, caster, spell_ob);
         break;
       case SP_PARTY_SPELL:
-        success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
+        success = cast_party_spell (op, caster, dir, spell_ob, spellparam);
         break;
       default:
         LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
     }
 }
 /* this checks to see if something special should happen if
  * something runs into the object.
  */
-void
+static void
 check_spell_effect (object *op)
 {
   switch (op->subtype)
     {
       case SP_BOLT:
         break;
     }
 }
+/**
+ * This function will let a fireball explode at the position of
+ * the victim with a specific maximum level.
+ */
+void
+create_exploding_ball_at (object *victim, int level)
+{
+  object *ball = get_archetype (EXPLODING_FIREBALL);
+  ball->dam_modifier = random_roll (1, level, victim, PREFER_LOW) / 5 + 1;
+  ball->stats.maxhp  = random_roll (1, level, victim, PREFER_LOW) / 10 + 2;
+  ball->insert_at (victim);
+}

Diff Legend

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

Comparing deliantra/server/server/spell_util.C (file contents): Revision 1.91 by root, Sun Jan 11 00:31:52 2009 UTC vs. Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC

Diff Legend

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.91 by root, Sun Jan 11 00:31:52 2009 UTC vs.
Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC