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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.101 by root, Sat Apr 10 05:12:57 2010 UTC vs.
Revision 1.109 by root, Wed Jan 18 19:12:22 2012 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 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
   for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
       int num_sections = 1;
       /* don't move DM */
-      if (QUERY_FLAG (tmp, FLAG_WIZ))
+      if (tmp->flag [FLAG_WIZ])
         return;
       /* don't move parts of objects */
       if (tmp->head)
         continue;
       /* don't move floors or immobile objects */
-      if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
+      if (tmp->flag [FLAG_IS_FLOOR] || (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
         continue;
       /* count the object's sections */
       for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
         num_sections++;
        * on the space.  So only call reflwall if we think the data it returns
        * will be useful.
        */
       if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
         {
-          if (!QUERY_FLAG (op, FLAG_REFLECTING))
+          if (!op->flag [FLAG_REFLECTING])
             return;
           /* Since walls don't run diagonal, if the bolt is in
            * one of 4 main directions, it just reflects back in the
            * opposite direction.  However, if the bolt is travelling
   tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
   tmp->stats.Dex = spob->stats.Dex;
   tmp->stats.Con = spob->stats.Con;
   tmp->direction = dir;
-  if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+  if (tmp->flag [FLAG_IS_TURNABLE])
     SET_ANIMATION (tmp, dir);
   tmp->set_owner (op);
   set_spell_skill (op, caster, spob, tmp);
   tmp->map = newmap;
   if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
     {
-      if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
+      if (!tmp->flag [FLAG_REFLECTING])
         {
           tmp->drop_and_destroy ();
           return 0;
         }
   if (!(mflags & P_IS_ALIVE))
     return;
   for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
     {
-      if (QUERY_FLAG (tmp, FLAG_ALIVE))
+      if (tmp->flag [FLAG_ALIVE])
         {
           dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
           // TODO: can't understand the following if's
           if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
             {
-              if (!QUERY_FLAG (op, FLAG_REMOVED))
+              if (!op->flag [FLAG_REMOVED])
                 {
                   op->destroy ();
                   return;
                 }
             }
   tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
   tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
   tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
   tmp->direction = dir;
-  if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+  if (tmp->flag [FLAG_IS_TURNABLE])
     SET_ANIMATION (tmp, dir);
   tmp->set_owner (op);
   set_spell_skill (op, caster, spob, tmp);
       return 0;
     }
   if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
     {
-      if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
+      if (!tmp->flag [FLAG_REFLECTING])
         {
           tmp->destroy ();
           return 0;
         }
       op->set_speed (0);
       return;
     }
   /* lava saves it's life, but not yours  :) */
-  if (QUERY_FLAG (op, FLAG_LIFESAVE))
+  if (op->flag [FLAG_LIFESAVE])
     {
       hit_map (op, 0, op->attacktype, 0);
       return;
     }
   MoveType movetype;
   if (!spell->other_arch)
     return 0;
-  if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)
+  if (op->type == PLAYER && op->flag [FLAG_UNDEAD] && op->attacktype & AT_TURN_UNDEAD)
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");
+      op->failmsg ("Your undead nature prevents you from turning undead!");
       return 0;
     }
   if (!dir)
     {
           tmp->attacktype = op->attacktype;
           tmp->set_owner (op);
           if (op->skill && op->skill != tmp->skill)
             tmp->skill = op->skill;
-          if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
+          if (tmp->flag [FLAG_IS_TURNABLE])
             SET_ANIMATION (tmp, i);
           op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
           move_bullet (tmp);
         }
   // to fix create bomb traps in doors, which cast with dir=0).
   if (dir)
     {
       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.");
+          op->failmsg ("There is something in the way.");
           return 0;
         }
     }
   tmp = spell->other_arch->instance ();
       if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
         return NULL;
       if (mflags & P_IS_ALIVE)
         for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
-          if (QUERY_FLAG (target, FLAG_MONSTER))
+          if (target->flag [FLAG_MONSTER])
             return target;
     }
   return NULL;
 }
       || target->flag [FLAG_REFL_SPELL]
       || (!god && spell->stats.grace)
       || (god && target->title == god->name)
       || (god && target->race.contains (god->race)))
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");
+      op->failmsg ("Your request is unheeded.");
       return 0;
     }
   if (spell->other_arch)
     effect = spell->other_arch->instance ();
     {
       if (tailor_god_spell (effect, op))
         new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
       else
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");
+          op->failmsg ("Your request is ignored.");
           return 0;
         }
     }
   /* size of the area of destruction */
   if (effect->attacktype & AT_DEATH)
     {
       effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
       /* casting death spells at undead isn't a good thing */
-      if (QUERY_FLAG (target, FLAG_UNDEAD))
+      if (target->flag [FLAG_UNDEAD])
         {
           if (random_roll (0, 2, op, PREFER_LOW))
             {
               new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
               effect->x = op->x;
 {
   /* some things are unaffected... */
   if (op->path_denied & PATH_LIGHT)
     return 0;
-  object *tmp = get_archetype (FORCE_NAME);
+  object *tmp = archetype::get (FORCE_NAME);
-  tmp->speed = 0.01;
+  tmp->set_speed (0.01);
   tmp->stats.food = time;
-  SET_FLAG (tmp, FLAG_IS_USED_UP);
+  tmp->set_flag (FLAG_IS_USED_UP);
   tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
   tmp = insert_ob_in_ob (tmp, op);
   if (tmp->glow_radius > op->glow_radius)
     op->set_glow_radius (tmp->glow_radius);
   object *tmp, *force;
   tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
   if (!tmp)
     {
-      new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
+      op->failmsg ("There is no one in that direction to curse.");
       return 0;
     }
   tmp = tmp->head_ ();
         }
     }
   if (!force)
     {
-      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
       return 1;
     }
   force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
-  force->speed = 1.f;
   force->speed_left = -1.f;
-  SET_FLAG (force, FLAG_APPLIED);
+  force->set_speed (1.f);
+  force->set_flag (FLAG_APPLIED);
   if (god)
     {
       if (spell_ob->last_grace)
         force->path_repelled = god->path_repelled;
   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
       /* Make sure the race is OK.  Likewise, only effect undead if spell specifically allows it */
       if (race && head->race && !strstr (race, head->race))
         continue;
-      if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
+      if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
         continue;
       /* Now do a bunch of stuff related to saving throws */
       best_at = -1;
       if (spell->attacktype)
       /* Done with saving throw.  Now start affecting the monster */
       done_one = 0;
       /* aggravation */
-      if (QUERY_FLAG (spell, FLAG_MONSTER))
+      if (spell->flag [FLAG_MONSTER])
         {
-          CLEAR_FLAG (head, FLAG_SLEEP);
+          head->clr_flag (FLAG_SLEEP);
           remove_friendly_object (head);
           done_one = 1;
           head->enemy = op;
         }
       /* calm monsters */
-      if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
+      if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
         {
-          SET_FLAG (head, FLAG_UNAGGRESSIVE);
+          head->set_flag (FLAG_UNAGGRESSIVE);
           head->enemy = NULL;
           done_one = 1;
         }
       /* berserk monsters */
-      if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
+      if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
         {
-          SET_FLAG (head, FLAG_BERSERK);
+          head->set_flag (FLAG_BERSERK);
           done_one = 1;
         }
       /* charm */
-      if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
+      if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
         {
           INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
           /* 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->clr_flag (FLAG_GENERATOR);
           head->set_owner (op);
           set_spell_skill (op, caster, spell, head);
           add_friendly_object (head);
           head->attack_movement = PETMOVE;
           done_one = 1;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP)
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
+          op->failmsg ("Nothing is there.");
           return 0;
         }
       if (mflags & P_IS_ALIVE && spell->attacktype)
         {
           for (target = GET_MAP_OB (m, x, y); target; target = target->above)
-            if (QUERY_FLAG (target, FLAG_MONSTER))
+            if (target->flag [FLAG_MONSTER])
               {
                 /* oky doky. got a target monster. Lets make a blinding attack */
                 if (target->head)
                   target = target->head;
         }
       /* no live target, perhaps a wall is in the way? */
       if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
         {
-          new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
+          op->failmsg ("Something is in the way.");
           return 0;
         }
     }
   /* ok, looks groovy to just insert a new light on the map */
       /* Only bother looking on this space if there is something living here */
       if (mflags & P_IS_ALIVE)
         {
           /* search this square for a victim */
           for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
-            if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
+            if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
               {                 /* found a victim */
                 object *disease = spell->other_arch->instance ();
                 disease->set_owner (op);
                 set_spell_skill (op, caster, spell, disease);
                 if (infect_object (walk, disease, 1))
                   {
                     op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
                     disease->destroy ();      /* don't need this one anymore */
-                    walk->map->insert (get_archetype (shstr_detect_magic), x, y, op);
+                    walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
                     return 1;
                   }
                 disease->destroy ();
               }

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.101 by root, Sat Apr 10 05:12:57 2010 UTC vs. Revision 1.109 by root, Wed Jan 18 19:12:22 2012 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.101 by root, Sat Apr 10 05:12:57 2010 UTC vs.
Revision 1.109 by root, Wed Jan 18 19:12:22 2012 UTC