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

Comparing deliantra/server/common/living.C (file contents):
Revision 1.89 by root, Thu Sep 25 04:09:57 2008 UTC vs.
Revision 1.101 by root, Mon Nov 9 18:47:55 2009 UTC

  *
  * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992,2007 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>
 object::drain_specific_stat (int deplete_stats)
 {
   object *tmp;
   archetype *at;
-  at = archetype::find (ARCH_DEPLETION);
+  at = archetype::find (shstr_depletion);
   if (!at)
     {
       LOG (llevError, "Couldn't find archetype depletion.\n");
       return;
     }
  * via an applied bad_luck object.
  */
 void
 object::change_luck (int value)
 {
-  archetype *at = archetype::find ("luck");
+  archetype *at = archetype::find (shstr_luck);
   if (!at)
     LOG (llevError, "Couldn't find archetype luck.\n");
   else
     {
       object *tmp = present_arch_in_ob (at, this);
        * then calls this function.
        */
       if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
         continue;
-      /* See note in map.c:update_position about making this additive
-       * since light sources are never applied, need to put check here.
-       */
-      glow_radius = max (glow_radius, tmp->glow_radius);
+      glow_radius += tmp->glow_radius;
       /* For some things, we don't care what is equipped */
       if (tmp->type == SKILL)
         {
           /* Want to take the highest skill here. */
                     else        /* To nullify the below effect */
                       ac += tmp->stats.ac + tmp->magic;
                   }
                 if (tmp->stats.wc)
-                  wc -= (tmp->stats.wc + tmp->magic);
+                  wc -= tmp->stats.wc + tmp->magic;
                 if (tmp->stats.ac)
-                  ac -= (tmp->stats.ac + tmp->magic);
+                  ac -= tmp->stats.ac + tmp->magic;
                 if (ARMOUR_SPEED (tmp))
                   max_speed = min (max_speed, ARMOUR_SPEED (tmp) / 10.f);
                 break;
             }                   /* switch tmp->type */
         }                       /* item is equipped */
     }                           /* for loop of items */
+  glow_radius = min (glow_radius, MAX_LIGHT_RADIUS);
   /* We've gone through all the objects the player has equipped.  For many things, we
    * have generated intermediate values which we now need to assign.
    */
       speed = 1.f + speed_bonus[stats.Dex];
       if (settings.search_items && contr->search_str[0])
         speed -= 1;
-      if (attacktype == 0)
-        attacktype = arch->attacktype;
     }                           /* End if player */
   if (added_speed >= 0)
     speed += added_speed / 10.f;
   else                          /* Something wrong here...: */
     move_type &= ~MOVE_WALK;
   /* It is quite possible that a player's spell costing might have changed,
    * so we will check that now.
    */
-  if (type == PLAYER)
+  if (is_player ())
-    {
+    contr->update_spells ();
-      esrv_update_stats  (contr);
-      esrv_update_spells (contr);
-    }
   // update the mapspace, if we are on a map
   if (!flag [FLAG_REMOVED] && map)
     map->at (x, y).flags_ = 0;
+}
+void
+object::set_glow_radius (sint8 rad)
+{
+  glow_radius = rad;
+  if (is_on_map ())
+    update_all_los (map, x, y);
+  else if (object *env = outer_env ())
+    {
+      env->update_stats ();
+      if (env->is_on_map ())
+        update_all_los (env->map, env->x, env->y);
+    }
 }
 /*
  * Returns true if the given player is a legal class.
  * The function to add and remove class-bonuses to the stats doesn't
 /*
  * This function is called when a dragon-player gains
  * an overall level. Here, the dragon might gain new abilities
  * or change the ability-focus.
  */
-void
+static void
 dragon_level_gain (object *who)
 {
   object *abil = NULL;          /* pointer to dragon ability force */
   object *skin = NULL;          /* pointer to dragon skin force */
   object *tmp = NULL;           /* tmp. object */
           new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
         }
     }
   if (changed)
-    {
+    who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
-      who->update_stats ();
-      esrv_update_stats (who->contr);
-      /* check if the spell data has changed */
-      esrv_update_spells (who->contr);
-    }
 }
 /*
  * Returns how much experience is needed for a player to become
  * the given level.  level should really never exceed max_level
  * flag is what to do if the player doesn't have the skill:
  */
 static void
 add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)
 {
-  object *skill_obj = NULL;
+  object *skill_obj;
   sint64 limit, exp_to_add;
   int i;
   /* prevents some forms of abuse. */
   if (op->contr->braced)
   /* Try to find the matching skill.
    * We do a shortcut/time saving mechanism first - see if it matches
    * chosen_skill. This means we don't need to search through
    * the players inventory.
    */
+  skill_obj = 0;
   if (skill_name)
     {
-      if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill))
+      skill_obj = op->contr->find_skill (skill_name);
-        skill_obj = op->chosen_skill;
-      else
-        {
-          for (object *tmp = op->inv; tmp; tmp = tmp->below)
-            if (tmp->skill == skill_name && tmp->type == SKILL)
-              {
-                skill_obj = splay (tmp);
-                break;
-              }
-          /* Player doesn't have the skill.  Check to see what to do, and give
+      /* Player doesn't have the skill.  Check to see what to do, and give
-           * it to the player if necessary
+       * it to the player if necessary
-           */
+       */
-          if (!skill_obj)
+      if (!skill_obj)
-            {
+        {
-              if (flag == SK_EXP_NONE)
+          if (flag == SK_EXP_NONE)
-                return;
+            return;
-              else if (flag == SK_EXP_ADD_SKILL)
+          if (flag == SK_EXP_ADD_SKILL)
-                skill_obj = give_skill_by_name (op, skill_name);
+            skill_obj = give_skill_by_name (op, skill_name);
-            }
         }
     }
   if (flag != SK_EXP_SKILL_ONLY)
     {
       player_lvl_adj (op, skill_obj);
     }
 }
 /* This function checks to make sure that object 'op' can
- * lost 'exp' experience.  It returns the amount of exp
+ * lose 'exp' experience. It returns the amount of exp
  * object 'op' can in fact lose - it basically makes
  * adjustments based on permanent exp and the like.
  * This function should always be used for losing experience -
  * the 'exp' value passed should be positive - this is the
  * amount that should get subtract from the player.
  */
-sint64
+static sint64
 check_exp_loss (const object *op, sint64 exp)
 {
   sint64 del_exp;
   if (exp > op->stats.exp)
     exp = op->stats.exp;
   if (settings.permanent_exp_ratio)
     {
       del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
       if (del_exp < 0)
         del_exp = 0;
       if (exp > del_exp)
         exp = del_exp;
     }
   return exp;
 }
 sint64
 check_exp_adjust (const object *op, sint64 exp)
 {
   if (exp < 0)
     return check_exp_loss (op, exp);
   else
-    return MIN (exp, (sint64) MAX_EXPERIENCE - op->stats.exp);
+    return min (exp, (sint64)MAX_EXPERIENCE - op->stats.exp);
 }
 /* Subtracts experience from player.
  * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
  * only subtract from the matching skill.  Otherwise,
  * this subtracts a portion from all
   sint64 del_exp;
   for (tmp = op->inv; tmp; tmp = tmp->below)
     if (tmp->type == SKILL && tmp->stats.exp)
       {
-        if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (tmp->skill, skill))
+        if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (&tmp->skill, skill))
           {
             del_exp = check_exp_loss (tmp, exp);
             tmp->stats.exp -= del_exp;
             player_lvl_adj (op, tmp);
           }
  * amount of permenent experience, whichever gives the lowest loss.
  */
 void
 apply_death_exp_penalty (object *op)
 {
-  object *tmp;
   sint64 loss;
   sint64 percentage_loss;       /* defined by the setting 'death_penalty_percent' */
   sint64 level_loss;            /* defined by the setting 'death_penalty_levels */
-  for (tmp = op->inv; tmp; tmp = tmp->below)
+  for (object *tmp = op->inv; tmp; tmp = tmp->below)
     if (tmp->type == SKILL && tmp->stats.exp)
       {
         percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
-        level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)];
+        level_loss = tmp->stats.exp - levels [max (0, tmp->level - settings.death_penalty_level)];
         /* With the revised exp system, you can get cases where
          * losing several levels would still require that you have more
          * exp than you currently have - this is true if the levels
          * tables is a lot harder.
          */
         if (level_loss < 0)
           level_loss = 0;
-        loss = check_exp_loss (tmp, MIN (level_loss, percentage_loss));
+        loss = check_exp_loss (tmp, min (level_loss, percentage_loss));
         tmp->stats.exp -= loss;
         player_lvl_adj (op, tmp);
       }
   percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
-  level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)];
+  level_loss = op->stats.exp - levels[max (0, op->level - settings.death_penalty_level)];
   if (level_loss < 0)
     level_loss = 0;
-  loss = check_exp_loss (op, MIN (level_loss, percentage_loss));
+  loss = check_exp_loss (op, min (level_loss, percentage_loss));
   op->stats.exp -= loss;
   player_lvl_adj (op, NULL);
 }

Diff Legend

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

Comparing deliantra/server/common/living.C (file contents): Revision 1.89 by root, Thu Sep 25 04:09:57 2008 UTC vs. Revision 1.101 by root, Mon Nov 9 18:47:55 2009 UTC

Diff Legend

Comparing deliantra/server/common/living.C (file contents):
Revision 1.89 by root, Thu Sep 25 04:09:57 2008 UTC vs.
Revision 1.101 by root, Mon Nov 9 18:47:55 2009 UTC