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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.80 by root, Mon Sep 29 08:25:02 2008 UTC vs.
Revision 1.97 by root, Sat Jun 27 03:51:05 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
  * it under the terms of the GNU General Public License as published by
 /* This returns a random spell from 'ob'.  If skill is set, then
  * the spell must be of this skill, it can be NULL in which case all
  * matching spells are used.
  */
 object *
-find_random_spell_in_ob (object *ob, const char *skill)
+find_random_spell_in_ob (object *ob, shstr_cmp skill)
 {
   int k = 0, s;
   for (object *tmp = ob->inv; tmp; tmp = tmp->below)
     if (tmp->type == SPELL && (!skill || tmp->skill == skill))
   /* No spells, no need to progess further */
   if (!k)
     return NULL;
-  s = RANDOM () % k;
+  s = rndm (k);
   for (object *tmp = ob->inv; tmp; tmp = tmp->below)
     if (tmp->type == SPELL && (!skill || tmp->skill == skill))
       if (!s)
         return tmp;
   // repell has no such quarrels
   return (caster->path_attuned  & spell->path_attuned ? min (level, +ATTUNE_REPELL) : 0)
        + (caster->path_repelled & spell->path_attuned ?             -ATTUNE_REPELL  : 0);
 }
-/*
- * This function takes a caster and spell and presents the
- * effective level the caster needs to be to cast the spell.
- * basically, it just adjusts the spell->level with attuned/repelled
- * spellpaths. Was called path_level_mod.
- *
- * caster is person casting the spell.
- * spell is the spell object.
- * Returns modified level.
- */
-int
-min_casting_level (object *caster, object *spell)
-{
-  if (caster->path_denied & spell->path_attuned)
-    return 500;
-  return max (1, spell->level + attuned_bonus (caster, spell, spell->level));
-}
 /* This function returns the effective level the spell
  * is being cast at.
  */
 int
 casting_level (object *caster, object *spell)
     level = lerp (level, (int)spell->level, 100, 1, 100);
   /* Always make this at least 1.  If this is zero, we get divide by zero
    * errors in various places.
    */
-  return max (level, 1);
+  return clamp (level, 1, settings.max_level);
 }
 /* The following function scales the spellpoint cost of
  * a spell by it's increased effectiveness.  Some of the
  * lower level spells become incredibly vicious at high
 /* Checks to see if player knows the spell.  If the name is the same
  * as an existing spell, we presume they know it.
  * returns 1 if they know the spell, 0 if they don't.
  */
 object *
-check_spell_known (object *op, const char *name)
+check_spell_known (object *op, shstr_cmp name)
 {
   object *spop;
-  shstr_cmp name_ (name);
   for (spop = op->inv; spop; spop = spop->below)
     if (spop->type == SPELL && spop->name == name)
       return spop;
  * exact match, we also return NULL.
  */
 object *
 lookup_spell_by_name (object *op, const char *spname)
 {
-  object *spob1 = NULL, *spob2 = NULL, *spob;
+  object *spob1 = 0, *spob2 = 0;
   int nummatch = 0;
-  if (spname == NULL)
+  if (!spname)
-    return NULL;
+    return 0;
   /* Try to find the spell.  We store the results in spob1
    * and spob2 - spob1 is only taking the length of
    * the past spname, spob2 uses the length of the spell name.
    */
-  for (spob = op->inv; spob; spob = spob->below)
+  for (object *spob = op->inv; spob; spob = spob->below)
     {
       if (spob->type == SPELL)
         {
+          // TODO: WTF?
           if (!strncmp (spob->name, spname, strlen (spname)))
             {
               nummatch++;
               spob1 = spob;
             }
                * fall into this category).  It shouldn't be hard to
                * make sure spell names don't overlap in that fashion.
                */
               if (spob2)
                 LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
               spob2 = spob;
             }
         }
     }
   /* if we have best match, return it.  Otherwise, if we have one match
    * on the loser match, return that, otehrwise null
    */
   if (spob2)
     return spob2;
   if (spob1 && nummatch == 1)
     return spob1;
   return NULL;
 }
 /* reflwall - decides weither the (spell-)object sp_op will
  * be reflected from the given mapsquare. Returns 1 if true.
                    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?
        */
  * 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;
     {
       SET_ANIMATION (op, ATTACKS[i].face);
     }
 }
 /* prayer_failure: This is called when a player fails
  * 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
 prayer_failure (object *op, int failure, int power)
 {
   const char *godname;
   object *tmp;
         }
     }
 }
 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)
     }
   spell = arch_to_object (spell_ob->other_arch);
   /* Always cast spell on caster */
-  success = cast_spell (op, caster, dir, spell, stringarg);
+  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, caster)))
-      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, cast_level = 0;
+  int success = 0;
   object *skill = NULL;
   if (!spell_ob)
     {
       LOG (llevError, "cast_spell: null spell object passed\n");
           int caster_level = skill->level;
           if (op->path_attuned & spell_ob->path_attuned)
             {
-              caster_level += min (cast_level * 2, ATTUNE_REPELL);
+              caster_level += min (caster_level, ATTUNE_REPELL);
               msg = " (attuned)";
             }
           if (op->path_repelled & spell_ob->path_attuned)
             {
-              caster_level = ATTUNE_REPELL; // negative is ok
+              caster_level -= ATTUNE_REPELL; // negative is ok
               msg = " (repelled)";
             }
           if (spell_ob->level > caster_level)
             {
         }
       /* If the caster is the wiz, they don't ever fail, and don't have
        * to have sufficient grace/mana.
        */
-      if (!QUERY_FLAG (op, FLAG_WIZ))
+      if (!QUERY_FLAG (op, FLAG_WIZCAST))
         {
           if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
               SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
             {
               op->failmsg ("You don't have enough mana!");
         }
       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);
     }
       case SP_MAGIC_MISSILE:
         if (QUERY_FLAG (victim, FLAG_ALIVE))
           {
             hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
-            if (!spell->destroyed ())
-              spell->destroy ();
+            spell->destroy ();
           }
         break;
       case SP_MOVING_BALL:
         if (QUERY_FLAG (victim, FLAG_ALIVE))
           hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
         else if (victim->materialname)
           save_throw_object (victim, spell->attacktype, spell);
-        break;
-    }
-}
+        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.80 by root, Mon Sep 29 08:25:02 2008 UTC vs. Revision 1.97 by root, Sat Jun 27 03:51:05 2009 UTC

Diff Legend

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.80 by root, Mon Sep 29 08:25:02 2008 UTC vs.
Revision 1.97 by root, Sat Jun 27 03:51:05 2009 UTC