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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.296 by root, Thu Nov 17 04:59:33 2016 UTC vs.
Revision 1.302 by root, Sun Nov 18 15:19:48 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
  * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
   disconnect ();
   attachable::do_destroy ();
   if (ob)
+    {
+      // potentially fix a bug where ob->contr is non-null while ob->contr->ob is null, causing a segfault.
+      // temporarily backed out patchset 4025 to see if THIS change causes crashes
+      //ob->contr = 0;
-    ob->destroy ();
+      ob->destroy ();
+    }
   ob = observe = viewpoint = 0;
 }
 player::~player ()
 #endif
   return op;
 }
 /* I believe this can safely go to 2, 3 is questionable, 4 will likely
  * result in a monster paths backtracking.  It basically determines how large a
  * detour a monster will take from the direction path when looking
  * for a path to the player.  The values are in the amount of direction
  * the deviation is
  */
 #define DETOUR_AMOUNT	2
             }
           else
             {
               /* direct path is blocked - try taking a side step to
                * either the left or right.
                * Note increase the values in the loop below to be
                * more than -1/1 respectively will mean the monster takes
                * bigger detour.  Have to be careful about these values getting
                * too big (3 or maybe 4 or higher) as the monster may just try
                * stepping back and forth
                */
   for (object *next, *op = pl->inv; op; op = next)
     {
       next = op->below;
       /* Forces get applied per default, unless they have the
        * flag "neutral" set. Sorry but I can't think of a better way
        */
       if (op->type == FORCE && !op->flag [FLAG_NEUTRAL])
         op->set_flag (FLAG_APPLIED);
       /* we never give weapons/armour if these cannot be used
        * by this player due to race restrictions
        */
       if (pl->type == PLAYER)
         {
           if ((!pl->flag [FLAG_USE_ARMOUR]
                &&
       ob->instantiate ();
       ob->stats = ob->contr->orig_stats;
       ob->name = ob->name_pl = name;
       ob->x = x;
       ob->y = y;
-      SET_ANIMATION (ob, 2);    /* So player faces south */
+      ob->set_anim_frame (2); /* So player faces south */
       insert_ob_in_map (ob, ob->map, ob, 0);
       assign (ob->contr->title, ob->arch->object::name);
       ob->add_statbonus ();
     }
   while (!allowed_class (ob));
 }
 /* routine for both players and monsters. We call this when
  * there is a possibility for our action distrubing our hiding
  * place or invisiblity spell. Artefact invisiblity causes
  * "noise" instead. If we arent invisible to begin with, we
  * return 0.
  */
 static int
 action_makes_visible (object *op)
 {
   if (op->invisible && op->flag [FLAG_ALIVE])
   return 0;
 }
 /*
  *  Find an arrow in the inventory and after that
  *  in the right type container (quiver). Pointer to the
  *  found object is returned.
  */
 static object *
 find_arrow (object *op, const char *type)
 {
   y = op->y;
   /* find the first target */
   for (i = 0, found = 0; i < 20; i++)
     {
-      x += freearr_x[dir];
+      x += DIRX (dir);
-      y += freearr_y[dir];
+      y += DIRY (dir);
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       if (mflags & P_OUT_OF_MAP || mflags & P_BLOCKSVIEW)
         {
           tmp = 0;
   return find_better_arrow (op, tmp, type, &i);
 }
 /*
  * Creature fires a bow - op can be monster or player.  Returns
  * 1 if bow was actually fired, 0 otherwise.
  * op is the object firing the bow.
  * part is for multipart creatures - the part firing the bow.
  * dir is the direction of fire.
  * wc_mod is any special modifier to give (used in special player fire modes)
       op->speed_left += speed - op->speed;
     }
 #endif
-  SET_ANIMATION (arrow, arrow->direction);
+  arrow->set_anim_frame (arrow->direction);
   /* update the speed */
   arrow->speed_left = 0;
   arrow->set_speed (max (2.f,
       ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
     }
   else if (op->contr->bowtype == bow_threewide)
     {
       ret  = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
-      ret |= fire_bow (op, op, NULL, dir, -5, op->x + freearr_x[absdir (dir + 2)], op->y + freearr_y[absdir (dir + 2)]);
+      ret |= fire_bow (op, op, NULL, dir, -5, op->x + DIRX (absdir (dir + 2)), op->y + DIRY (absdir (dir + 2)));
-      ret |= fire_bow (op, op, NULL, dir, -5, op->x + freearr_x[absdir (dir - 2)], op->y + freearr_y[absdir (dir - 2)]);
+      ret |= fire_bow (op, op, NULL, dir, -5, op->x + DIRX (absdir (dir - 2)), op->y + DIRY (absdir (dir - 2)));
     }
   else if (op->contr->bowtype == bow_spreadshot)
     {
       ret  = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
       ret |= fire_bow (op, op, NULL, absdir (dir - 1), -5, op->x, op->y);
   for (tmp = container->inv; tmp; tmp = tmp->below)
     {
       if (door->type == DOOR && tmp->type == KEY)
         break;
       /* For sanity, we should really check door type, but other stuff
        * (like containers) can be locked with special keys
        */
       if (tmp->slaying && tmp->type == SPECIAL_KEY && tmp->slaying == door->slaying)
         break;
     }
 /* find_key
  * We try to find a key for the door as passed.  If we find a key
  * and successfully use it, we return the key, otherwise NULL
  * This function merges both normal and locked door, since the logic
  * for both is the same - just the specific key is different.
  * pl is the player,
  * inv is the objects inventory to searched
  * door is the door we are trying to match against.
  * This function can be called recursively to search containers.
  */
 object *
 find_key (object *pl, object *container, object *door)
     {
       --op->speed_left;
       return true;
     }
-  sint16 nx = freearr_x[dir] + op->x;
+  sint16 nx = DIRX (dir) + op->x;
-  sint16 ny = freearr_y[dir] + op->y;
+  sint16 ny = DIRY (dir) + op->y;
   if (out_of_map (op->map, nx, ny))
     return false;
   /* If braced, or can't move to the square, and it is not out of the
                   /* There is a maximum depletion total per level. */
                   if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
                     {
                       lose_this_stat = 0;
                       /* Take loss chance vs keep chance to see if we
                          retain the stat. */
                     }
                   else
                     {
                       if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
     level = -(10 + (2 * ob->map->darklevel ()));
   /* scan through all nearby squares for terrain to hide in */
   for (i = 0, x = ob->x, y = ob->y;
        i <= SIZEOFFREE1;
-       i++, x = ob->x + freearr_x[i], y = ob->y + freearr_y[i])
+       i++, x = ob->x + DIRX (i), y = ob->y + DIRY (i))
     {
       mflag = get_map_flags (ob->map, NULL, x, y, NULL, NULL);
       if (mflag & P_OUT_OF_MAP)
         continue;
     friendly = who->flag [FLAG_FRIENDLY];
   /* search adjacent squares */
   for (i = 1; i < 9; i++)
     {
-      x = who->x + freearr_x[i];
+      x = who->x + DIRX (i);
-      y = who->y + freearr_y[i];
+      y = who->y + DIRY (i);
       m = who->map;
       mflags = get_map_flags (m, &m, x, y, &x, &y);
       /* space must be blocked if there is a monster.  If not
        * blocked, don't need to check this space.
        */
   get_rangevector (pl, op, &rv, 0x1);
   /* starting with the 'head' part, lets loop
    * through the object and find if it has any
    * part that is in the los array but isn't on
    * a blocked los square.
    * we use the archetype to figure out offsets.
    */
   while (op)
     {

Diff Legend

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

Comparing deliantra/server/server/player.C (file contents): Revision 1.296 by root, Thu Nov 17 04:59:33 2016 UTC vs. Revision 1.302 by root, Sun Nov 18 15:19:48 2018 UTC

Diff Legend

Comparing deliantra/server/server/player.C (file contents):
Revision 1.296 by root, Thu Nov 17 04:59:33 2016 UTC vs.
Revision 1.302 by root, Sun Nov 18 15:19:48 2018 UTC