[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.121 by root, Fri Apr 30 11:25:48 2010 UTC

 /*
    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
   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;
     }
   /* 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
     {
       /* 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)
    * 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.

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.121 by root, Fri Apr 30 11:25:48 2010 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.121 by root, Fri Apr 30 11:25:48 2010 UTC