--- deliantra/server/common/living.C	2008/09/25 22:58:13	1.90
+++ deliantra/server/common/living.C	2009/11/29 17:41:07	1.105
@@ -5,18 +5,19 @@
  * 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
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+ * 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 GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * 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>
  */
@@ -596,7 +597,7 @@
   object *tmp;
   archetype *at;
 
-  at = archetype::find (ARCH_DEPLETION);
+  at = archetype::find (shstr_depletion);
   if (!at)
     {
       LOG (llevError, "Couldn't find archetype depletion.\n");
@@ -608,7 +609,7 @@
 
       if (!tmp)
         {
-          tmp = arch_to_object (at);
+          tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
           SET_FLAG (tmp, FLAG_APPLIED);
         }
@@ -626,7 +627,7 @@
 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
@@ -638,7 +639,7 @@
           if (!value)
             return;
 
-          tmp = arch_to_object (at);
+          tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
           SET_FLAG (tmp, FLAG_APPLIED);
         }
@@ -768,6 +769,8 @@
   /* First task is to clear all the values back to their original values */
   if (type == PLAYER)
     {
+      contr->delayed_update = false;
+
       for (int i = 0; i < NUM_STATS; i++)
         stat_sum [i] = contr->orig_stats.stat (i);
 
@@ -860,10 +863,7 @@
       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)
@@ -913,7 +913,7 @@
                   continue;
 
               for (int i = 0; i < NUM_STATS; i++)
-                stat_sum [i] = stat_sum [i] + tmp->stats.stat (i);
+                stat_sum [i] += tmp->stats.stat (i);
 
               if (digest_types [tmp->type])
                 {
@@ -1139,10 +1139,10 @@
                   }
 
                 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);
@@ -1152,6 +1152,8 @@
         }                       /* 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.
    */
@@ -1174,18 +1176,16 @@
     {
       // clamp various player stats
       for (int i = 0; i < NUM_STATS; ++i)
-        stats.stat (i) = clamp (stat_sum [i], MIN_STAT, MAX_STAT);
+        stats.stat (i) = stat_sum [i];
+
+      check_stat_bounds (&stats);
 
       contr->digestion = clamp (contr->digestion, MIN_DIGESTION, MAX_DIGESTION);
 
       /* Figure out the players sp/mana/hp totals. */
       int pl_level;
 
-      check_stat_bounds (&(stats));
-      pl_level = level;
-
-      if (pl_level < 1)
-        pl_level = 1;           /* safety, we should always get 1 levels worth of hp! */
+      pl_level = max (1, level); /* safety, we should always get 1 levels worth of hp! */
 
       /* You basically get half a con bonus/level.  But we do take into account rounding,
        * so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
@@ -1330,9 +1330,6 @@
 
       if (settings.search_items && contr->search_str[0])
         speed -= 1;
-
-      if (attacktype == 0)
-        attacktype = arch->attacktype;
     }                           /* End if player */
 
   if (added_speed >= 0)
@@ -1361,8 +1358,7 @@
   /* Put a lower limit on speed.  Note with this speed, you move once every
    * 25 ticks or so. This amounts to once every 3 seconds of realtime.
    */
-  if (speed < 0.04f && type == PLAYER)
-    speed = 0.04f;
+  max_it (speed, is_player () ? MIN_PLAYER_SPEED : MIN_ACTIVE_SPEED);
 
   if (speed != old_speed)
     set_speed (speed);
@@ -1410,17 +1406,30 @@
   /* It is quite possible that a player's spell costing might have changed,
    * so we will check that now.
    */
-  if (type == PLAYER)
-    {
-      esrv_update_stats  (contr);
-      esrv_update_spells (contr);
-    }
+  if (is_player ())
+    contr->update_spells ();
 
   // 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
@@ -1492,7 +1501,7 @@
  * 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 */
@@ -1641,12 +1650,7 @@
     }
 
   if (changed)
-    {
-      who->update_stats ();
-      esrv_update_stats (who->contr);
-      /* check if the spell data has changed */
-      esrv_update_spells (who->contr);
-    }
+    who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
 }
 
 /*
@@ -1771,28 +1775,32 @@
 }
 
 /* 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;
 }
 
@@ -1802,7 +1810,7 @@
   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.
@@ -1925,17 +1933,15 @@
 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
@@ -1945,18 +1951,19 @@
         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);