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

Comparing deliantra/server/common/living.C (file contents):
Revision 1.76 by root, Tue Aug 7 22:57:57 2007 UTC vs.
Revision 1.113 by root, Sun Mar 28 17:04:37 2010 UTC

 /*
- * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
+ * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 1992 Frank Tore Johansen
  *
- * Crossfire TRT 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 <crossfire@schmorp.de>
+ * The authors can be reached via e-mail to <support@deliantra.net>
  */
 #include <global.h>
-#include <funcpoint.h>
 /* Handy little macro that adds exp and keeps it within bounds.  Since
  * we are now using 64 bit values, I'm not all concerned about overflow issues
  * with exptotal wrapping.  exptotal is typically op->exp, or op->perm_exp
  */
 /* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
  * make this macro to clean those up.  Not usuable outside change_abil
  * function since some of the values passed to new_draw_info are hardcoded.
  */
 #define DIFF_MSG(flag, msg1, msg2) \
-    new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2);
+    new_draw_info (NDI_UNIQUE, 0, op, (flag > 0) ? msg1 : msg2);
 /* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */
 /* flag is set to 1 if we are applying the object, -1 if we are removing
  * the object.
  * that gives them that ability.
  */
 int
 change_abil (object *op, object *tmp)
 {
-  int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, success = 0;
+  int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
+  int success = 0;
   char message[MAX_BUF];
   int potion_max = 0;
-  /* remember what object was like before it was changed.  note that
+  // keep some stats for comparison purposes
-   * refop is a local copy of op only to be used for detecting changes
+  object::flags_t prev_flag = op->flag;
-   * found by update_stats. refop is not a real object
+  MoveType prev_move_type = op->move_type;
-   */
+  sint16 prev_resist [NROFATTACKS]; // clumsy
-  object_copy refop = *op;
+  assert (sizeof (prev_resist) == sizeof (op->resist));
+  memcpy (prev_resist, op->resist, sizeof (prev_resist));
   if (op->type == PLAYER)
     {
       if (tmp->type == POTION)
         {
           potion_max = 1;
           for (int j = 0; j < NUM_STATS; j++)
             {
               int ostat = op->contr->orig_stats.stat (j);
               int i = tmp->stats.stat (j);
               /* nstat is what the stat will be after use of the potion */
               int nstat = flag * i + ostat;
-              /* Do some bounds checking.  While I don't think any
+              /* Do some bounds checking. There is the potential for potions
-               * potions do so right now, there is the potential for potions
                * that adjust that stat by more than one point, so we need
                * to allow for that.
                */
               if (nstat < 1 && i * flag < 0)
                 nstat = 1;
     {
       success = 1;
       DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
     }
-  if (QUERY_FLAG (op, FLAG_LIFESAVE) != QUERY_FLAG (&refop, FLAG_LIFESAVE))
+  if (op->flag [FLAG_LIFESAVE] != prev_flag [FLAG_LIFESAVE])
     {
       success = 1;
       DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");
     }
-  if (QUERY_FLAG (op, FLAG_REFL_MISSILE) != QUERY_FLAG (&refop, FLAG_REFL_MISSILE))
+  if (op->flag [FLAG_REFL_MISSILE] != prev_flag [FLAG_REFL_MISSILE])
     {
       success = 1;
       DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");
     }
-  if (QUERY_FLAG (op, FLAG_REFL_SPELL) != QUERY_FLAG (&refop, FLAG_REFL_SPELL))
+  if (op->flag [FLAG_REFL_SPELL] != prev_flag [FLAG_REFL_SPELL])
     {
       success = 1;
       DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");
     }
    * user has multiple items giving the same type appled like we
    * used to - that is more work than what we gain, plus messages
    * can be misleading (a little higher could be miscontrued from
    * from fly high)
    */
-  if (tmp->move_type && op->move_type != refop.move_type)
+  if (tmp->move_type && op->move_type != prev_move_type)
     {
       success = 1;
       /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
        * status doesn't make a difference if you are flying high
        */
       if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
         {
-          DIFF_MSG (flag, "You start to float in the air!.", "You float down to the ground.");
+          DIFF_MSG (flag, "You start to float in the air!", "You float down to the ground.");
         }
       if (tmp->move_type & MOVE_FLY_HIGH)
         {
           /* double conditional - second case covers if you have move_fly_low -
                     (op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));
         }
       if (tmp->move_type & MOVE_SWIM)
         DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");
-      /* Changing move status may mean you are affected by things you weren't before */
-      check_move_on (op, op);
     }
   /* becoming UNDEAD... a special treatment for this flag. Only those not
    * originally undead may change their status
    */
-  if (!QUERY_FLAG (op->arch, FLAG_UNDEAD))
+  if (!op->arch->flag [FLAG_UNDEAD])
-    if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD))
+    if (op->flag [FLAG_UNDEAD] != prev_flag [FLAG_UNDEAD])
       {
         success = 1;
         if (flag > 0)
           {
             op->race = "undead";
             op->race = op->arch->race;
             new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
           }
       }
-  if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH))
+  if (op->flag [FLAG_STEALTH] != prev_flag [FLAG_STEALTH])
     {
       success = 1;
       DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
     }
-  if (QUERY_FLAG (op, FLAG_MAKE_INVIS) != QUERY_FLAG (&refop, FLAG_MAKE_INVIS))
+  if (op->flag [FLAG_MAKE_INVIS] != prev_flag [FLAG_MAKE_INVIS])
     {
       success = 1;
       DIFF_MSG (flag, "You become transparent.", "You can see yourself.");
     }
   /* blinded you can tell if more blinded since blinded player has minimal
    * vision
    */
-  if (QUERY_FLAG (tmp, FLAG_BLIND))
+  if (tmp->flag [FLAG_BLIND])
     {
       success = 1;
       if (flag > 0)
         {
-          if (QUERY_FLAG (op, FLAG_WIZ))
+          if (op->flag [FLAG_WIZ])
             new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");
           else
             {
               new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");
               SET_FLAG (op, FLAG_BLIND);
                 op->contr->do_los = 1;
             }
         }
       else
         {
-          if (QUERY_FLAG (op, FLAG_WIZ))
+          if (op->flag [FLAG_WIZ])
             new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");
           else
             {
               new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");
               CLEAR_FLAG (op, FLAG_BLIND);
                 op->contr->do_los = 1;
             }
         }
     }
-  if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) != QUERY_FLAG (&refop, FLAG_SEE_IN_DARK))
+  if (op->flag [FLAG_SEE_IN_DARK] != prev_flag [FLAG_SEE_IN_DARK])
     {
       success = 1;
       if (op->type == PLAYER)
         op->contr->do_los = 1;
       DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");
     }
-  if (QUERY_FLAG (op, FLAG_XRAYS) != QUERY_FLAG (&refop, FLAG_XRAYS))
+  if (op->flag [FLAG_XRAYS] != prev_flag [FLAG_XRAYS])
     {
       success = 1;
       if (flag > 0)
         {
-          if (QUERY_FLAG (op, FLAG_WIZ))
+          if (op->flag [FLAG_WIZ])
             new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");
           else
             {
               new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");
               if (op->type == PLAYER)
                 op->contr->do_los = 1;
             }
         }
       else
         {
-          if (QUERY_FLAG (op, FLAG_WIZ))
+          if (op->flag [FLAG_WIZ])
             new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");
           else
             {
               new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");
               if (op->type == PLAYER)
   for (int i = 0; i < NROFATTACKS; i++)
     {
       if (i == ATNR_PHYSICAL)
         continue;               /* Don't display about armour */
-      if (op->resist[i] != refop.resist[i])
+      if (op->resist [i] != prev_resist [i])
         {
           success = 1;
-          if (op->resist[i] > refop.resist[i])
+          if (op->resist [i] > prev_resist [i])
-            sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg[i], op->resist[i]);
+            sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg [i], op->resist [i]);
           else
-            sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg[i], op->resist[i]);
+            sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg [i], op->resist [i]);
           new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
         }
     }
   if (!potion_max)
-    {
-      for (int j = 0; j < NUM_STATS; j++)
+    for (int j = 0; j < NUM_STATS; j++)
-        {
-          if (int i = tmp->stats.stat (j))
+      if (int i = tmp->stats.stat (j))
-            {
+        {
-              success = 1;
+          success = 1;
-              DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
+          DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
-            }
+        }
-        }
-    }
   return success;
 }
 /*
 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;
     }
     {
       tmp = present_arch_in_ob (at, this);
       if (!tmp)
         {
-          tmp = arch_to_object (at);
+          tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
           SET_FLAG (tmp, FLAG_APPLIED);
         }
     }
  * 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);
       if (!tmp)
         {
           if (!value)
             return;
-          tmp = arch_to_object (at);
+          tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
           SET_FLAG (tmp, FLAG_APPLIED);
         }
       if (value)
   int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
   object *grace_obj = NULL, *mana_obj = NULL, *tmp;
   float old_speed = speed;
   int stat_sum [NUM_STATS];
+  MoveType move_type; // we use change_move_type to change it, so use a local copy
   /* 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);
       if (settings.spell_encumbrance == TRUE)
         contr->encumbrance = 0;
   path_repelled = arch->path_repelled;
   path_denied   = arch->path_denied;
   glow_radius   = arch->glow_radius;
   move_type     = arch->move_type;
-  chosen_skill = 0;
+  object *chosen_skill = 0;
   /* initializing resistances from the values in player/monster's
    * archetype clone
    */
   memcpy (&resist, &arch->resist, sizeof (resist));
   for (int i = 0; i < NROFATTACKS; i++)
     {
       if (resist[i] > 0)
-        prot[i] = resist[i], vuln[i] = 0;
+        prot[i] =  resist[i], vuln[i] = 0;
       else
-        vuln[i] = -(resist[i]), prot[i] = 0;
+        vuln[i] = -resist[i], prot[i] = 0;
-      potion_resist[i] = 0;
+      potion_resist[i] = -1000;
     }
   wc = arch->stats.wc;
   stats.dam = arch->stats.dam;
        * 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.
-       */
-      if (tmp->glow_radius > glow_radius)
-        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 if (tmp->level > grace_obj->level)
                 grace_obj = tmp;
             }
         }
-      /* Container objects are not meant to adjust a players, but other applied
+      /* Container objects are not meant to adjust players, but other applied
        * objects need to make adjustments.
        * This block should handle all player specific changes
        * The check for Praying is a bit of a hack - god given bonuses are put
        * in the praying skill, and the player should always get those.
        * It also means we need to put in additional checks for applied below,
        * up, etc.
        */
       if ((tmp->flag [FLAG_APPLIED]
            && tmp->type != CONTAINER
            && tmp->type != CLOSE_CON)
-          || (tmp->type == SKILL
-              && tmp->subtype == SK_PRAYING))
+          || (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
         {
           if (type == PLAYER)
             {
               contr->item_power += tmp->item_power;
                     && !tmp->flag [FLAG_CURSED]
                     && !tmp->flag [FLAG_DAMNED])
                   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])
                 {
                   contr->digestion     += tmp->stats.food;
                   contr->gen_hp        += tmp->stats.hp;
+                  if (tmp->type != BOW) // ugly exception for bows
-                  contr->gen_sp        += tmp->stats.sp;
+                    contr->gen_sp      += tmp->stats.sp;
                   contr->gen_grace     += tmp->stats.grace;
                   contr->gen_sp_armour += tmp->gen_sp_armour;
                 }
             }                   /* if this is a player */
           else
               if (tmp->type == WEAPON)
                 current_weapon = tmp;
             }
           /* Update slots used for items */
-          if (QUERY_FLAG (tmp, FLAG_APPLIED))
+          if (tmp->flag [FLAG_APPLIED])
             for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
               slot[i].used += tmp->slot[i].info;
           if (tmp->type == SYMPTOM)
-            {
-              speed_reduce_from_disease = tmp->last_sp / 100.f;
+            min_it (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f);
-              if (speed_reduce_from_disease == 0)
-                speed_reduce_from_disease = 1;
-            }
-          /* Pos. and neg. protections are counted seperate (-> pro/vuln).
+          /* Pos. and neg. protections are counted separate (-> pro/vuln).
            * (Negative protections are calculated exactly like positive.)
            * Resistance from potions are treated special as well. If there's
            * more than one potion-effect, the bigger prot.-value is taken.
            */
-          if (tmp->type != POTION)
+          if (tmp->type == POTION_EFFECT)
-            {
-              for (int i = 0; i < NROFATTACKS; i++)
+            for (int i = 0; i < NROFATTACKS; i++)
-                {
-                  /* Potential for cursed potions, in which case we just can use
-                   * a straight MAX, as potion_resist is initialised to zero.
-                   */
-                  if (tmp->type == POTION_EFFECT)
-                    {
-                      if (potion_resist[i])
-                        potion_resist[i] = max (potion_resist[i], tmp->resist[i]);
-                      else
-                        potion_resist[i] = tmp->resist[i];
+              max_it (potion_resist[i], tmp->resist[i]);
-                    }
+          else if (tmp->type != POTION)
+            for (int i = 0; i < NROFATTACKS; i++)
-                  else if (tmp->resist[i] > 0)
+              if (tmp->resist[i] > 0)
-                    prot[i] += ((100 - prot[i]) *  tmp->resist[i]) / 100;
+                prot[i] += ((100 - prot[i]) *  tmp->resist[i]) / 100;
-                  else if (tmp->resist[i] < 0)
+              else if (tmp->resist[i] < 0)
-                    vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;
+                vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;
-                }
-            }
           /* There may be other things that should not adjust the attacktype */
           if (tmp->type != SYMPTOM)
             {
               attacktype    |= tmp->attacktype;
                 added_speed += tmp->stats.exp;
             }
           switch (tmp->type)
             {
-#if 0
-              case WAND:
-              case ROD:
-              case HORN:
-                if (type != PLAYER || current_weapon == tmp)
-                  chosen_skill = tmp;
-                break;
-#endif
                 /* skills modifying the character -b.t. */
                 /* for all skills and skill granting objects */
               case SKILL:
                 {
                   if (!QUERY_FLAG (tmp, FLAG_APPLIED) || skill_flags [tmp->subtype] & SF_APPLY)
                   if (tmp->stats.ac)
                     ac -= tmp->stats.ac + tmp->magic;
                   if (settings.spell_encumbrance == TRUE && type == PLAYER)
-                    contr->encumbrance += (int) 3 *tmp->weight / 1000;
+                    contr->encumbrance += 3 * tmp->weight / 1000;
                 }
                 break;
               case SHIELD:
                 if (settings.spell_encumbrance == TRUE && type == PLAYER)
-                  contr->encumbrance += (int) tmp->weight / 2000;
+                  contr->encumbrance += tmp->weight / 2000;
+                //FALLTHROUGH
               case RING:
               case AMULET:
               case GIRDLE:
               case HELMET:
               case BOOTS:
                 if (tmp->stats.ac)
                   ac -= tmp->stats.ac + tmp->magic;
                 break;
+              case WAND:
+              case ROD:
+              case HORN:
+              case SKILL_TOOL:
+                if (type != PLAYER)
+                  chosen_skill = find_skill_by_name (this, tmp->skill);
+                break;
               case BOW:
               case WEAPON:
                 if (type != PLAYER || current_weapon == tmp)
                   {
+                    chosen_skill = find_skill_by_name (this, tmp->skill);
                     wc -= tmp->stats.wc + tmp->magic;
                     if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
                       ac -= tmp->stats.ac + tmp->magic;
                     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 */
+  if (type != PLAYER)
+    this->chosen_skill = chosen_skill;
+  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.
    */
    */
   for (int i = 0; i < NROFATTACKS; i++)
     {
       resist[i] = prot[i] - vuln[i];
-      if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0)))
+      if (potion_resist[i] != -1000
+          && (potion_resist[i] > resist[i] || potion_resist[i] < 0))
         resist[i] = potion_resist[i];
     }
   if (type == PLAYER)
     {
       // 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.
        */
       stats.maxhp = 0;
       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...: */
       /* f is a number the represents the number of kg above (positive num)
        * or below (negative number) that the player is carrying.  If above
        * weight limit, then player suffers a speed reduction based on how
        * much above he is, and what is max carry is
        */
-      f = (carrying / 1000) - max_carry[stats.Str];
+      float f = (carrying / 1000) - max_carry[stats.Str];
-      if (f > 0)
+      if (f > 0.f)
         speed = speed / (1.f + f / max_carry[stats.Str]);
     }
   speed += bonus_speed / 10.f;      /* Not affected by limits */
+  speed *= speed_reduce_from_disease;
   /* Put a lower limit on speed.  Note with this speed, you move once every
-   * 100 ticks or so.  This amounts to once every 12 seconds of realtime.
+   * 25 ticks or so. This amounts to once every 3 seconds of realtime.
    */
-  speed = speed * speed_reduce_from_disease;
+  max_it (speed, is_player () ? MIN_PLAYER_SPEED : MIN_ACTIVE_SPEED);
-  if (speed < 0.01f && type == PLAYER)
+  if (speed != old_speed)
-    speed = 0.01f;
+    set_speed (speed);
   if (type == PLAYER)
     {
       /* (This formula was made by vidarl@ifi.uio.no)
        * Note that we never used these values again - basically
   if (move_type == 0)
     move_type = MOVE_WALK;
   else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
     move_type &= ~MOVE_WALK;
-  if (speed != old_speed)
+  // now apply the new move_type
-    set_speed (speed);
+  if (this->move_type != move_type)
+    change_move_type (move_type);
   /* 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
 /*
  * set the new dragon name after gaining levels or
  * changing ability focus (later this can be extended to
  * eventually change the player's face and animation)
- *
- * Note that the title is written to 'own_title' in the
- * player struct. This should be changed to 'ext_title'
- * as soon as clients support this!
- * Please, anyone, write support for 'ext_title'.
  */
 void
 set_dragon_name (object *pl, const object *abil, const object *skin)
 {
   int atnr = -1;                /* attacknumber of highest level */
   /* now if there are equals at highest level, pick the one with focus,
      or else at random */
   if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
     atnr = abil->stats.exp;
-  level = (int) (level / 5.);
   /* now set the new title */
-  if (pl->contr != NULL)
-    {
-      if (level == 0)
-        sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
+  if      (level <  25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
-      else if (level == 1)
-        sprintf (pl->contr->title, "%s wyrm", attacks[atnr]);
+  else if (level <  50) sprintf (pl->contr->title, "%s wyrm"     , attacks[atnr]);
-      else if (level == 2)
-        sprintf (pl->contr->title, "%s wyvern", attacks[atnr]);
+  else if (level <  75) sprintf (pl->contr->title, "%s wyvern"   , attacks[atnr]);
-      else if (level == 3)
-        sprintf (pl->contr->title, "%s dragon", attacks[atnr]);
+  else if (level < 100) sprintf (pl->contr->title, "%s dragon"   , attacks[atnr]);
-      else
+  else
-        {
+    {
-          /* special titles for extra high resistance! */
+      /* special titles for extra high resistance! */
-          if (skin->resist[atnr] > 80)
-            sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
+      if      (skin->resist[atnr] > 80) sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
-          else if (skin->resist[atnr] > 50)
-            sprintf (pl->contr->title, "ancient %s dragon", attacks[atnr]);
+      else if (skin->resist[atnr] > 50) sprintf (pl->contr->title, "ancient %s dragon"  , attacks[atnr]);
-          else
-            sprintf (pl->contr->title, "big %s dragon", attacks[atnr]);
+      else                              sprintf (pl->contr->title, "big %s dragon"      , attacks[atnr]);
-        }
     }
   strcpy (pl->contr->own_title, "");
 }
 /*
  * 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 */
   object *skill_obj;
   skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
   if (!skill_obj)
     {
-      LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name);
+      LOG (llevError, "give_skill_by_name: couldn't find skill %s\n", skill_name);
       return NULL;
     }
   /* clear the flag - exp goes into this bucket, but player
    * still doesn't know it.
    */
   CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);
   skill_obj->stats.exp = 0;
   skill_obj->level = 1;
-  insert_ob_in_ob (skill_obj, op);
+  op->insert (skill_obj);
   if (player *pl = op->contr)
-    {
+    pl->link_skills ();
-      pl->last_skill_ob [skill_obj->subtype] = skill_obj;
-      if (pl->ns)
-        pl->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
-    }
   return skill_obj;
 }
 /* player_lvl_adj() - for the new exp system. we are concerned with
     {
       changed = true;
       op->level++;
-      if (op && op == who && op->stats.exp > 1 && is_dragon_pl (who))
+      if (op && op == who && op->stats.exp > 1 && who->is_dragon ())
         dragon_level_gain (who);
       /* Only roll these if it is the player (who) that gained the level */
       if (op == who && (who->level < 11) && who->type == PLAYER)
         {
           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 (i = 0; i < NUM_SKILLS; i++)
-            if (op->contr->last_skill_ob[i] && !strcmp (op->contr->last_skill_ob[i]->skill, skill_name))
-              {
-                skill_obj = op->contr->last_skill_ob[i];
-                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)
-                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.76 by root, Tue Aug 7 22:57:57 2007 UTC vs. Revision 1.113 by root, Sun Mar 28 17:04:37 2010 UTC

Diff Legend

Comparing deliantra/server/common/living.C (file contents):
Revision 1.76 by root, Tue Aug 7 22:57:57 2007 UTC vs.
Revision 1.113 by root, Sun Mar 28 17:04:37 2010 UTC