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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.49 by root, Thu Nov 8 19:43:28 2007 UTC vs.
Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002-2003,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 function checks to see if a spell pushes objects as well
  * as flies over and damages them (only used for cones for now)
  * but moved here so it could be applied to bolts too
  * op is the spell object.
  */
 void
 check_spell_knockback (object *op)
 {
   object *tmp, *tmp2;           /* object on the map */
   int weight_move;
  *
  * BOLT CODE
  *
  ***************************************************************************/
-/* Causes op to fork.  op is the original bolt, tmp
+/* Causes op to fork. op is the original bolt, tmp
  * is the first piece of the fork.
  */
 void
 forklightning (object *op, object *tmp)
 {
   int new_dir = 1;              /* direction or -1 for left, +1 for right 0 if no new bolt */
   int t_dir;                    /* stores temporary dir calculation */
       return;
     }
   if (op->env)
     {
-      object *env = object_get_env_recursive (op);
+      object *env = op->outer_env ();
-      if (env->map == NULL || out_of_map (env->map, env->x, env->y))
+      if (!env->map || out_of_map (env->map, env->x, env->y))
         {
           LOG (llevError, "BUG: explode_bullet(): env out of map\n");
           op->destroy ();
           return;
         }
   int mflags;
   if (!spob->other_arch)
     return 0;
-  tmp = arch_to_object (spob->other_arch);
+  tmp = spob->other_arch->instance ();
-  if (tmp == NULL)
+  if (!tmp)
     return 0;
-  /*  peterm:  level dependency for bolts  */
+  /*  peterm: level dependency for bolts  */
   tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
   tmp->attacktype = spob->attacktype;
   if (spob->slaying)
     tmp->slaying = spob->slaying;
     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 + freearr_x[dir];
-  tmp->y = op->y + freearr_y[dir];
+  tmp->y   = op->y + freearr_y[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)
  * op is the original bomb object.
  */
 void
 animate_bomb (object *op)
 {
-  int i;
-  object *env, *tmp;
   if (op->state != NUM_ANIMATIONS (op) - 1)
     return;
-  env = object_get_env_recursive (op);
+  object *env = op->outer_env ();
   if (op->env)
     {
       if (env->map == NULL)
         return;
-      if (env->type == PLAYER)
-        esrv_del_item (env->contr, op->count);
       if (!(op = op->insert_at (env, op)))
         return;
     }
    * but using the cast_bullet isn't really feasible,
    * so just set up the appropriate values.
    */
   if (archetype *at = archetype::find (SPLINT))
     {
-      for (i = 1; i < 9; i++)
+      for (int i = 1; i < 9; i++)
         {
           if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
             continue;
-          tmp = arch_to_object (at);
+          object *tmp = arch_to_object (at);
           tmp->direction = i;
           tmp->range = op->range;
           tmp->stats.dam = op->stats.dam;
           tmp->duration = op->duration;
           tmp->attacktype = op->attacktype;
 }
 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];
   maptile *m;
   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.");
       return 0;
     }
   tmp = arch_to_object (spell->other_arch);
   /*  level dependencies for bomb  */
   tmp->range = spell->range + SP_level_range_adjust (caster, spell);
   tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
           }
         /* charm */
         if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
           {
+            INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
-            /* Prevent uncontolled outbreaks of self replicating monsters.
+            /* 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->set_owner (op);
             set_spell_skill (op, caster, spell, head);
       op->direction = i;
     }
 }
-/* move_swarm_spell:  peterm
+/* 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
+ * 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
+ * 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
   static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
   static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
   sint16 target_x, target_y, origin_x, origin_y;
   int adjustdir;
   maptile *m;
 #endif
-  int basedir;
-  object *owner;
+  object *owner = op->env;
-  owner = op->owner;
+  if (!op->duration || !owner->is_on_map ())
-  if (op->duration == 0 || owner == NULL)
     {
       op->destroy ();
       return;
     }
   op->duration--;
-  basedir = op->direction;
+  int basedir = op->direction;
-  if (basedir == 0)
+  if (!basedir)
-    {
-      /* spray in all directions! 8) */
+    /* spray in all directions! 8) */
-      basedir = rndm (1, 8);
+    basedir = (op->facing += op->state) % 8 + 1;
-    }
 #if 0
   // this is bogus: it causes wrong places to be checked below
   // (a wall 2 cells away will block the effect...) and
   // doesn't work for SP_BULLET anyhow, so again tests the wrong
     {
       /* Bullet spells have a bunch more customization that needs to be done */
       if (op->spell->subtype == SP_BULLET)
         fire_bullet (owner, op, basedir, op->spell);
       else if (op->spell->subtype == SP_MAGIC_MISSILE)
-        fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);
+        fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
     }
 }
 /*  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.
  *  caster: the caster (owner, wand, rod, scroll)
  *  dir: the direction everything will be fired in
  *  spell - the spell that is this spell.
  *  n:  the number to be fired.
  */
 int
 fire_swarm (object *op, object *caster, object *spell, int dir)
 {
-  object *tmp;
-  int i;
   if (!spell->other_arch)
     return 0;
-  tmp = get_archetype (SWARM_SPELL);
+  object *tmp = archetype::get (SWARM_SPELL);
-  tmp->set_owner (op);          /* needed so that if swarm elements kill, caster gets xp. */
   set_spell_skill (op, caster, spell, tmp);
-  tmp->level = caster_level (caster, spell);    /*needed later, to get level dep. right. */
+  tmp->level      = caster_level (caster, spell);    /* needed later, to get level dep. right. */
-  tmp->spell = arch_to_object (spell->other_arch);
+  tmp->spell      = spell->other_arch->instance ();
   tmp->attacktype = tmp->spell->attacktype;
   if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
     if (!tailor_god_spell (tmp, op))
       return 1;
   tmp->duration = SP_level_duration_adjust (caster, spell);
-  for (i = 0; i < spell->duration; i++)
+  for (int i = 0; i < spell->duration; i++)
     tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
   tmp->direction = dir;
   tmp->invisible = 1;
+  tmp->facing    = rndm (1, 8); // initial firing direction
+  tmp->state     = rndm (4) * 2 + 1; // direction increment
-  tmp->insert_at (op, op);
+  op->insert (tmp);
   return 1;
 }
 /* See the spells documentation file for why this is its own
  * function.
  */
 int

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.49 by root, Thu Nov 8 19:43:28 2007 UTC vs. Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.49 by root, Thu Nov 8 19:43:28 2007 UTC vs.
Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC