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

Comparing deliantra/server/common/living.C (file contents):
Revision 1.117 by root, Tue Apr 6 21:11:48 2010 UTC vs.
Revision 1.127 by root, Fri Jan 27 22:00:39 2012 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 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
 /*
    Since this is nowhere defined ...
    Both come in handy at least in function add_exp()
 */
-#define MAX_EXPERIENCE  levels[settings.max_level]
+#define MAX_EXPERIENCE  levels [settings.max_level]
 /* because exp_obj sum to make the total score,
  * we cannot allow that sum to exceed the maximum
  * amount of experience a player can gain. Thus
  * we define MAX_EXP_IN_OBJ. It is important to try
  * line with progression of previous levels, so
  * if more levels are desired, this should be fixed.
  *  -b.t.
  */
-#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)
+#define MAX_EXP_IN_OBJ MAX_EXP_IN_OBJ / (MAX_EXP_CAT - 1)
-extern sint64 *levels;
 #define MAX_SAVE_LEVEL 110
 /* This no longer needs to be changed anytime the number of
  * levels is increased - rather, did_make_save will do the
           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->set_flag (FLAG_BLIND);
               if (op->type == PLAYER)
                 op->contr->do_los = 1;
             }
         }
       else
           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->clr_flag (FLAG_BLIND);
               if (op->type == PLAYER)
                 op->contr->do_los = 1;
             }
         }
     }
       if (!tmp)
         {
           tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
-          SET_FLAG (tmp, FLAG_APPLIED);
+          tmp->set_flag (FLAG_APPLIED);
         }
     }
   new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
   change_attr_value (&tmp->stats, deplete_stats, -1);
           if (!value)
             return;
           tmp = at->instance ();
           tmp = insert_ob_in_ob (tmp, this);
-          SET_FLAG (tmp, FLAG_APPLIED);
+          tmp->set_flag (FLAG_APPLIED);
         }
       if (value)
         {
           /* Limit the luck value of the bad luck object to +/-100. This
  * spell system split, grace points now added to system  --peterm
  */
 void
 object::update_stats ()
 {
-  float f, max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
+  float max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
   int weapon_weight = 0, weapon_speed = 0;
   int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
   int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
   object *grace_obj = NULL, *mana_obj = NULL, *tmp;
   float old_speed = speed;
   for (int i = NUM_BODY_LOCATIONS; i--; )
     slot[i].used = slot[i].info;
   slaying = 0;
-  if (!QUERY_FLAG (this, FLAG_WIZ))
+  if (!this->flag [FLAG_WIZ])
-    {
-      CLEAR_FLAG (this, FLAG_XRAYS);
-      CLEAR_FLAG (this, FLAG_MAKE_INVIS);
-    }
+    {
+      this->clr_flag (FLAG_XRAYS);
+      this->clr_flag (FLAG_MAKE_INVIS);
+    }
-  CLEAR_FLAG (this, FLAG_LIFESAVE);
+  this->clr_flag (FLAG_LIFESAVE);
-  CLEAR_FLAG (this, FLAG_STEALTH);
+  this->clr_flag (FLAG_STEALTH);
-  CLEAR_FLAG (this, FLAG_BLIND);
+  this->clr_flag (FLAG_BLIND);
-  if (!QUERY_FLAG (arch, FLAG_REFL_SPELL  )) CLEAR_FLAG (this, FLAG_REFL_SPELL);
+  if (!arch->flag [FLAG_REFL_SPELL  ]) this->clr_flag (FLAG_REFL_SPELL);
-  if (!QUERY_FLAG (arch, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);
+  if (!arch->flag [FLAG_REFL_MISSILE]) this->clr_flag (FLAG_REFL_MISSILE);
-  if (!QUERY_FLAG (arch, FLAG_UNDEAD      )) CLEAR_FLAG (this, FLAG_UNDEAD);
+  if (!arch->flag [FLAG_UNDEAD      ]) this->clr_flag (FLAG_UNDEAD);
-  if (!QUERY_FLAG (arch, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);
+  if (!arch->flag [FLAG_SEE_IN_DARK ]) this->clr_flag (FLAG_SEE_IN_DARK);
   path_attuned  = arch->path_attuned;
   path_repelled = arch->path_repelled;
   path_denied   = arch->path_denied;
   glow_radius   = arch->glow_radius;
    * the fact that maxlevel is factored in could be considered sort of bogus -
    * we should probably give them some bonus and cap it off - otherwise,
    * basically, if a server updates its max level, these playes may find
    * that their protection from physical goes down
    */
-  if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)
+  if (!this->flag [FLAG_USE_ARMOUR] && type == PLAYER)
     {
       ac = max (-10, arch->stats.ac - level / 3);
       prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
     }
   else
     {
       /* This happens because apply_potion calls change_abil with the potion
        * applied so we can tell the player what changed. But change_abil
        * then calls this function.
        */
-      if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
+      if (tmp->flag [FLAG_APPLIED] && tmp->type == POTION)
         continue;
       glow_radius += tmp->glow_radius;
       /* For some things, we don't care what is equipped */
        * because the skill shouldn't count against body positions being used
        * up, etc.
        */
       if ((tmp->flag [FLAG_APPLIED]
            && tmp->type != CONTAINER
-           && tmp->type != CLOSE_CON)
+           && tmp->type != CLOSE_CON
+           && tmp->type != SPELL)
           || (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
         {
           if (type == PLAYER)
             {
               contr->item_power += tmp->item_power;
             for (int i = 0; i < NROFATTACKS; i++)
               max_it (potion_resist[i], tmp->resist[i]);
           else if (tmp->type != POTION)
             for (int i = 0; i < NROFATTACKS; i++)
               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)
-                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;
               stats.luck    += tmp->stats.luck;
             }
           flag |= tmp->flag & copy_flags;
-          if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (arch, FLAG_UNDEAD))
+          if (tmp->flag [FLAG_UNDEAD] && !arch->flag [FLAG_UNDEAD])
-            SET_FLAG (this, FLAG_UNDEAD);
+            this->set_flag (FLAG_UNDEAD);
           //TODO: copy_flags?
-          if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))
+          if (tmp->flag [FLAG_MAKE_INVIS])
             {
-              SET_FLAG (this, FLAG_MAKE_INVIS);
+              set_flag (FLAG_MAKE_INVIS);
               invisible = 1;
             }
           if (tmp->stats.exp && tmp->type != SKILL)
             {
                   chosen_skill = tmp;
                   if (tmp->stats.dam > 0)
                     {             /* skill is a 'weapon' */
-                      if (!QUERY_FLAG (this, FLAG_READY_WEAPON))
+                      if (!this->flag [FLAG_READY_WEAPON])
                         weapon_speed = max (0, WEAPON_SPEED (tmp));
                       weapon_weight = tmp->weight;
                       stats.dam += 1 + chosen_skill->level * tmp->stats.dam / 9;
                 if (tmp->stats.ac)
                   ac -= tmp->stats.ac + tmp->magic;
                 break;
-              case WAND:
+              case RANGED:
-              case ROD:
-              case HORN:
-                break;
               case BOW:
               case WEAPON:
                 wc -= tmp->stats.wc + tmp->magic;
                 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
                 if (tmp->stats.ac)
                   ac -= tmp->stats.ac + tmp->magic;
                 if (ARMOUR_SPEED (tmp))
-                  max_speed = min (max_speed, ARMOUR_SPEED (tmp) / 10.f);
+                  min_it (max_speed, ARMOUR_SPEED (tmp) / 10.f);
                 break;
             }                   /* switch tmp->type */
         }                       /* item is equipped */
     }                           /* for loop of items */
     }
   /* 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->clr_flag (FLAG_CAN_USE_SKILL);
   skill_obj->stats.exp = 0;
   skill_obj->level = 1;
   op->insert (skill_obj);
   if (player *pl = op->contr)
  */
 sint64
 level_exp (int level, double expmul)
 {
-  if (level > settings.max_level)
+  return expmul * level_to_min_exp (level);
-    return (sint64) (expmul * levels[settings.max_level]);
-  return (sint64) (expmul * levels[level]);
 }
 /*
  * Ensure that the permanent experience requirements in an exp object are met.
  * This really just checks 'op to make sure the perm_exp value is within
  *   NULL, in which case exp increases the players general
  *   total, but not any particular skill.
  * 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)
+add_player_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
 {
   object *skill_obj;
   sint64 limit, exp_to_add;
-  int i;
   /* prevents some forms of abuse. */
   if (op->contr->braced)
     exp /= 5;
     {
       /* Basically, you can never gain more experience in one shot
        * than half what you need to gain for next level.
        */
       exp_to_add = exp;
-      limit = (levels[op->level + 1] - levels[op->level]) / 2;
+      limit = (levels [op->level + 1] - levels [op->level]) / 2;
       if (exp_to_add > limit)
         exp_to_add = limit;
       ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));
       if (settings.permanent_exp_ratio)
     }
   if (skill_obj)
     {
       exp_to_add = exp;
-      limit = (levels[skill_obj->level + 1] - levels[skill_obj->level]) / 2;
+      limit = (levels [skill_obj->level + 1] - levels [skill_obj->level]) / 2;
       if (exp_to_add > limit)
         exp_to_add = limit;
       ADD_EXP (skill_obj->stats.exp, exp_to_add);
       if (settings.permanent_exp_ratio)
  * where everything is at the minimum perm exp, he would lose nothing.
  * exp is the amount of exp to subtract - thus, it should be
  * a postive number.
  */
 static void
-subtract_player_exp (object *op, sint64 exp, const char *skill, int flag)
+subtract_player_exp (object *op, sint64 exp, shstr_tmp skill, int flag)
 {
   float fraction = (float) exp / (float) op->stats.exp;
   object *tmp;
   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 && tmp->skill == skill)
           {
             del_exp = check_exp_loss (tmp, exp);
             tmp->stats.exp -= del_exp;
             player_lvl_adj (op, tmp);
           }
         else if (flag != SK_SUBTRACT_SKILL_EXP)
           {
             /* only want to process other skills if we are not trying
              * to match a specific skill.
              */
-            del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction));
+            del_exp = check_exp_loss (tmp, tmp->stats.exp * fraction);
             tmp->stats.exp -= del_exp;
             player_lvl_adj (op, tmp);
           }
       }
  * skill_name is the skill that should get the exp added.
  * flag is what to do if player doesn't have the skill.
  * these last two values are only used for players.
  */
 void
-change_exp (object *op, sint64 exp, const char *skill_name, int flag)
+change_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
 {
 #ifdef EXP_DEBUG
   LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
 #endif
    * worth.
    */
   if (op->type != PLAYER)
     {
       /* Sanity check */
-      if (!QUERY_FLAG (op, FLAG_ALIVE))
+      if (!op->flag [FLAG_ALIVE])
         return;
       /* reset exp to max allowed value.  We subtract from
        * MAX_EXPERIENCE to prevent overflows.  If the player somehow has
        * more than max exp, just return.
         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));

Diff Legend

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

Comparing deliantra/server/common/living.C (file contents): Revision 1.117 by root, Tue Apr 6 21:11:48 2010 UTC vs. Revision 1.127 by root, Fri Jan 27 22:00:39 2012 UTC

Diff Legend

Comparing deliantra/server/common/living.C (file contents):
Revision 1.117 by root, Tue Apr 6 21:11:48 2010 UTC vs.
Revision 1.127 by root, Fri Jan 27 22:00:39 2012 UTC