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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.291 by root, Mon Nov 12 03:14:33 2012 UTC vs.
Revision 1.301 by root, Sat Nov 17 23:40:04 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 Marc Alexander Lehmann / Robin Redeker / 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
  * the terms of the Affero GNU General Public License as published by the
   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]
                &&
    */
   if (*first_map_ext_path)
     ob->player_goto (format ("%s/%s", &first_map_ext_path, &ob->arch->archname), ob->x, ob->y);
   else
     LOG (llevDebug, "first_map_ext_path not set\n");
+}
+/*
+ * Returns true if the given player is a legal class.
+ * The function to add and remove class-bonuses to the stats doesn't
+ * check if the stat becomes negative, thus this function
+ * merely checks that all stats are 1 or more, and returns
+ * false otherwise.
+ */
+static int
+allowed_class (const object *op)
+{
+  return op->stats.Dex > 0
+      && op->stats.Str > 0
+      && op->stats.Con > 0
+      && op->stats.Int > 0
+      && op->stats.Wis > 0
+      && op->stats.Pow > 0
+      && op->stats.Cha > 0;
 }
 void
 player::chargen_race_next ()
 {
 }
 /* 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)
   SET_ANIMATION (arrow, arrow->direction);
   /* update the speed */
   arrow->speed_left = 0;
   arrow->set_speed (max (2.f,
     ((bow->flag [FLAG_NO_STRENGTH] ? 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.f
     + bow->stats.dam / 7.f
   ));
   int wc = op->stats.wc + wc_mod - arrow->magic - arrow->stats.wc;
   arrow->stats.dam = clamp (arrow->stats.dam + op->stats.dam + arrow->magic, MIN_DAM, MAX_DAM);
   arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC);
   arrow->move_type = MOVE_FLY_LOW;
   arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
+  arrow->set_flag (FLAG_NO_PICK);
   op->play_sound (sound_find ("fire_arrow"));
   m->insert (arrow, sx, sy, op);
   if (!arrow->destroyed ())
       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
   int rate_grace = 2000;
   const int max_hp = 1;
   const int max_sp = 1;
   const int max_grace = 1;
+#if 0
   if (op->contr->hidden)
     {
       op->invisible = 1000;
       /* the socket code flashes the player visible/invisible
        * depending on the value of invisible, so we need to
        * alternate it here for it to work correctly.
        */
       if (server_tick & 2)
         op->invisible--;
     }
+  else
+#endif
-  else if (op->invisible && !(op->flag [FLAG_MAKE_INVIS]))
+  if (op->invisible && !(op->flag [FLAG_MAKE_INVIS]))
     {
       if (!op->invisible--)
         {
           make_visible (op);
           new_draw_info (NDI_UNIQUE, 0, op, "Your invisibility spell runs out.");
                   /* 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.
        */
       for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
         {
           if ((player ||friendly) &&tmp->flag [FLAG_MONSTER] && !tmp->flag [FLAG_UNAGGRESSIVE])
             return 1;
           else if (tmp->type == PLAYER)
-            {
-              /*don't let a hidden DM prevent you from hiding */
-              if (!tmp->flag [FLAG_WIZ] || tmp->contr->hidden == 0)
-                return 1;
+            return 1;
-            }
         }
     }
   return 0;
 }
 /* check the player los field for viewability of the
  * object op. This function works fine for monsters,
  * but we dont worry if the object isnt the top one in
  * a pile (say a coin under a table would return "viewable"
  * by this routine). Another question, should we be
  * concerned with the direction the player is looking
  * in? Realistically, most of us can't see stuff behind
  * our backs...on the other hand, does the "facing" direction
  * imply the way your head, or body is facing? It's possible
  * for them to differ. Sigh, this fctn could get a bit more complex.
  * -b.t.
  * This function is now map tiling safe.
  */
 int
 player_can_view (object *pl, object *op)
 {
   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.291 by root, Mon Nov 12 03:14:33 2012 UTC vs. Revision 1.301 by root, Sat Nov 17 23:40:04 2018 UTC

Diff Legend

Comparing deliantra/server/server/player.C (file contents):
Revision 1.291 by root, Mon Nov 12 03:14:33 2012 UTC vs.
Revision 1.301 by root, Sat Nov 17 23:40:04 2018 UTC