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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.289 by root, Fri Jan 27 22:00:40 2012 UTC vs.
Revision 1.298 by root, Sun Jan 29 03:59:15 2017 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * 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
  * 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
   disconnect ();
   attachable::do_destroy ();
   if (ob)
+    {
+      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)
 {
   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 ())
   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)
   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)
 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)
         {
       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.289 by root, Fri Jan 27 22:00:40 2012 UTC vs. Revision 1.298 by root, Sun Jan 29 03:59:15 2017 UTC

Diff Legend

Comparing deliantra/server/server/player.C (file contents):
Revision 1.289 by root, Fri Jan 27 22:00:40 2012 UTC vs.
Revision 1.298 by root, Sun Jan 29 03:59:15 2017 UTC