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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.278 by root, Sun May 9 22:33:29 2010 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 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
  * Free Software Foundation, either version 3 of the License, or (at your
  * 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 Affero GNU General Public License
  * 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>
  */
 //+GPL
+#include <algorithm>
+#include <functional>
 #include <global.h>
 #include <sproto.h>
 #include <sounds.h>
 #include <living.h>
 #include <object.h>
 #include <spells.h>
 #include <skills.h>
-#include <algorithm>
-#include <functional>
 playervec players;
 /* This loads the first map an puts the player on it. */
 static void
 set_first_map (object *op)
 player::set_object (object *op)
 {
   ob = observe = viewpoint = op;
   ob->contr = this;              /* this aren't yet in archetype */
-  ob->set_speed (1.0f);
+  ob->speed = 1.0f; // object still inactive, keep it that way
   ob->speed_left = 0.5f;
   ob->direction  = 5;            /* So player faces south */
 }
   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
  */
 int
 path_to_player (object *mon, object *pl, unsigned mindiff)
 {
   rv_vector rv;
-  int dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked;
+  int dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES;
   get_rangevector (mon, pl, &rv, 0);
   if (rv.distance < mindiff)
     return 0;
             }
           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]
                &&
             }
         }
       /* Here we remove duplicated skills (as duplicated spell objects have
        * _very_ confusing effects for players), which could for instance be
-       * generated by bad treasurelists. - elmex
+       * generated by multiple treasurelists specifying the same skills.
        */
       if (op->type == SKILL)
         {
           for (object *tmp = op->below; tmp; tmp = tmp->below)
             if (tmp->type == op->type && tmp->name == op->name)
               {
                 op->destroy ();
-                LOG (llevError,
-                     "give_initial_items: Removing duplicate skill %s\n", &tmp->name);
                 break;
               }
           if (op->nrof > 1)
             op->nrof = 1;
    */
   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 ()
 {
       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,
     ((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);
       if (item->type == WAND)
         {
           if (!(--item->stats.food))
             {
-              object *tmp;
               if (item->arch)
                 {
                   item->clr_flag (FLAG_ANIMATE);
                   item->face = item->arch->face;
                   item->set_speed (0);
   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
            || mon->flag [FLAG_CAN_ROLL])
           && mon != op)
         break;
     }
-  if (!mon)          /* This happens anytime the player tries to move */
+  /* no monster == player tries to move into a wall or so */
-    return false;                 /* into a wall */
+  if (!mon)
+    {
+      for (object *ob = m->at (nx, ny).top; ob; ob = ob->below)
+        if (op->move_type & ob->move_block)
+          {
+            if (ob->move_block == MOVE_ALL)
+              move_into_wall (op, ob);
+            else
+              {
+                if (op->contr->ns->bumpmsg)
+                  {
+                    op->play_sound (sound_find ("blocked_move"));
+                    op->statusmsg (ob->invisible
+                       ? "Something blocks you."
+                       : format ("Something blocks you from entering the %s.", query_name (ob))
+                    );
+                  }
+              }
+            break;
+          }
+      return false;
+    }
   mon = mon->head_ ();
   if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
     if (op->contr->weapon_sp_left > 0.f)
 }
 bool
 move_player (object *op, int dir)
 {
-  if (!op->map || op->map->in_memory != MAP_ACTIVE)
+  if (!op->map || op->map->state != MAP_ACTIVE)
     return 0;
   /* Sanity check: make sure dir is valid */
   if (dir < 0 || dir > 8)
     {
 void
 do_some_living (object *op)
 {
   int last_food = op->stats.food;
   int gen_hp, gen_sp, gen_grace;
-  int i;
   int rate_hp = 1200;
   int rate_sp = 2500;
   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 (pticks & 2)
+      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)
   if (will_kill_again)
     {
       object *force;
       int at;
-      force = get_archetype (FORCE_NAME);
+      force = archetype::get (FORCE_NAME);
       /* 50 ticks should be enough time for the spell to abate */
       force->speed_left = -5.f;
       force->set_speed (0.1f);
       force->set_flag (FLAG_APPLIED);
 }
 static void
 loot_object (object *op)
 {                               /* Grab and destroy some treasure */
-  object *tmp, *tmp2, *next;
+  object *tmp, *next;
   op->close_container (); /* close open sack first */
   for (tmp = op->inv; tmp; tmp = next)
     {
 void
 fix_weight ()
 {
   for_all_players (pl)
     {
-      sint32 old = pl->ob->carrying;
+      weight_t old = pl->ob->carrying;
       pl->ob->update_weight ();
       if (old != pl->ob->carrying)
         {
     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.278 by root, Sun May 9 22:33:29 2010 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.278 by root, Sun May 9 22:33:29 2010 UTC vs.
Revision 1.302 by root, Sun Nov 18 15:19:48 2018 UTC