[ViewVC] Diff of: cvs/deliantra/server/server/pets.C

Comparing deliantra/server/server/pets.C (file contents):
Revision 1.50 by root, Thu Jan 1 15:43:35 2009 UTC vs.
Revision 1.67 by root, Sat Apr 23 04:56:56 2011 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,2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 1992 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>
   //  return 0;
   /* See if the pet has an existing enemy. If so, don't start a new one */
   if (tmp = check_enemy (pet, rv))
     {
-      if (tmp == owner && !QUERY_FLAG (pet, FLAG_CONFUSED) && QUERY_FLAG (pet, FLAG_FRIENDLY))
+      if (tmp == owner && !pet->flag [FLAG_CONFUSED] && pet->flag [FLAG_FRIENDLY])
         /* without this check, you can actually get pets with
          * enemy set to owner!
          */
         pet->enemy = 0;
       else
             {
               for (tmp = GET_MAP_OB (nm, x, y); tmp != 0; tmp = tmp->above)
                 {
                   object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
-                  if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) &&
+                  if (tmp2->flag [FLAG_ALIVE] && ((!tmp2->flag [FLAG_FRIENDLY] &&
                                                          (tmp2->type != PLAYER)) ||
                                                         should_arena_attack (pet, owner, tmp2))
-                      && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
+                      && !tmp2->flag [FLAG_UNAGGRESSIVE] && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
                     {
                       if (!can_see_enemy (pet, tmp2))
                         {
                           if (tmp3 != 0)
   /* No threat to owner, check to see if the pet has an attacker */
   if (attacker)
     {
       /* also need to check to make sure it is not freindly */
       /* or otherwise non-hostile, and is an appropriate target */
-      if (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && on_same_map (pet, attacker))
+      if (!attacker->flag [FLAG_FRIENDLY] && on_same_map (pet, attacker))
         {
           pet->enemy = attacker;
           if (check_enemy (pet, rv) != 0)
             return attacker;
             {
               for (tmp = GET_MAP_OB (nm, x, y); tmp != 0; tmp = tmp->above)
                 {
                   object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
-                  if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) &&
+                  if (tmp2->flag [FLAG_ALIVE] && ((!tmp2->flag [FLAG_FRIENDLY] &&
                                                          (tmp2->type != PLAYER)) ||
                                                         should_arena_attack (pet, owner, tmp2))
-                      && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
+                      && !tmp2->flag [FLAG_UNAGGRESSIVE] && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
                     {
                       if (!can_see_enemy (pet, tmp2))
                         {
                           if (tmp3 != 0)
 }
 /*
  * Unfortunately, sometimes, the owner of a pet is in the
  * process of entering a new map when this is called.
- * Thus the map isn't loaded yet, and we have to remove
- * the pet...
  * Interesting enough, we don't use the passed map structure in
  * this function.
  */
 void
-remove_all_pets (maptile *map)
+move_all_pets ()
 {
   objectlink *obl, *next;
   object *owner;
   for (obl = first_friendly_object; obl; obl = next)
     {
       next = obl->next;
       if (obl->ob->type != PLAYER
-          && QUERY_FLAG (obl->ob, FLAG_FRIENDLY)
+          && obl->ob->flag [FLAG_FRIENDLY]
-          && (owner = obl->ob->owner) != 0
+          && (owner = obl->ob->owner)
           && !on_same_map (owner, obl->ob))
         {
           /* follow owner checks map status for us */
           follow_owner (obl->ob, owner);
         }
   /* Check to see if player pulled out */
   if ((owner = ob->owner) == NULL)
     {
       ob->drop_and_destroy ();
-      LOG (llevMonster, "Pet: no owner, leaving.\n");
+      LOG (llevTrace, "Pet: no owner, leaving.\n");
       return;
     }
   /* move monster into the owners map if not in the same map
    * except when the owner is removed.
   if (!on_same_map (ob, owner) && !owner->flag [FLAG_REMOVED])
     {
       follow_owner (ob, owner);
       return;
     }
   /* Calculate Direction */
   if (owner->type == PLAYER && owner->contr->petmode == pet_sad)
     {
       /* in S&D mode, if we have no enemy, run randomly about. */
       for (i = 0; i < 15; i++)
       struct rv_vector rv;
       get_rangevector (ob, ob->owner, &rv, 0);
       dir = rv.direction;
     }
   ob->direction = dir;
   /* move_ob returns 0 if the object couldn't move.  If that is the
    * case, lets do some other work.
    */
-  if (!(move_ob (ob, dir, ob)))
+  if (!(ob->move (dir)))
     {
       object *part;
       /* the failed move_ob above may destroy the pet, so check here */
       if (ob->destroyed ())
           for (ob2 = GET_MAP_OB (m, dx, dy); ob2 != NULL; ob2 = ob2->above)
             {
               object *new_ob;
               new_ob = ob2->head ? ob2->head : ob2;
               if (new_ob == ob)
                 break;
               if (new_ob == ob->owner)
                 return;
               if (new_ob->owner == ob->owner)
                 break;
               /* Hmm.  Did we try to move into an enemy monster?  If so,
                * make it our enemy.
                */
-              if (QUERY_FLAG (new_ob, FLAG_ALIVE) && !QUERY_FLAG (ob, FLAG_UNAGGRESSIVE)
+              if (new_ob->flag [FLAG_ALIVE] && !ob->flag [FLAG_UNAGGRESSIVE]
-                  && !QUERY_FLAG (new_ob, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (new_ob, FLAG_FRIENDLY))
+                  && !new_ob->flag [FLAG_UNAGGRESSIVE] && !new_ob->flag [FLAG_FRIENDLY])
                 {
                   ob->enemy = new_ob;
                   if (new_ob->enemy == NULL)
                     new_ob->enemy = ob;
                 }
             }
         }
       /* Try a different course */
       dir = absdir (dir + 4 - (rndm (5)) - (rndm (5)));
-      (void) move_ob (ob, dir, ob);
+      ob->move (dir);
     }
-  return;
 }
 /****************************************************************************
  *
  * GOLEM SPELL CODE
  * proper for map insertion.
  * at is the archetype, op is the caster of the spell, dir is the
  * direction the monster should be placed in.
  * is_golem is to note that this is a golem spell.
  */
-object *
+static object *
 fix_summon_pet (archetype *at, object *op, int dir, int is_golem)
 {
   object *tmp = NULL, *prev = NULL, *head = NULL;
   for (archetype *atmp = at; atmp; atmp = (archetype *)atmp->more)
     {
-      tmp = arch_to_object (atmp);
+      tmp = atmp->instance ();
       if (atmp == at)
         {
           if (!is_golem)
-            SET_FLAG (tmp, FLAG_MONSTER);
+            tmp->set_flag (FLAG_MONSTER);
           tmp->set_owner (op);
           if (op->type == PLAYER)
             {
               tmp->stats.exp = 0;
               add_friendly_object (tmp);
               if (is_golem)
-                CLEAR_FLAG (tmp, FLAG_MONSTER);
+                tmp->clr_flag (FLAG_MONSTER);
             }
           else
             {
-              if (QUERY_FLAG (op, FLAG_FRIENDLY))
+              if (op->flag [FLAG_FRIENDLY])
                 {
                   object *owner = op->owner;
                   if (owner)
                     {           /* For now, we transfer ownership */
   head->last_eat = 0;
   head->last_grace = 0;
   head->last_sp = 0;
   head->other_arch = NULL;
   head->stats.exp = 0;
-  CLEAR_FLAG (head, FLAG_CHANGING);
+  head->clr_flag (FLAG_CHANGING);
-  CLEAR_FLAG (head, FLAG_STAND_STILL);
+  head->clr_flag (FLAG_STAND_STILL);
-  CLEAR_FLAG (head, FLAG_GENERATOR);
+  head->clr_flag (FLAG_GENERATOR);
-  CLEAR_FLAG (head, FLAG_SPLITTING);
+  head->clr_flag (FLAG_SPLITTING);
   if (head->attacktype & AT_GHOSTHIT)
     head->attacktype = (AT_PHYSICAL | AT_DRAIN);
   return head;
 }
 move_golem (object *op)
 {
   int made_attack = 0;
   object *tmp;
-  if (QUERY_FLAG (op, FLAG_MONSTER))
+  if (op->flag [FLAG_MONSTER])
     return;                     /* Has already been moved */
   if (!op->owner)
     {
       LOG (llevDebug, "Golem without owner destructed.\n");
       return;
     }
   /* Do golem attacks/movement for single & multisq golems.
    * Assuming here that op is the 'head' object. Pass only op to
-   * move_ob (makes recursive calls to other parts)
+   * ->move (makes recursive calls to other parts)
    * move_ob returns 0 if the creature was not able to move.
    */
-  if (move_ob (op, op->direction, op))
+  if (op->move (op->direction, op))
     return;
   if (op->destroyed ())
     return;
       if (mflags & P_OUT_OF_MAP)
         continue;
       for (victim = GET_MAP_OB (m, x, y); victim; victim = victim->above)
-        if (QUERY_FLAG (victim, FLAG_ALIVE))
+        if (victim->flag [FLAG_ALIVE])
           break;
       /* We used to call will_hit_self to make sure we don't
        * hit ourselves, but that didn't work, and I don't really
        * know if that was more efficient anyways than this.
 int
 summon_golem (object *op, object *caster, int dir, object *spob)
 {
   object *tmp, *god = NULL;
   archetype *at;
-  char buf[MAX_BUF];
   /* Because there can be different golem spells, player may want to
    * 'lose' their old golem.
    */
   if (op->type == PLAYER && op->contr->golem)
       op->contr->golem = tmp;
       /* give the player control of the golem */
       set_spell_skill (op, caster, spob, tmp);
     }
-  /* make the speed positive. */
-  tmp->speed = fabs (tmp->speed);
-  /*  This sets the level dependencies on dam and hp for monsters */
+  /* This sets the level dependencies on dam and hp for monsters */
   /* players can't cope with too strong summonings. */
   /* but monsters can.  reserve these for players. */
   if (op->type == PLAYER)
     {
       tmp->stats.hp += spob->duration + SP_level_duration_adjust (caster, spob);
       if (!spob->stats.dam)
         tmp->stats.dam += SP_level_dam_adjust (caster, spob);
       else
         tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
-      tmp->speed += .02 * SP_level_range_adjust (caster, spob);
+      tmp->set_speed (min (1.f, tmp->speed + .02f * SP_level_range_adjust (caster, spob)));
-      tmp->speed = min (tmp->speed, 1.0);
       if (spob->attacktype)
         tmp->attacktype = spob->attacktype;
     }
   tmp->direction = dir;
   /* Holy spell - some additional tailoring */
   if (god)
     {
-      object *tmp2;
-      sprintf (buf, "%s of %s", &spob->name, &god->name);
+      char *buf = format ("%s of %s", &spob->name, &god->name);
       buf[0] = toupper (buf[0]);
-      for (tmp2 = tmp; tmp2; tmp2 = tmp2->more)
+      for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
         tmp2->name = buf;
       tmp->attacktype |= god->attacktype;
       memcpy (tmp->resist, god->resist, sizeof (tmp->resist));
       tmp->race = god->race;
 /* Returns a monster (chosen at random) that this particular player (and his
  * god) find acceptable.  This checks level, races allowed by god, etc
  * to determine what is acceptable.
  * This returns NULL if no match was found.
  */
-object *
+static object *
 choose_cult_monster (object *pl, object *god, int summon_level)
 {
   char buf[MAX_BUF];
   const char *race;
   int racenr, mon_nr, i;
   /* search for an apprplritate monster on this race list */
   mon_nr = 0;
   for (tobl = list->member; tobl; tobl = tobl->next)
     {
       otmp = tobl->ob;
-      if (!otmp || !QUERY_FLAG (otmp, FLAG_MONSTER))
+      if (!otmp || !otmp->flag [FLAG_MONSTER])
         continue;
       if (otmp->level <= summon_level)
         mon_nr++;
     }
   mon_nr = rndm (mon_nr - 1);
   for (tobl = list->member; tobl; tobl = tobl->next)
     {
       otmp = tobl->ob;
-      if (!otmp || !QUERY_FLAG (otmp, FLAG_MONSTER))
+      if (!otmp || !otmp->flag [FLAG_MONSTER])
         continue;
       if (otmp->level <= summon_level && !mon_nr--)
         return otmp;
     }
 }
 int
 summon_object (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)
 {
-  sint16 x, y, nrof = 1, i;
+  int nrof = 1;
   archetype *summon_arch;
   int ndir;
   if (spell_ob->other_arch)
     summon_arch = spell_ob->other_arch;
         }
       summon_arch = lasttr->item;
       nrof        = lasttr->nrof;
     }
-  else if (spell_ob->race && !strcmp (spell_ob->race, "GODCULTMON"))
+  else if (spell_ob->race == shstr_GODCULTMON)
     {
       object *god = find_god (determine_god (op)), *mon, *owner;
       int summon_level, tries;
       if (!god && ((owner = op->owner) != NULL))
     {
       new_draw_info (NDI_UNIQUE, 0, op, "There is no monsters available for summoning.");
       return 0;
     }
-  for (i = 1; i <= nrof; i++)
+  for (int i = 1; i <= nrof; i++)
     {
       object *prev = NULL, *head = NULL, *tmp;
       if (dir)
         {
           dir = absdir (dir + 1);
         }
       else
         ndir = find_free_spot (summon_arch, op->map, op->x, op->y, 1, SIZEOFFREE);
-      if (ndir > 0)
-        {
-          x = freearr_x[ndir];
+      sint16 x = freearr_x [ndir];
-          y = freearr_y[ndir];
+      sint16 y = freearr_y [ndir];
-        }
       if (ndir < 0 || summon_arch->blocked (op->map, op->x + x, op->y + y))
         {
           new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
           if (nrof > 1)
             new_draw_info (NDI_UNIQUE, 0, op, "No more pets for this casting.");
           return nrof > 1;
         }
-      for (archetype *atmp = summon_arch; atmp != NULL; atmp = (archetype *)atmp->more)
+      for (archetype *atmp = summon_arch; atmp; atmp = (archetype *)atmp->more)
         {
-          tmp = arch_to_object (atmp);
+          tmp = atmp->instance ();
           if (atmp == summon_arch)
             {
-              if (QUERY_FLAG (tmp, FLAG_MONSTER))
+              if (tmp->flag [FLAG_MONSTER])
                 {
                   tmp->set_owner (op);
                   set_spell_skill (op, caster, spell_ob, tmp);
                   tmp->enemy = op->enemy;
                   tmp->type = 0;
-                  CLEAR_FLAG (tmp, FLAG_SLEEP);
+                  tmp->clr_flag (FLAG_SLEEP);
-                  if (op->type == PLAYER || QUERY_FLAG (op, FLAG_FRIENDLY))
+                  if (op->type == PLAYER || op->flag [FLAG_FRIENDLY])
                     {
                       /* If this is not set, we make it friendly */
-                      if (!QUERY_FLAG (spell_ob, FLAG_MONSTER))
+                      if (!spell_ob->flag [FLAG_MONSTER])
                         {
                           add_friendly_object (tmp);
                           tmp->stats.exp = 0;
                           if (spell_ob->attack_movement)
                             tmp->set_owner (op->owner);
                         }
                     }
                 }
-              if (tmp->speed > MIN_ACTIVE_SPEED)
+              if (tmp->has_active_speed ())
                 tmp->speed_left = -1;
             }
           if (head == NULL)
             head = tmp;
       if (head && head->randomitems)
         {
           create_treasure (head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0);
           for (object *tmp = head->inv; tmp; tmp = tmp->below)
-            SET_FLAG (tmp, FLAG_DESTROY_ON_DEATH);
+            tmp->set_flag (FLAG_DESTROY_ON_DEATH);
         }
     }                           /* for i < nrof */
   return 1;
 }

Diff Legend

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

Comparing deliantra/server/server/pets.C (file contents): Revision 1.50 by root, Thu Jan 1 15:43:35 2009 UTC vs. Revision 1.67 by root, Sat Apr 23 04:56:56 2011 UTC

Diff Legend

Comparing deliantra/server/server/pets.C (file contents):
Revision 1.50 by root, Thu Jan 1 15:43:35 2009 UTC vs.
Revision 1.67 by root, Sat Apr 23 04:56:56 2011 UTC