server/common/living.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 *
 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 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
 * 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 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>
 */

#include <global.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
 */
#define ADD_EXP(exptotal, exp) {exptotal += exp; if (exptotal > MAX_EXPERIENCE) exptotal = MAX_EXPERIENCE; }

static const int con_bonus[MAX_STAT + 1] = {
  -6, -5, -4, -3, -2, -1, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20,
  22, 25, 30, 40, 50
};

/* changed the name of this to "sp_bonus" from "int_bonus"
 * because Pow can now be the stat that controls spellpoint
 * advancement. -b.t.
 */
static const int sp_bonus[MAX_STAT + 1] = {
  -10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
  30, 40, 50, 70, 100
};

static const int grace_bonus[MAX_STAT + 1] = {
  -10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
  30, 40, 50, 70, 100
};

/* 0.92.7 Changed way charisma works.  Values now 
 * represent how much more it costs to buy something than to sell it
 * (10, a value of 10 means it is that if it costs 50 gp to buy, you
 * would only get 5 gp when you sell.)  Let query_cost do the calculations
 * on how to really do this.  Buy keeping it this simple number, it is
 * much easier to know how things will be influenced.  A value of '1' means
 * buying and selling is both the same value - any value less than or equal
 * to 1 should not be used.  
 * At least as of now, the only place that uses this code is query_cost,
 * in server/shop.c.  This bonus is split evenly between buying and selling
 * (ie, if the bonus is 2.0, then items are bought for 1.33 list, and sold
 * at .667
 * This is figured by diff=(y-1)/(1+y), and for buy, it is 1+diff, for sell
 * it is 1-diff
 */

const float cha_bonus[MAX_STAT + 1] = { 10.0,
  10.0, 9.0, 8.0, 7.0, 6.0,     /*  5 */
  5.0, 4.5, 4.0, 3.5, 3.0,      /* 10 */
  2.9, 2.8, 2.7, 2.6, 2.5,      /* 15 */
  2.4, 2.3, 2.2, 2.1, 2.0,      /* 20 */
  1.9, 1.8, 1.7, 1.6, 1.5,      /* 25 */
  1.4, 1.3, 1.2, 1.1, 1.0       /* 30 */
};

const int dex_bonus[MAX_STAT + 1] = {
  -4, -3, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7
};

/* speed_bonus uses dex as its stat */
const float speed_bonus[MAX_STAT + 1] = {
  -0.4, -0.35, -0.3, -0.25, -0.2, -0.16, -0.12, -0.09, -0.06, -0.03, -0.01, 0, 0.01, 0.03,
  0.05, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.4,
  1.6, 1.8, 2.0, 2.5, 3.0
};

/* dam_bonus, thaco_bonus, max_carry, weight limit all are based on
 * strength.
 */
const int dam_bonus[MAX_STAT + 1] = {
  -2, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 10, 15
};

const int thaco_bonus[MAX_STAT + 1] = {
  -2, -2, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 10
};

/* Max you can carry before you start getting extra speed penalties */
const int max_carry[MAX_STAT + 1] = {
  2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172, 191, 211, 232, 254, 277,
  301, 326, 352, 400, 450, 500, 600, 1000
};

/* weight_limit - the absolute most a character can carry - a character can't
 * pick stuff up if it would put him above this limit.
 * value is in grams, so we don't need to do conversion later
 * These limits are probably overly generous, but being there were no values
 * before, you need to start someplace.
 */

const uint32 weight_limit[MAX_STAT + 1] = {
   200000,                                      /*  0 */
   250000,  300000,  350000,  400000,  500000,  /*  5 */
   600000,  700000,  800000,  900000, 1000000,  /* 10 */
  1100000, 1200000, 1300000, 1400000, 1500000,  /* 15 */
  1650000, 1800000, 1950000, 2100000, 2250000,  /* 20 */
  2400000, 2550000, 2700000, 2850000, 3000000,  /* 25 */
  3250000, 3500000, 3750000, 4000000, 4500000   /* 30 */
};

const int learn_spell[MAX_STAT + 1] = {
  0, 0, 0, 1, 2, 4, 8, 12, 16, 25, 36, 45, 55, 65, 70, 75, 80, 85, 90, 95, 100, 100, 100, 100, 100,
  100, 100, 100, 100, 100, 100
};

const int cleric_chance[MAX_STAT + 1] = {
  100, 100, 100, 100, 90, 80, 70, 60, 50, 40, 35, 30, 25, 20, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0
};

const int turn_bonus[MAX_STAT + 1] = {
  -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 15
};

const int fear_bonus[MAX_STAT + 1] = {
  3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/*
   Since this is nowhere defined ...
   Both come in handy at least in function add_exp()
*/

#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
 * to make the value of MAX_EXP_CAT close to the
 * actual number of experience objects in the game,
 * otherwise the maximum level in any experience
 * category could be quite low. To help the situation
 * out a little I added 10 more levels, and jacked
 * up the last level experience value. Its out of 
 * line with progression of previous levels, so 
 * if more levels are desired, this should be fixed.
 *  -b.t.
 */

#define MAX_EXP_IN_OBJ MAX_EXP_IN_OBJ / (MAX_EXP_CAT - 1)

#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
 * right thing and always use range within this table.
 * for safety, savethrow should not be accessed directly anymore,
 * and instead did_make_save should be used instead.
 */
static const int savethrow[MAX_SAVE_LEVEL + 1] = {
  18,
  18, 17, 16, 15, 14, 14, 13, 13, 12, 12, 12, 11, 11, 11, 11, 10, 10, 10, 10, 9,
  9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,
  6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};

const char *const attacks[NROFATTACKS] = {
  "physical", "magical", "fire", "electricity", "cold", "confusion",
  "acid", "drain", "weaponmagic", "ghosthit", "poison", "slow",
  "paralyze", "turn undead", "fear", "cancellation", "depletion", "death",
  "chaos", "counterspell", "god power", "holy power", "blinding", "",
  "life stealing"
};

static const char *const drain_msg[NUM_STATS] = {
  "Oh no! You are weakened!",
  "You're feeling clumsy!",
  "You feel less healthy",
  "You suddenly begin to lose your memory!",
  "Watch out, your mind is going!",
  "Your spirit feels drained!",
  "Your face gets distorted!",
};
const char *const restore_msg[NUM_STATS] = {
  "You feel your strength return.",
  "You feel your agility return.",
  "You feel your health return.",
  "You feel your memory return.",
  "You feel your wisdom return.",
  "You feel your spirits return.",
  "You feel your charisma return.",
};
const char *const gain_msg[NUM_STATS] = {
  "You feel stronger.",
  "You feel more agile.",
  "You feel healthy.",
  "You feel smarter.",
  "You feel wiser.",
  "You feel more potent.",
  "You seem to look better.",
};
const char *const lose_msg[NUM_STATS] = {
  "You feel weaker!",
  "You feel clumsy!",
  "You feel less healthy!",
  "You feel stupid!",
  "You lose some of your memory!",
  "You feel less potent!",
  "You look ugly!",
};

const char *const statname[NUM_STATS] = {
  "strength", "dexterity", "constitution", "intelligence", "wisdom", "power", "charisma"
};

const char *const short_stat_name[NUM_STATS] = {
  "Str", "Dex", "Con", "Int", "Wis", "Pow", "Cha"
};

/*
 * Like set_attr_value(), but instead the value (which can be negative)
 * is added to the specified stat.
 */
void
change_attr_value (living *stats, int attr, sint8 value)
{
  stats->stat (attr) += value;
}

/*
 * Ensures that all stats (str/dex/con/wis/cha/int) are within the
 * 1-30 stat limit.
 */
void
check_stat_bounds (living *stats)
{
  for (int i = 0; i < NUM_STATS; i++)
    {
      sint8 &v = stats->stat (i);
      v = clamp (v, MIN_STAT, MAX_STAT);
    }
}

#define ORIG_S(xyz,abc) (op->contr->orig_stats.abc)

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

/* 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.
 * It is the calling functions responsibilty to check to see if the object
 * can be applied or not.
 * The main purpose of calling this function is the messages that are
 * displayed - update_stats should really always be called after this when
 * removing an object - that is because it is impossible to know if some object
 * is the only source of an attacktype or spell attunement, so this function
 * will clear the bits, but the player may still have some other object
 * that gives them that ability.
 */
int
change_abil (object *op, object *tmp)
{
  int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
  int success = 0;
  char message[MAX_BUF];
  int potion_max = 0;

  // keep some stats for comparison purposes
  object::flags_t prev_flag = op->flag;
  MoveType prev_move_type = op->move_type;
  sint16 prev_resist [NROFATTACKS]; // clumsy
  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. 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;
              else if (nstat > 20 + op->arch->stats.stat (j))
                nstat = 20 + op->arch->stats.stat (j);

              if (nstat != ostat)
                {
                  op->contr->orig_stats.stat (j) = nstat;
                  potion_max = 0;
                }
              else if (i)
                {
                  /* potion is useless - player has already hit the natural maximum */
                  potion_max = 1;
                }
            }

          /* This section of code ups the characters normal stats also.  I am not
           * sure if this is strictly necessary, being that fix_player probably
           * recalculates this anyway.
           */
          for (int j = 0; j < NUM_STATS; j++)
            change_attr_value (&op->stats, j, flag * tmp->stats.stat (j));

          check_stat_bounds (&op->stats);
        }                       /* end of potion handling code */
    }

  /* reset attributes that update_stats doesn't reset since it doesn't search
   * everything to set 
   */
  if (flag == -1)
    {
      op->attacktype    &= ~tmp->attacktype;
      op->path_attuned  &= ~tmp->path_attuned;
      op->path_repelled &= ~tmp->path_repelled;
      op->path_denied   &= ~tmp->path_denied;
      /* Presuming here that creatures only have move_type,
       * and not the other move_ fields.
       */
      op->move_type     &= ~tmp->move_type;
    }

  /* call fix_player since op object could have whatever attribute due
   * to multiple items. if update_stats always has to be called after
   * change_ability then might as well call it from here
   */
  op->update_stats ();

  /* update_stats won't add the bows ability to the player, so don't
   * print out message if this is a bow.
   */
  if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW)
    {
      success = 1;
      DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
    }

  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 (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 (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.");
    }

  /* movement type has changed.  We don't care about cases where
   * 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 != 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.");
        }

      if (tmp->move_type & MOVE_FLY_HIGH)
        {
          /* double conditional - second case covers if you have move_fly_low -
           * in that case, you don't actually land
           */
          DIFF_MSG (flag, "You soar into the air!",
                    (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");
    }

  /* becoming UNDEAD... a special treatment for this flag. Only those not
   * originally undead may change their status 
   */
  if (!op->arch->flag [FLAG_UNDEAD])
    if (op->flag [FLAG_UNDEAD] != prev_flag [FLAG_UNDEAD])
      {
        success = 1;
        if (flag > 0)
          {
            op->race = "undead";
            new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
          }
        else
          {
            op->race = op->arch->race;
            new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
          }
      }

  if (op->flag [FLAG_STEALTH] != prev_flag [FLAG_STEALTH])
    {
      success = 1;
      DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
    }

  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 (tmp->flag [FLAG_BLIND])
    {
      success = 1;
      if (flag > 0)
        {
          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.");
              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.");
              op->clr_flag (FLAG_BLIND);
              if (op->type == PLAYER)
                op->contr->do_los = 1;
            }
        }
    }

  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 (op->flag [FLAG_XRAYS] != prev_flag [FLAG_XRAYS])
    {
      success = 1;
      if (flag > 0)
        {
          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 (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)
                op->contr->do_los = 1;
            }
        }
    }

  if (tmp->stats.luck)
    {
      success = 1;
      DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");
    }

  if (digest_types [tmp->type])
    {
      if (tmp->stats.hp && op->type == PLAYER)
        {
          success = 1;
          DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");
        }

      if (tmp->stats.sp && op->type == PLAYER
          && tmp->type != SKILL && tmp->type != BOW)
        {
          success = 1;
          DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");
        }

      /* for the future when artifacts set this -b.t. */
      if (tmp->stats.grace && op->type == PLAYER)
        {
          success = 1;
          DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");
        }

      if (tmp->stats.food && op->type == PLAYER)
        {
          success = 1;
          DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");
        }
    }

  /* Messages for changed resistance */
  for (int i = 0; i < NROFATTACKS; i++)
    {
      if (i == ATNR_PHYSICAL)
        continue;               /* Don't display about armour */

      if (op->resist [i] != prev_resist [i])
        {
          success = 1;

          if (op->resist [i] > prev_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]);

          new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
        }
    }

  if (!potion_max)
    for (int j = 0; j < NUM_STATS; j++)
      if (int i = tmp->stats.stat (j))
        {
          success = 1;
          DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
        }

  return success;
}

/*
 * Stat draining by Vick 930307
 * (Feeling evil, I made it work as well now.  -Frank 8)
 */
void
object::drain_stat ()
{
  drain_specific_stat (rndm (NUM_STATS));
}

void
object::drain_specific_stat (int deplete_stats)
{
  object *tmp;
  archetype *at;

  at = archetype::find (shstr_depletion);
  if (!at)
    {
      LOG (llevError, "Couldn't find archetype depletion.\n");
      return;
    }
  else
    {
      tmp = present_arch_in_ob (at, this);

      if (!tmp)
        {
          tmp = at->instance ();
          tmp = insert_ob_in_ob (tmp, this);
          tmp->set_flag (FLAG_APPLIED);
        }
    }

  new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
  change_attr_value (&tmp->stats, deplete_stats, -1);
  update_stats ();
}

/*
 * A value of 0 indicates timeout, otherwise change the luck of the object.
 * via an applied bad_luck object.
 */
void
object::change_luck (int value)
{
  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 = at->instance ();
          tmp = insert_ob_in_ob (tmp, this);
          tmp->set_flag (FLAG_APPLIED);
        }

      if (value)
        {
          /* Limit the luck value of the bad luck object to +/-100. This
           * (arbitrary) value prevents overflows (both in the bad luck object and
           * in op itself).
           */
          int new_luck = tmp->stats.luck + value;

          if (new_luck >= -100 && new_luck <= 100)
            {
              stats.luck += value;
              tmp->stats.luck = new_luck;
            }
        }
      else
        {
          if (!tmp->stats.luck)
            return;

          /* Randomly change the players luck.  Basically, we move it
           * back neutral (if greater>0, subtract, otherwise add)
           */
          if (rndm (abs (tmp->stats.luck)) >= rndm (30))
            {
              int diff = tmp->stats.luck > 0 ? -1 : 1;

              stats.luck += diff;
              tmp->stats.luck += diff;
            }
        }
    }
}

/*
 * Subtracts stat-bonuses given by the class which the player has chosen.
 */
void
object::remove_statbonus ()
{
  for (int i = 0; i < NUM_STATS; ++i)
    {
      sint8 v = arch->stats.stat (i);
      stats.stat (i)             -= v;
      contr->orig_stats.stat (i) -= v;
    }
}

/*
 * Adds stat-bonuses given by the class which the player has chosen.
 */
void
object::add_statbonus ()
{
  for (int i = 0; i < NUM_STATS; ++i)
    {
      sint8 v = arch->stats.stat (i);
      stats.stat (i)             += v;
      contr->orig_stats.stat (i) += v;
    }
}

static struct copy_flags : object::flags_t
{
  copy_flags ()
  {
    set (FLAG_LIFESAVE);
    set (FLAG_REFL_SPELL);
    set (FLAG_REFL_MISSILE);
    set (FLAG_STEALTH);
    set (FLAG_XRAYS);
    set (FLAG_BLIND);
    set (FLAG_SEE_IN_DARK);
  }
} copy_flags;

/*
 * Updates all abilities given by applied objects in the inventory
 * of the given object.  Note: This function works for both monsters
 * and players; the "player" in the name is purely an archaic inheritance.
 * This functions starts from base values (archetype or player object)
 * and then adjusts them according to what the player has equipped.
 *
 * July 95 - inserted stuff to handle new skills/exp system - b.t.
 * spell system split, grace points now added to system  --peterm
 */
void
object::update_stats ()
{
  float max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
  weight_t weapon_weight = 0;
  int 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;
  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;

      attacktype = 0;

      contr->digestion     = 0;
      contr->gen_hp        = 0;
      contr->gen_sp        = 0;
      contr->gen_grace     = 0;
      contr->gen_sp_armour = 10;
      contr->item_power    = 0;
    }

  for (int i = NUM_BODY_LOCATIONS; i--; )
    slot[i].used = slot[i].info;

  slaying = 0;

  if (!this->flag [FLAG_WIZ])
    {
      this->clr_flag (FLAG_XRAYS);
      this->clr_flag (FLAG_MAKE_INVIS);
    }

  this->clr_flag (FLAG_LIFESAVE);
  this->clr_flag (FLAG_STEALTH);
  this->clr_flag (FLAG_BLIND);

  if (!arch->flag [FLAG_REFL_SPELL  ]) this->clr_flag (FLAG_REFL_SPELL);
  if (!arch->flag [FLAG_REFL_MISSILE]) this->clr_flag (FLAG_REFL_MISSILE);
  if (!arch->flag [FLAG_UNDEAD      ]) this->clr_flag (FLAG_UNDEAD);
  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;
  move_type     = arch->move_type;

  /* 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;
      else
        vuln[i] = -resist[i], prot[i] = 0;

      potion_resist[i] = -1000;
    }

  wc = arch->stats.wc;
  stats.dam = arch->stats.dam;

  /* for players which cannot use armour, they gain AC -1 per 3 levels,
   * plus a small amount of physical resist, those poor suckers. ;) 
   * 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 (!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
    ac = arch->stats.ac;

  stats.luck = arch->stats.luck;
  speed = arch->speed;

  chosen_skill = 0;

  /* OK - we've reset most all the objects attributes to sane values.
   * now go through and make adjustments for what the player has equipped.
   */
  for (tmp = inv; tmp; tmp = tmp->below)
    {
      /* 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 (tmp->flag [FLAG_APPLIED] && tmp->type == POTION)
        continue;

      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. */
          if (IS_MANA_SKILL (tmp->subtype))
            {
              if (!mana_obj)
                mana_obj = tmp;
              else if (tmp->level > mana_obj->level)
                mana_obj = tmp;
            }

          if (IS_GRACE_SKILL (tmp->subtype))
            {
              if (!grace_obj)
                grace_obj = tmp;
              else if (tmp->level > grace_obj->level)
                grace_obj = tmp;
            }
        }

      /* 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, 
       * 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 != SPELL)
          || (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
        {
          if (type == PLAYER)
            {
              contr->item_power += tmp->item_power;

              for (int i = 0; i < NUM_STATS; 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_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 (tmp->flag [FLAG_APPLIED]) // exclude praying...
            for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
              slot[i].used += tmp->slot[i].info;

          if (tmp->type == SYMPTOM)
            min_it (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f); 

          /* 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_EFFECT)
            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;
              else if (tmp->resist[i] < 0)
                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;
              path_attuned  |= tmp->path_attuned;
              path_repelled |= tmp->path_repelled;
              path_denied   |= tmp->path_denied;
              move_type     |= tmp->move_type;
              stats.luck    += tmp->stats.luck;
            }

          flag |= tmp->flag & copy_flags;

          if (tmp->flag [FLAG_UNDEAD] && !arch->flag [FLAG_UNDEAD])
            this->set_flag (FLAG_UNDEAD);

          //TODO: copy_flags?
          if (tmp->flag [FLAG_MAKE_INVIS])
            {
              set_flag (FLAG_MAKE_INVIS);
              invisible = 1;
            }

          if (tmp->stats.exp && tmp->type != SKILL)
            {
              if (tmp->stats.exp > 0)
                {
                  added_speed += tmp->stats.exp / 3.f;
                  bonus_speed += tmp->stats.exp / 3.f + 1.f;
                }
              else
                added_speed += tmp->stats.exp;
            }

          switch (tmp->type)
            {
              case SKILL:
                {
                  // some skills will end up here without counting as "applied"
                  if (!tmp->flag [FLAG_APPLIED] || skill_flags [tmp->subtype] & SF_AUTARK)
                    break;

                  if (chosen_skill)
                    {
                      LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
                           &name, &chosen_skill->name, &tmp->name);

                      tmp->flag [FLAG_APPLIED] = false;
                      update_stats ();
                      return;
                    }

                  chosen_skill = tmp;

                  if (tmp->stats.dam > 0)
                    {             /* skill is a '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->magic)
                        stats.dam += tmp->magic;
                    }

                  if (tmp->stats.wc)
                    wc -= tmp->stats.wc + tmp->magic;

                  if (tmp->slaying)
                    slaying = tmp->slaying;

                  if (tmp->stats.ac)
                    ac -= tmp->stats.ac + tmp->magic;

                  if (settings.spell_encumbrance == TRUE && type == PLAYER)
                    contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);
                }

                break;

              case SHIELD:
                if (settings.spell_encumbrance == TRUE && type == PLAYER)
                  contr->encumbrance += weight_to_kg_approx (tmp->weight) >> 1;
                //FALLTHROUGH
              case RING:
              case AMULET:
              case GIRDLE:
              case HELMET:
              case BOOTS:
              case GLOVES:
              case CLOAK:
                if (tmp->stats.wc)
                  wc -= tmp->stats.wc + tmp->magic;

                if (tmp->stats.dam)
                  stats.dam += tmp->stats.dam + tmp->magic;

                if (tmp->stats.ac)
                  ac -= tmp->stats.ac + tmp->magic;

                break;

              case RANGED:
              case BOW:
              case WEAPON:
                wc -= tmp->stats.wc + tmp->magic;

                if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
                  ac -= tmp->stats.ac + tmp->magic;

                stats.dam += tmp->stats.dam + tmp->magic;
                weapon_weight = tmp->weight;
                weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;

                if (weapon_speed < 0)
                  weapon_speed = 0;

                slaying = tmp->slaying;

                /* If there is desire that two handed weapons should do
                 * extra strength damage, this is where the code should
                 * go.
                 */

                if (type == PLAYER)
                  if (settings.spell_encumbrance)
                    contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);

                break;

              case ARMOUR:     /* Only the best of these three are used: */
                if (settings.spell_encumbrance == TRUE && type == PLAYER)
                  contr->encumbrance += weight_to_kg_approx (tmp->weight);

              case BRACERS:
              case FORCE:
                if (tmp->stats.wc)
                  {
                    if (best_wc < tmp->stats.wc + tmp->magic)
                      {
                        wc += best_wc;
                        best_wc = tmp->stats.wc + tmp->magic;
                      }
                    else
                      wc += tmp->stats.wc + tmp->magic;
                  }

                if (tmp->stats.ac)
                  {
                    if (best_ac < tmp->stats.ac + tmp->magic)
                      {
                        ac += best_ac;  /* Remove last bonus */
                        best_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;

                if (tmp->stats.ac)
                  ac -= tmp->stats.ac + tmp->magic;

                if (ARMOUR_SPEED (tmp))
                  min_it (max_speed, ARMOUR_SPEED (tmp) / 10.f);

                break;
            }                   /* switch tmp->type */
        }                       /* item is equipped */
    }                           /* for loop of items */

  min_it (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.
   */

  /* 'total resistance = total protections - total vulnerabilities'.
   * If there is an uncursed potion in effect, granting more protection
   * than that, we take: 'total resistance = resistance from potion'.
   * If there is a cursed (and no uncursed) potion in effect, we take
   * 'total resistance = vulnerability from cursed potion'. 
   */
  for (int i = 0; i < NROFATTACKS; i++)
    {
      resist[i] = prot[i] - vuln[i];

      if (potion_resist[i] != -1000
          && (potion_resist[i] < 0 || potion_resist[i] > resist[i]))
        resist[i] = potion_resist[i];
    }

  if (type == PLAYER)
    {
      // clamp various player stats
      for (int i = 0; i < NUM_STATS; ++i)
        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;

      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;
      for (int i = 1; i <= min (10, pl_level); i++)
        {
          int j = contr->levhp[i] + con_bonus[stats.Con] / 2;

          if (i % 2 && con_bonus[stats.Con] % 2)
            if (con_bonus[stats.Con] > 0)
              j++;
            else
              j--;

          stats.maxhp += j > 1 ? j : 1;     /* always get at least 1 hp/level */
        }

      stats.maxhp += 2 * max (0, level - 10);

      if (stats.hp > stats.maxhp)
        stats.hp = stats.maxhp;

      /* Sp gain is controlled by the level of the player's 
       * relevant experience object (mana_obj, see above) 
       */
      /* following happen when skills system is not used */
      if (!mana_obj)
        mana_obj = this;

      if (!grace_obj)
        grace_obj = this;

      /* set maxsp */
      if (!mana_obj || !mana_obj->level || type != PLAYER)
        mana_obj = this;

      if (mana_obj == this && type == PLAYER)
        stats.maxsp = 1;
      else
        {
          float sp_tmp = 0.f;
 
          for (int i = 1; i <= min (10, mana_obj->level); i++)
            {
              float stmp;

              /* Got some extra bonus at first level */
              if (i < 2)
                stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) /  6.f;
              else
                stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;

              sp_tmp += max (1.f, stmp);
            }

          stats.maxsp = int (sp_tmp) + 2 * max (0, mana_obj->level - 10);
        }

      /* Characters can get their sp supercharged via rune of transferrance */
      stats.sp = min (stats.sp, stats.maxsp * 2);

      /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
      if (!grace_obj || !grace_obj->level || type != PLAYER)
        grace_obj = this;

      if (grace_obj == this && type == PLAYER)
        stats.maxgrace = 1;
      else
        {
          /* store grace in a float - this way, the divisions below don't create
           * big jumps when you go from level to level - with int's, it then
           * becomes big jumps when the sums of the bonuses jump to the next
           * step of 8 - with floats, even fractional ones are useful.
           */
          float sp_tmp = 0.f;

          for (int i = 1; i <= min (10, grace_obj->level); i++)
            {
              float grace_tmp = 0.f;

              /* Got some extra bonus at first level */
              if (i < 2)
                grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) /  6.f;
              else
                grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;

              sp_tmp += max (1.f, grace_tmp);
            }

          /* two grace points per level after 10 */
          stats.maxgrace = int (sp_tmp) + 2 * max (0, grace_obj->level - 10);
        }

      /* No limit on grace vs maxgrace */

      if (contr->braced)
        {
          ac += 2;
          wc += 4;
        }
      else
        ac -= dex_bonus[stats.Dex];

      /* In new exp/skills system, wc bonuses are related to 
       * the players level in a relevant exp object (wc_obj)
       * not the general player level -b.t. 
       * I changed this slightly so that wc bonuses are better
       * than before. This is to balance out the fact that 
       * the player no longer gets a personal weapon w/ 1
       * improvement every level, now its fighterlevel/5. So
       * we give the player a bonus here in wc and dam
       * to make up for the change. Note that I left the 
       * monster bonus the same as before. -b.t.
       */
      object *wc_obj = chosen_skill;

      if (contr && wc_obj && wc_obj->level > 1)
        {
          wc -= wc_obj->level + thaco_bonus[stats.Str];

          for (int i = 1; i < wc_obj->level; i++)
            {
              /* additional wc every 6 levels */
              if (!(i % 6))
                wc--;

              /* additional dam every 4 levels. */
              if (!(i % 4) && dam_bonus[stats.Str] >= 0)
                stats.dam += 1 + dam_bonus[stats.Str] / 5;
            }
        }
      else
        wc -= level + thaco_bonus[stats.Str];

      stats.dam += dam_bonus[stats.Str];

      if (stats.dam < 1)
        stats.dam = 1;

      speed = 1.f + speed_bonus[stats.Dex];

      if (settings.search_items && contr->search_str[0])
        speed -= 1;
    }                           /* End if player */

  if (added_speed >= 0)
    speed += added_speed / 10.f;
  else                          /* Something wrong here...: */
    speed /= 1.f - added_speed;

  /* Max is determined by armour */
  speed = min (speed, max_speed);

  if (type == PLAYER)
    {
      /* 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
       */
      float f = (sint32)weight_to_kg_approx (carrying) - max_carry[stats.Str];
      if (f > 0.f)
        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
   * 25 ticks or so. This amounts to once every 3 seconds of realtime.
   */
  max_it (speed, is_player () ? MIN_PLAYER_SPEED : MIN_ACTIVE_SPEED);

  if (speed != old_speed)
    set_speed (speed);

  if (type == PLAYER)
    {
      /* (This formula was made by vidarl@ifi.uio.no)
       * Note that we never used these values again - basically
       * all of these could be subbed into one big equation, but
       * that would just be a real pain to read.
       */
      float M = (max_carry[stats.Str] - 121) / 121.f;
      float M2 = max_carry[stats.Str] / 100.f;
      float W = weapon_weight / 20000.f;
      float s = (20 - weapon_speed) / 10.f;
      float D = (stats.Dex - 14) / 14.f;
      float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f;

      K *= (4 + level) * 1.2f / (6 + level);

      if (K <= 0.01f)
        K = 0.01f;

      contr->weapon_sp = K * s * .5f; //TODO: balance the .5
    }

  /* I want to limit the power of small monsters with big weapons: */
  if (type != PLAYER && arch && stats.dam > arch->stats.dam * 3)
    stats.dam = arch->stats.dam * 3;

  stats.wc = clamp (wc, MIN_WC, MAX_WC);
  stats.ac = clamp (ac, MIN_AC, MAX_AC);

  /* if for some reason the creature doesn't have any move type,
   * give them walking as a default.
   * The second case is a special case - to more closely mimic the
   * old behaviour - if your flying, your not walking - just
   * one or the other.
   */
  if (move_type == 0)
    move_type = MOVE_WALK;
  else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
    move_type &= ~MOVE_WALK;

  // now apply the new move_type
  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 (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);
    }
}

/*
 * 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)
 */
void
set_dragon_name (object *pl, const object *abil, const object *skin)
{
  int atnr = -1;                /* attacknumber of highest level */
  int level = 0;                /* highest level */
  int i;

  /* Perhaps do something more clever? */
  if (!abil || !skin)
    return;

  /* first, look for the highest level */
  for (i = 0; i < NROFATTACKS; i++)
    {
      if (atnr_is_dragon_enabled (i) && (atnr == -1 || abil->resist[i] > abil->resist[atnr]))
        {
          level = abil->resist[i];
          atnr = i;
        }
    }

  /* 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;

  /* now set the new title */
  if      (level <  25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
  else if (level <  50) sprintf (pl->contr->title, "%s wyrm"     , attacks[atnr]);
  else if (level <  75) sprintf (pl->contr->title, "%s wyvern"   , attacks[atnr]);
  else if (level < 100) sprintf (pl->contr->title, "%s dragon"   , attacks[atnr]);
  else
    {
      /* special titles for extra high resistance! */
      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                              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.
 */
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 */
  char buf[MAX_BUF];            /* tmp. string buffer */

  /* now grab the 'dragon_ability'-forces from the player's inventory */
  for (tmp = who->inv; tmp; tmp = tmp->below)
    if (tmp->type == FORCE)
      if (tmp->arch->archname == shstr_dragon_ability_force)
        abil = tmp;
      else if (tmp->arch->archname == shstr_dragon_skin_force)
        skin = tmp;

  /* if the force is missing -> bail out */
  if (abil == NULL)
    return;

  /* The ability_force keeps track of maximum level ever achieved.
   * New abilties can only be gained by surpassing this max level 
   */
  if (who->level > abil->level)
    {
      /* increase our focused ability */
      abil->resist[abil->stats.exp]++;


      if (abil->resist[abil->stats.exp] > 0 && abil->resist[abil->stats.exp] % 5 == 0)
        {
          /* time to hand out a new ability-gift */
          dragon_ability_gain (who, (int) abil->stats.exp, (int) ((1 + abil->resist[abil->stats.exp]) / 5.));
        }

      if (abil->last_eat > 0 && atnr_is_dragon_enabled (abil->last_eat))
        {
          /* apply new ability focus */
          sprintf (buf, "Your metabolism now focuses on %s!", change_resist_msg[abil->last_eat]);
          new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, buf);

          abil->stats.exp = abil->last_eat;
          abil->last_eat = 0;
        }

      abil->level = who->level;
    }

  /* last but not least, set the new title for the dragon */
  set_dragon_name (who, abil, skin);
}

/* Handy function - given the skill name skill_name, we find the skill
 * archetype/object, set appropriate values, and insert it into
 * the object (op) that is passed.
 * We return the skill - this makes it easier for calling functions that
 * want to do something with it immediately.
 */
object *
give_skill_by_name (object *op, const char *skill_name)
{
  object *skill_obj;

  skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
  if (!skill_obj)
    {
      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.
   */
  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)
    pl->link_skills ();

  return skill_obj;
}

/* player_lvl_adj() - for the new exp system. we are concerned with
 * whether the player gets more hp, sp and new levels.
 * Note this this function should only be called for players.  Monstes
 * don't really gain levels
 * who is the player, op is what we are checking to gain the level
 * (eg, skill)
 */
void
player_lvl_adj (object *who, object *op)
{
  char buf[MAX_BUF];
  bool changed = false;

  if (!op)                      /* when rolling stats */
    op = who;

  while (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
    {
      changed = true;

      op->level++;

      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)
        {
          who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
          who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
          who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
        }

      if (op->level > 1)
        {
          if (op->type != PLAYER)
            {
              who->contr->play_sound (sound_find ("skill_up"));
              sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
            }
          else
            {
              who->contr->play_sound (sound_find ("level_up"));
              sprintf (buf, "You are now level %d.", op->level);
            }

          if (who)
            new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
        }
    }

  while (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
    {
      changed = true;

      op->level--;

      if (op->type != PLAYER)
        {
          sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
          new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
        }
    }

  if (changed)
    who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
}

/*
 * Returns how much experience is needed for a player to become
 * the given level.  level should really never exceed max_level
 */

sint64
level_exp (int level, double expmul)
{
  return expmul * level_to_min_exp (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
 * proper range.  Note that the checking of what is passed through
 * has been reduced.  Since there is now a proper field for perm_exp,
 * this can now work on a much larger set of objects.
 */
void
calc_perm_exp (object *op)
{
  int p_exp_min;

  /* Ensure that our permanent experience minimum is met.
   * permenent_exp_ratio is an integer percentage, we divide by 100 
   * to get the fraction   */
  p_exp_min = (int) (settings.permanent_exp_ratio * (float) (op->stats.exp) / 100);

  if (op->perm_exp < p_exp_min)
    op->perm_exp = p_exp_min;

  /* Cap permanent experience. */
  if (op->perm_exp < 0)
    op->perm_exp = 0;
  else if (op->perm_exp > (sint64) MAX_EXPERIENCE)
    op->perm_exp = MAX_EXPERIENCE;
}

/* Add experience to a player - exp should only be positive.
 * Updates permanent exp for the skill we are adding to.
 * skill_name is the skill to add exp to.  Skill name can be
 *   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, shstr_tmp skill_name, int flag)
{
  object *skill_obj;
  sint64 limit, exp_to_add;

  /* prevents some forms of abuse. */
  if (op->contr->braced)
    exp /= 5;

  /* 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)
    {
      skill_obj = op->contr->find_skill (skill_name);

      /* Player doesn't have the skill.  Check to see what to do, and give
       * it to the player if necessary
       */
      if (!skill_obj)
        {
          if (flag == SK_EXP_NONE)
            return;

          if (flag == SK_EXP_ADD_SKILL)
            skill_obj = give_skill_by_name (op, skill_name);
        }
    }

  if (flag != SK_EXP_SKILL_ONLY)
    {
      /* 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;
      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)
        {
          ADD_EXP (op->perm_exp, (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO * (skill_obj ? skill_obj->expmul : 1)));
          calc_perm_exp (op);
        }

      player_lvl_adj (op, NULL);
    }

  if (skill_obj)
    {
      exp_to_add = exp;
      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)
        {
          skill_obj->perm_exp += (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO);
          calc_perm_exp (skill_obj);
        }

      player_lvl_adj (op, skill_obj);
    }
}

/* This function checks to make sure that object 'op' can
 * 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.
 */
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);
}

/* 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
 * skills the player has.  Eg, if we figure the player is losing 10%
 * of his total exp, what happens is he loses 10% from all his skills.
 * Note that if permanent exp is used, player may not in fact lose
 * as much as listed.  Eg, if player has gotten reduced to the point
 * 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, 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 && 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, tmp->stats.exp * fraction);
            tmp->stats.exp -= del_exp;
            player_lvl_adj (op, tmp);
          }
      }

  if (flag != SK_SUBTRACT_SKILL_EXP)
    {
      del_exp = check_exp_loss (op, exp);
      op->stats.exp -= del_exp;
      player_lvl_adj (op, NULL);
    }
}

/* change_exp() - changes experience to a player/monster.  This
 * does bounds checking to make sure we don't overflow the max exp.
 *
 * The exp passed is typically not modified much by this function -
 * it is assumed the caller has modified the exp as needed.
 * 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, shstr_tmp skill_name, int flag)
{
#ifdef EXP_DEBUG
  LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
#endif

  /* safety */
  if (!op)
    {
      LOG (llevError, "change_exp() called for null object!\n");
      return;
    }

  /* if no change in exp, just return - most of the below code
   * won't do anything if the value is 0 anyways.
   */
  if (exp == 0)
    return;

  /* Monsters are easy - we just adjust their exp - we   
   * don't adjust level, since in most cases it is unrelated to
   * the exp they have - the monsters exp represents what its
   * worth.
   */
  if (op->type != PLAYER)
    {
      /* Sanity check */
      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.
       */
      if (exp > 0 && (op->stats.exp > (sint64) (MAX_EXPERIENCE - exp)))
        {
          exp = MAX_EXPERIENCE - op->stats.exp;
          if (exp < 0)
            return;
        }

      op->stats.exp += exp;
    }
  else
    {                           /* Players only */
      if (exp > 0)
        add_player_exp (op, exp, skill_name, flag);
      else
        /* note that when you lose exp, it doesn't go against
         * a particular skill, so we don't need to pass that
         * along.
         */
        subtract_player_exp (op, abs (exp), skill_name, flag);
    }
}

/* Applies a death penalty experience, the size of this is defined by the 
 * settings death_penalty_percentage and death_penalty_levels, and by the
 * amount of permenent experience, whichever gives the lowest loss.
 */
void
apply_death_exp_penalty (object *op)
{
  sint64 loss;
  sint64 percentage_loss;       /* defined by the setting 'death_penalty_percent' */
  sint64 level_loss;            /* defined by the setting 'death_penalty_levels */

  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)];

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

        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)];

  if (level_loss < 0)
    level_loss = 0;

  loss = check_exp_loss (op, min (level_loss, percentage_loss));

  op->stats.exp -= loss;
  player_lvl_adj (op, NULL);
}

/* This function takes an object (monster/player, op), and
 * determines if it makes a basic save throw by looking at the
 * save_throw table.  level is the effective level to make
 * the save at, and bonus is any plus/bonus (typically based on
 * resistance to particular attacktype.
 * Returns 1 if op makes his save, 0 if he failed
 */
int
did_make_save (const object *op, int level, int bonus)
{
  if (level > MAX_SAVE_LEVEL)
    level = MAX_SAVE_LEVEL;

  if ((random_roll (1, 20, op, PREFER_HIGH) + bonus) < savethrow[level])
    return 0;

  return 1;
}
Revision:	1.132
Committed:	Wed Nov 16 23:41:59 2016 UTC (7 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.131:	+1 -1 lines
Log Message:	copyright update 2016