server/server/shop.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#include <global.h>
#include <spells.h>
#include <skills.h>
#include <living.h>
#include <sproto.h>
#include <math.h>

/* this is a measure of how effective store specialisation is. A general store
 * will offer this proportion of the 'maximum' price, a specialised store will
 * offer a range of prices around it such that the maximum price is always one
 * therefore making this number higher, makes specialisation less effective. 
 * setting this value above 1 or to a negative value would have interesting,
 * (though not useful) effects.
 */
#define SPECIALISATION_EFFECT .5

// price a shopkeeper will give someone that is not of their race
#define DISLIKE_RATIO 0.8

static void pay_from_container (object *pl, object *pouch, sint64 &to_pay);
static sint64 value_limit (sint64 val, int quantity, const object *who, int isshop);
static double shop_specialisation_ratio (const object *item, const maptile *map);
static double shop_greed (const maptile *map);

/* Added F_TRUE flag to define.h to mean that the price should not
 * be adjusted by players charisma. With F_TRUE, it returns the amount
 * that the item is worth, if it was sold, but unadjusted by charisma.
 * This is needed for alchemy, to to determine what value of gold nuggets
 * should be given (the gold nuggets, when sold, will have the adjustment
 * by charisma done at that time).  NULL could have been passed as the
 * who parameter, but then the adjustment for expensive items (>10000)
 * would not be done.
 *
 * Added F_APPROX flag, which means that the price returned should be wrong by
 * an amount related to the player's bargaining skill.
 *
 * Added F_SHOP flag to mean that the specialisation of the shop on the player's 
 * current map should be taken into account when determining the price. Shops that
 * specialise in what is being traded will give better prices than those that do not. 
 *
 * CF 0.91.4 - This function got changed around a bit.  Now the
 * number of object is multiplied by the value early on.  This fixes problems
 * with items worth very little.  What happened before is that various
 * divisions took place, the value got rounded to 0 (Being an int), and
 * thus remained 0.
 *
 * Mark Wedel (mwedel@pyramid.com)
 */

static sint64 approx_range;

sint64
query_cost (const object *tmp, object *who, int flag)
{
  double val;
  int number;                   /* used to better calculate value */
  int no_bargain;
  int identified;
  int not_cursed;
  int approximate;
  int shop;
  double diff;

  approx_range = 0;

  no_bargain = flag & F_NO_BARGAIN;
  identified = flag & F_IDENTIFIED;
  not_cursed = flag & F_NOT_CURSED;
  approximate = flag & F_APPROX;
  shop = flag & F_SHOP;
  flag &= ~(F_NO_BARGAIN | F_IDENTIFIED | F_NOT_CURSED | F_APPROX | F_SHOP);

  if (tmp->type == MONEY)
    return tmp->nrof * tmp->value;

  if (tmp->type == GEM)
    {
      if (flag == F_TRUE)
        return (tmp->nrof * tmp->value);

      if (flag == F_BUY)
        return (sint64) (1.03 * tmp->nrof * tmp->value);

      if (flag == F_SELL)
        return (sint64) (0.97 * tmp->nrof * tmp->value);

      LOG (llevError, "Query_cost: Gem type with unknown flag %d: %s\n", flag, tmp->debug_desc ());
      return 0;
    }

  number = tmp->nrof;
  if (number == 0)
    number = 1;
  if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)
    {
      if (!not_cursed && (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
        return 0;
      else
        val = tmp->value * number;
    }
  /* This area deals with objects that are not identified, but can be */
  else
    {
      if (tmp->arch != NULL)
        {
          if (flag == F_BUY)
            {
              LOG (llevError, "Asking for buy-value of unidentified object.\n");
              val = tmp->arch->value * 50 * number;
            }
          else
            {                   /* Trying to sell something, or get true value */
              if (tmp->type == POTION)
                val = number * 40;      /* Don't want to give anything away */
              else
                {
                  /* Get 2/3'rd value for applied objects, 1/3'rd for totally
                   * unknown objects
                   */
                  if (QUERY_FLAG (tmp, FLAG_BEEN_APPLIED))
                    val = number * tmp->arch->value * 2 / 3;
                  else
                    val = number * tmp->arch->value / 3;
                }
            }
        }
      else
        {                       /* No archetype with this object */
          LOG (llevDebug, "In sell item: Have object with no archetype: %s\n", &tmp->name);
          if (flag == F_BUY)
            {
              LOG (llevError, "Asking for buy-value of unidentified object without arch.\n");
              val = number * tmp->value * 10;
            }
          else
            val = number * tmp->value / 5;
        }
    }

  /* If the item has been applied or identifed or does not need to be
   * identified, AND the object is magical and the archetype is non
   * magical, then change values accordingly.  The tmp->arch==NULL is
   * really just a check to prevent core dumps for when it checks
   * tmp->arch->magic for any magic.  The check for archetype
   * magic is to not give extra money for archetypes that are by
   * default magical.  This is because the archetype value should have
   * already figured in that value.
   */
  if ((QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified ||
       QUERY_FLAG (tmp, FLAG_BEEN_APPLIED)) && tmp->magic && (tmp->arch == NULL || !tmp->arch->magic))
    {
      if (tmp->magic > 0)
        val *= (3 * tmp->magic * tmp->magic * tmp->magic);
      else
        /* Note that tmp->magic is negative, so that this
         * will actually be something like val /=2, /=3, etc.
         */
        val /= (1 - tmp->magic);
    }

  if (tmp->type == WAND)
    {
      /* Value of the wand is multiplied by the number of
       * charges.  the treasure code already sets up the value
       * 50 charges is used as the baseline.
       */
      if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)
        val = (val * tmp->stats.food) / 50;
      else                      /* if not identified, presume one charge */
        val /= 50;
    }

  /* Limit amount of money you can get for really great items. */
  if (flag == F_SELL)
    val = value_limit ((sint64) val, number, who, shop);

  // use a nonlinear price adjustment. as my predecessor said, don't change
  // the archetypes, its work required for balancing, and we don't care.
  //val = pow (val, 1.05);

  /* This modification is for bargaining skill.
   * Now only players with max level in bargaining
   * AND Cha = 30 will get optimal price.
   * Thus charisma will never get useless.
   * -b.e. edler@heydernet.de
   */

  if (who != NULL && who->type == PLAYER)
    {
      int lev_bargain = 0;
      int lev_identify = 0;
      int idskill1 = 0;
      int idskill2 = 0;
      const typedata *tmptype;

      tmptype = get_typedata (tmp->type);

      if (find_skill_by_number (who, SK_BARGAINING))
        lev_bargain = find_skill_by_number (who, SK_BARGAINING)->level;

      if (tmptype)
        {
          idskill1 = tmptype->identifyskill;

          if (idskill1)
            {
              idskill2 = tmptype->identifyskill2;

              if (find_skill_by_number (who, idskill1))
                lev_identify = find_skill_by_number (who, idskill1)->level;

              if (idskill2 && find_skill_by_number (who, idskill2))
                lev_identify += find_skill_by_number (who, idskill2)->level;
            }
        }
      else
        LOG (llevError, "Query_cost: item %s hasn't got a valid type\n", tmp->debug_desc ());

      /* ratio determines how much of the price modification
       * will come from the basic stat charisma
       * the rest will come from the level in bargaining skill
       */
      const double cha_ratio = 0.40;

      diff = no_bargain ? 1.0 : 1. - pow (lev_bargain / (double) settings.max_level, 0.25);
      diff = (1. - cha_ratio) * diff + cha_ratio * (cha_bonus[who->stats.Cha] - 1.) / (cha_bonus[who->stats.Cha] + 1.);
      diff = .02 + (.80 - .02) * diff;

      if (flag == F_BUY)
        val += val * diff;
      else if (flag == F_SELL)
        val -= val * diff;

      // now find a price range. the less good we can judge, the larger the range is
      // then the range is adjusted randomly around the correct value
      if (approximate)
        approx_range = sint64 (val / sqrt (lev_identify * 3 + 1));
    }

  /* I don't think this should really happen - if it does, it indicates and
   * overflow of diff above.  That should only happen if
   * we are selling objects - in that case, the person just
   * gets no money.
   */
  if ((sint64) val < 0)
    val = 0;

  /* Unidentified stuff won't sell for more than 60gp */
  if (flag == F_SELL && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && need_identify (tmp) && !identified)
    {
      val = (val > 600) ? 600 : val;
    }

  /* if we are in a shop, check how the type of shop should affect the price */
  if (shop && who)
    {
      if (flag == F_SELL)
        val = (val * shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who) / shop_greed (who->map));
      else if (flag == F_BUY)
        {
          /* 
           * when buying, if the item was sold by another player, it is ok to
           * let the item be sold cheaper, according to the specialisation of
           * the shop. If a player sold an item here, then his sale price was
           * multiplied by the specialisation ratio, to do the same to the buy 
           * price will not generate extra money. However, the 
           * same is not true of generated items, these have to /divide/ by the 
           * specialisation, so that the price is never less than what they could
           * be sold for (otherwise players could camp map resets to make money).
           * In game terms, a non-specialist shop, might not recognise the true 
           * value of the items they sell (much like how people sometimes find 
           * antiques in a junk shop in real life).
           */
          if (QUERY_FLAG (tmp, FLAG_PLAYER_SOLD))
            val = (val * shop_greed (who->map) * shop_specialisation_ratio (tmp, who->map) / shopkeeper_approval (who->map, who));
          else
            val = (val * shop_greed (who->map) / (shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who)));
        }

      /* we will also have an extra 0-5% variation between shops of the same type 
       * for valuable items (below a value of 50 this effect wouldn't be very 
       * pointful, and could give fun with rounding.
       */
      //TODO: why use cosf at all, just % and scale linearly, gives more even distribution
      if (val > 50)
        val += float (val) * .05f * cosf ((tmp->uuid.seq & 0xffff) * float (M_PI * 2. / 0x10000));
    }

  return (sint64) val;
}

/* Find the coin type that is worth more the 'c'.  Starts at the
 * cointype placement.
 */

static archetype *
find_next_coin (sint64 c, int *cointype)
{
  archetype *coin;

  do
    {
      if (coins[*cointype] == NULL)
        return NULL;
      coin = archetype::find (coins[*cointype]);
      if (coin == NULL)
        return NULL;
      *cointype += 1;
    }
  while (coin->value > c);

  return coin;
}

/* This returns a string of how much something is worth based on
 * an integer being passed.
 * cost is the cost we need to represent.
 * While cost is 64 bit, the number of any coin is still really
 * limited to 32 bit (size of nrof field).  If it turns out players
 * have so much money that they have more than 2 billion platinum
 * coins, there are certainly issues - the easiest fix at that
 * time is to add a higher denomination (mithril piece with
 * 10,000 silver or something)
 */
const char *
cost_string_from_value (sint64 cost, int approx)
{
  static char buf[MAX_BUF];
  archetype *coin, *next_coin;
  int num, cointype = 0;

  coin = find_next_coin (cost, &cointype);
  if (coin == NULL)
    return "nothing";

  num = cost / coin->value;
  /* so long as nrof is 32 bit, this is true.
   * If it takes more coins than a person can possibly carry, this
   * is basically true.
   */
  if ((cost / coin->value) > UINT32_MAX)
    {
      strcpy (buf, "an unimaginable sum of money");
      return buf;
    }

  cost -= num * (sint64)coin->value;

  sprintf (buf, "%d %s", num, num > 1 ? &coin->object::name_pl : &coin->object::name);

  next_coin = find_next_coin (cost, &cointype);
  if (next_coin == NULL || approx)
    return buf;

  coin = next_coin;
  num = cost / coin->value;
  cost -= num * (sint64)coin->value;

  sprintf (buf + strlen (buf), " and %d %s", num, num > 1 ? &coin->object::name_pl : &coin->object::name);

  return buf;
}

const char *
query_cost_string (const object *tmp, object *who, int flag)
{
  sint64 real_value = query_cost (tmp, who, flag);
  int idskill1 = 0;
  int idskill2 = 0;
  const typedata *tmptype;

  tmptype = get_typedata (tmp->type);
  if (tmptype)
    {
      idskill1 = tmptype->identifyskill;
      idskill2 = tmptype->identifyskill2;
    }

  /* we show an approximate price if
   * 1) we are approximating
   * 2) there either is no id skill(s) for the item, or we don't have them
   * 3) we don't have bargaining skill either
   */
  if (flag & F_APPROX)
    {
      if (!idskill1 || !find_skill_by_number (who, idskill1))
        {
          if (!idskill2 || !find_skill_by_number (who, idskill2))
            {
              if (!find_skill_by_number (who, SK_BARGAINING))
                {
                  static char buf[MAX_BUF];
                  int num, cointype = 0;
                  archetype *coin = find_next_coin (real_value, &cointype);

                  if (coin == NULL)
                    return "nothing";

                  num = real_value / coin->value;
                  if (num == 1)
                    sprintf (buf, "about one %s", &coin->object::name);
                  else if (num < 5)
                    sprintf (buf, "a few %s", &coin->object::name_pl);
                  else if (num < 10)
                    sprintf (buf, "several %s", &coin->object::name_pl);
                  else if (num < 25)
                    sprintf (buf, "a moderate amount of %s", &coin->object::name_pl);
                  else if (num < 100)
                    sprintf (buf, "lots of %s", &coin->object::name_pl);
                  else if (num < 1000)
                    sprintf (buf, "a great many %s", &coin->object::name_pl);
                  else
                    sprintf (buf, "a vast quantity of %s", &coin->object::name_pl);
                  return buf;
                }
            }
        }

      int hash = ((unsigned int) tmp->count * 174364621) & 1023;

      if (approx_range)
        {
          sint64 lo = (sint64) real_value - (approx_range * hash >> 10);
          static char buf[MAX_BUF];

          sprintf (buf, "between %s", cost_string_from_value (lo, 1));
          sprintf (buf + strlen (buf), " and %s", cost_string_from_value (lo + approx_range, 1));

          return buf;
        }
    }

  return cost_string_from_value (real_value, 0);
}

/* This function finds out how much money the player is carrying,
 * including what is in containers.
 */
sint64
query_money (const object *op)
{
  object *tmp;
  sint64 total = 0;

  if (op->type != PLAYER && op->type != CONTAINER)
    {
      LOG (llevError, "Query money called with non player/container\n");
      return 0;
    }

  for (tmp = op->inv; tmp; tmp = tmp->below)
    if (tmp->type == MONEY)
      total += tmp->nrof * (sint64)tmp->value;
    else if (tmp->type == CONTAINER && QUERY_FLAG (tmp, FLAG_APPLIED) && (tmp->race == NULL || strstr (tmp->race, "gold")))
      total += query_money (tmp);

  return total;
}

/* TCHIZE: This function takes the amount of money from the
 * the player inventory and from it's various pouches using the
 * pay_from_container function.
 * returns 0 if not possible. 1 if success
 */
int
pay_for_amount (sint64 to_pay, object *pl)
{
  object *pouch;

  if (to_pay == 0)
    return 1;

  if (to_pay > query_money (pl))
    return 0;

  pay_from_container (pl, pl, to_pay);

  for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
    if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (pouch->race == NULL || strstr (pouch->race, "gold")))
      pay_from_container (pl, pouch, to_pay);

  pl->update_stats ();
  return 1;
}

/* DAMN: This is now a wrapper for pay_from_container, which is
 * called for the player, then for each active container that can hold
 * money until op is paid for.  Change will be left wherever the last
 * of the price was paid from.
 */
int
pay_for_item (object *op, object *pl)
{
  sint64 to_pay = query_cost (op, pl, F_BUY | F_SHOP);
  object *pouch;
  sint64 saved_money;

  if (to_pay == 0)
    return 1;

  if (to_pay > query_money (pl))
    return 0;

  /* We compare the paid price with the one for a player
   * without bargaining skill.
   * This determins the amount of exp (if any) gained for bargaining.
   */
  saved_money = query_cost (op, pl, F_BUY | F_NO_BARGAIN | F_SHOP) - to_pay;

  if (saved_money > 0)
    change_exp (pl, saved_money, "bargaining", SK_EXP_NONE);

  pay_from_container (pl, pl, to_pay);

  for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
    if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (pouch->race == NULL || strstr (pouch->race, "gold")))
      pay_from_container (pl, pouch, to_pay);

  pl->update_stats ();

  return 1;
}

/* This pays for the item, and takes the proper amount of money off
 * the player.
 * CF 0.91.4 - this function is mostly redone in order to fix a bug
 * with weight not be subtracted properly.  We now remove and
 * insert the coin objects -  this should update the weight
 * appropriately
 *
 * DAMN: This function is used for the player, then for any active
 * containers that can hold money.
 *
 * pouch is the container (pouch or player) to remove the coins from.
 * to_pay is the required amount.
 * returns the amount still missing after using "pouch".
 */
static void
pay_from_container (object *pl, object *pouch, sint64 &to_pay)
{
  int count, i;
  object *tmp, *next;
  archetype *at;

  if (pouch->type != PLAYER && pouch->type != CONTAINER)
    return;

  object *coin_objs[NUM_COINS] = { 0 };

  /* This hunk should remove all the money objects from the player/container */
  for (tmp = pouch->inv; tmp; tmp = next)
    {
      next = tmp->below;

      if (tmp->type == MONEY)
        {
          for (i = 0; i < NUM_COINS; i++)
            {
              if (tmp->value == tmp->arch->value && !strcmp (coins[NUM_COINS - 1 - i], tmp->arch->archname))
                {
                  // This should not happen, but if it does, just merge the two.
                  if (coin_objs [i])
                    {
                      LOG (llevError, "%s has two money entries of (%s)\n", &pouch->name, coins[NUM_COINS - 1 - i]);
                      tmp->remove ();
                      coin_objs[i]->nrof += tmp->nrof;
                      esrv_del_item (pl->contr, tmp->count);
                      tmp->destroy ();
                    }
                  else
                    {
                      tmp->remove ();

                      if (pouch->type == PLAYER)
                        esrv_del_item (pl->contr, tmp->count);

                      coin_objs[i] = tmp;
                    }

                  break;
                }
            }

          if (i == NUM_COINS)
            LOG (llevError, "in pay_for_item: Did not find string match for %s\n", &tmp->arch->archname);
        }
    }

  /* Fill in any gaps in the coin_objs array - needed to make change. */
  /* Note that the coin_objs array goes from least value to greatest value */
  for (i = 0; i < NUM_COINS; i++)
    if (!coin_objs[i])
      {
        at = archetype::find (coins[NUM_COINS - 1 - i]);

        if (at == NULL)
          LOG (llevError, "Could not find %s archetype\n", coins[NUM_COINS - 1 - i]);

        coin_objs[i] = arch_to_object (at);
        coin_objs[i]->nrof = 0;
      }

  for (i = 0; i < NUM_COINS; i++)
    {
      object &coin = *coin_objs[i];
      sint64 num_coins = min ((to_pay + coin.value - 1) / coin.value, coin.nrof);
      to_pay -= num_coins * coin.value;

      coin.nrof -= num_coins;
      /* Now start making change.  Start at the coin value
       * below the one we just did, and work down to
       * the lowest value.
       */
      count = i - 1;

      while (to_pay < 0 && count >= 0)
        {
          num_coins = (-to_pay) / coin_objs[count]->value;
          coin_objs[count]->nrof += num_coins;
          to_pay += num_coins * coin_objs[count]->value;
          count--;
        }
    }

  for (i = 0; i < NUM_COINS; i++)
    {
      if (coin_objs[i]->nrof)
        {
          object *tmp = insert_ob_in_ob (coin_objs[i], pouch);

          esrv_send_item (pl, tmp);
          esrv_send_item (pl, pouch);

          if (pl != pouch)
            esrv_update_item (UPD_WEIGHT, pl, pouch);

          if (pl->type != PLAYER)
            esrv_send_item (pl, pl);
        }
      else
        coin_objs[i]->destroy ();
    }
}

/* Checks all unpaid items in op's inventory, adds up all the money they
 * have, and checks that they can actually afford what they want to buy.
 * Returns 1 if they can, and 0 if they can't. also prints an appropriate message 
 * to the player
 */
int
can_pay (object *pl)
{
  int unpaid_count = 0;
  sint64 unpaid_price = 0;
  sint64 player_wealth = query_money (pl);

  if (!pl || pl->type != PLAYER)
    {
      LOG (llevError, "can_pay(): called against something that isn't a player\n");
      return 0;
    }

  for (object::depth_iterator item = pl->begin (); item != pl->end (); ++item)
    if (QUERY_FLAG (item, FLAG_UNPAID))
      {
        unpaid_count++;
        unpaid_price += query_cost (item, pl, F_BUY | F_SHOP);
      }

  if (unpaid_price > player_wealth)
    {
      char buf[MAX_BUF];
      char cost[MAX_BUF];
      char missing[MAX_BUF];

      snprintf (cost, MAX_BUF, "%s", cost_string_from_value (unpaid_price, 0));
      snprintf (missing, MAX_BUF, "%s", cost_string_from_value (unpaid_price - player_wealth, 0));

      snprintf (buf, MAX_BUF, "You have %d unpaid items that would cost you %s. You need another %s to be able to afford that.",
                unpaid_count, cost, missing);
      new_draw_info (NDI_UNIQUE, 0, pl, buf);

      return 0;
    }
  else
    return 1;
}

/* Better get_payment, descends containers looking for
 * unpaid items, and pays for them.
 * returns 0 if the player still has unpaid items.
 * returns 1 if the player has paid for everything.
 * pl is the player buying the stuff.
 */
int
get_payment (object *pl)
{
  for (;;)
    {
      next_item:

      for (object::depth_iterator op = pl->begin (); op != pl->end (); ++op)
        {
          if (QUERY_FLAG (op, FLAG_UNPAID))
            {
              char buf[MAX_BUF];
              snprintf (buf, MAX_BUF, "%s", query_cost_string (op, pl, F_BUY | F_SHOP));

              if (!pay_for_item (op, pl))
                {
                  sint64 i = query_cost (op, pl, F_BUY | F_SHOP) - query_money (pl);

                  CLEAR_FLAG (op, FLAG_UNPAID);
                  new_draw_info_format (NDI_UNIQUE, 0, pl, "You lack %s to buy %s.", cost_string_from_value (i, 0), query_name (op));
                  SET_FLAG (op, FLAG_UNPAID);
                  return 0;
                }
              else
                {
                  object *tmp;

                  CLEAR_FLAG (op, FLAG_UNPAID);
                  CLEAR_FLAG (op, FLAG_PLAYER_SOLD);
                  new_draw_info_format (NDI_UNIQUE, 0, op, "You paid %s for %s.", buf, query_name (op));
                  tmp = merge_ob (op, NULL);

                  if (pl->type == PLAYER)
                    {
                      if (tmp)
                        {               /* it was merged */
                          esrv_del_item (pl->contr, op->count);
                          op = tmp;
                        }

                      esrv_send_item (pl, op);
                    }

                  goto next_item;
                }
            }
        }

      return 1;
    }
}

/* written by elmex:
 * moved this code from sell_item () here to have a function
 * that pays the player an amount. Mainly put the code here to
 * be able to call it from a plugin.
 *
 * If the player can't carry all the money that is paid, it gets inserted
 * in his inventory anyway. This is the best alternative to not pay any money
 * or put it on the ground under the player. This way the player can still
 * go somewhere and unload the money at a safe place.
 *
 */
void
pay_player (object *pl, sint64 amount)
{
  int count = 0;
  archetype *at = 0;
  object *pouch = 0, *tmp = 0;

  for (count = 0; coins[count]; count++)
    {
      at = archetype::find (coins[count]);

      if (at == NULL)
        LOG (llevError, "Could not find %s archetype\n", coins[count]);
      else if ((amount / at->value) > 0)
        {
          for (pouch = pl->inv; pouch; pouch = pouch->below)
            {
              if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && pouch->race && strstr (pouch->race, "gold"))
                {
                  int w = at->weight * (100 - pouch->stats.Str) / 100;
                  int n = amount / at->value;

                  if (w == 0)
                    w = 1;      /* Prevent divide by zero */

                  if (n > 0 && (!pouch->weight_limit || pouch->carrying + w <= pouch->weight_limit))
                    {
                      if (pouch->weight_limit && (pouch->weight_limit - pouch->carrying) / w < n)
                        n = (pouch->weight_limit - pouch->carrying) / w;

                      tmp = arch_to_object (at);
                      tmp->nrof = n;
                      amount -= tmp->nrof * tmp->value;
                      tmp = insert_ob_in_ob (tmp, pouch);
                      esrv_send_item (pl, tmp);
                      esrv_send_item (pl, pouch);
                      esrv_update_item (UPD_WEIGHT, pl, pouch);
                      esrv_send_item (pl, pl);
                    }
                }
            }

          if (amount / at->value > 0)
            {
              tmp = arch_to_object (at);
              tmp->nrof = amount / tmp->value;
              amount -= tmp->nrof * tmp->value;
              tmp = insert_ob_in_ob (tmp, pl);
              esrv_send_item (pl, tmp);
              esrv_send_item (pl, pl);
            }
        }
    }

  if (amount != 0)
    LOG (llevError, "Warning - payment in pay_player () not zero: %llu\n", amount);
}

/* elmex: this is for the bank plugin :( */
sint64
pay_player_arch (object *pl, const char *arch, sint64 amount)
{
  archetype *at = archetype::find (arch);

  if (!at)
    return 0;

  if (amount > 0)
    {
      object *tmp = arch_to_object (at);
      tmp->nrof = amount;
      tmp = insert_ob_in_ob (tmp, pl);
      esrv_send_item (pl, tmp);
      esrv_send_item (pl, pl);
    }

  return 1;
}

/* Modified function to give out platinum coins.  This function uses
 * the coins[] array to know what coins are available, just like
 * buy item.
 *
 * Modified to fill available race: gold containers before dumping
 * remaining coins in character's inventory.
 */
void
sell_item (object *op, object *pl)
{
  sint64 amount = query_cost (op, pl, F_SELL | F_SHOP), extra_gain;

  if (pl == NULL || pl->type != PLAYER)
    {
      LOG (llevDebug, "Object other than player tried to sell something.\n");
      return;
    }

  op->custom_name = 0;

  if (!amount)
    {
      new_draw_info_format (NDI_UNIQUE, 0, pl, "We're not interested in %s.", query_name (op));

      /* Even if the character doesn't get anything for it, it may still be
       * worth something.  If so, make it unpaid
       */
      if (op->value)
        {
          SET_FLAG (op, FLAG_UNPAID);
          SET_FLAG (op, FLAG_PLAYER_SOLD);
        }

      identify (op);
      return;
    }

  /* We compare the price with the one for a player
   * without bargaining skill.
   * This determins the amount of exp (if any) gained for bargaining.
   * exp/10 -> 1 for each gold coin
   */
  extra_gain = amount - query_cost (op, pl, F_SELL | F_NO_BARGAIN | F_SHOP);

  if (extra_gain > 0)
    change_exp (pl, extra_gain / 10, "bargaining", SK_EXP_NONE);

  pay_player (pl, amount);

  new_draw_info_format (NDI_UNIQUE, 0, pl, "You receive %s for %s.", query_cost_string (op, pl, F_SELL | F_SHOP), query_name (op));
  pl->play_sound (sound_find ("shop_sell"));

  SET_FLAG (op, FLAG_UNPAID);
  identify (op);
}

/* returns a double that is the ratio of the price that a shop will offer for
 * item based on the shops specialisation. Does not take account of greed, 
 * returned value is between SPECIALISATION_EFFECT and 1.
 */
static double
shop_specialisation_ratio (const object *item, const maptile *map)
{
  shopitems *items = map->shopitems;
  double likedness = 0.;
  int i;

  if (item == NULL)
    {
      LOG (llevError, "shop_specialisation_ratio: passed a NULL item for map %s\n", &map->path);
      return 0;
    }

  if (!item->type)
    {
      LOG (llevError, "shop_specialisation_ratio: passed an item with an invalid type\n");
      /* 
       * I'm not really sure what the /right/ thing to do here is, these types of 
       * item shouldn't exist anyway, but returning the ratio is probably the best bet.." 
       */
      return SPECIALISATION_EFFECT;
    }

  if (map->shopitems)
    {
      for (i = 0; i < items[0].index; i++)
        if (items[i].typenum == item->type || (!items[i].typenum && likedness == 0.001))
          likedness = items[i].strength / 100.0;
    }

  if (likedness > 1.0)
    {                           /* someone has been rather silly with the map headers. */
      LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is above 100%%\n", item->type, &map->path);
      likedness = 1.0;
    }

  if (likedness < -1.0)
    {
      LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is below -100%%\n", item->type, &map->path);
      likedness = -1.0;
    }

  return lerp (likedness, -1., 1., SPECIALISATION_EFFECT, 1.);
}

/*returns the greed of the shop on map, or 1 if it isn't specified. */
static double
shop_greed (const maptile *map)
{
  return map->shopgreed
     ? map->shopgreed
     : 1.;
}

/* Returns a double based on how much the shopkeeper approves of the player.
 * this is based on the race of the shopkeeper and that of the player.
 */
double
shopkeeper_approval (const maptile *map, const object *player)
{
  return map->shoprace && player->race != map->shoprace
     ? DISLIKE_RATIO
     : 1.;
}

/* limit the value of items based on the wealth of the shop. If the item is close
 * to the maximum value a shop will offer, we start to reduce it, if the item is 
 * below the minimum value the shop is prepared to trade in, then we don't 
 * want it and offer nothing. If it isn't a shop, check whether we should do generic
 * value reduction.
 * 
 */
static sint64
value_limit (sint64 val, int quantity, const object *who, int isshop)
{
  sint64 newval, unit_price, tmpshopmax;
  maptile *map;

  unit_price = val / quantity;

  if (!isshop || !who)
    {
      if (unit_price > 250000)
        newval = (sint64) (250000. - pow (250000., .75) * 65. + pow (unit_price, .75) * 65.);
      else
        newval = unit_price;
    }
  else
    {
      if (!who->map)
        {
          LOG (llevError, "value_limit: asked shop price for ob %s on NULL map\n", &who->name);
          return val;
        }

      map = who->map;

      tmpshopmax = map->shopmax ? map->shopmax : 100000;        // 20 royalties default

      if (map->shopmin && unit_price < map->shopmin)
        return 0;
      else if (unit_price > tmpshopmax / 2)
        newval = MIN ((tmpshopmax / 2) + isqrt (unit_price - tmpshopmax / 2), tmpshopmax);
      else
        newval = unit_price;
    }

  newval *= quantity;

  return newval;
}

/* gives a desciption of the shop on their current map to the player op. */
int
describe_shop (const object *op)
{
  maptile *map = op->map;

  /*shopitems *items=map->shopitems; */
  int pos = 0, i;
  double opinion = 0;
  char tmp[MAX_BUF] = "\0";

  if (op->type != PLAYER)
    return 0;

  /*check if there is a shop specified for this map */
  if (map->shopitems || map->shopgreed || map->shoprace || map->shopmin || map->shopmax)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "From looking at the nearby shop you determine that it trades in:");

      if (map->shopitems)
        for (i = 0; i < map->shopitems[0].index; i++)
          if (map->shopitems[i].name && map->shopitems[i].strength > 10)
            {
              snprintf (tmp + pos, sizeof (tmp) - pos, "%s, ", map->shopitems[i].name_pl);
              pos += strlen (tmp + pos);
            }

      if (!pos)
        strcat (tmp, "a little of everything.");

      /* format the string into a list */
      make_list_like (tmp);
      new_draw_info_format (NDI_UNIQUE, 0, op, "%s", tmp);

      if (map->shopmax)
        new_draw_info_format (NDI_UNIQUE, 0, op, "It won't trade for items above %s.", cost_string_from_value (map->shopmax, 0));

      if (map->shopmin)
        new_draw_info_format (NDI_UNIQUE, 0, op, "It won't trade in items worth less than %s.", cost_string_from_value (map->shopmin, 0));

      if (map->shopgreed)
        {
          if (map->shopgreed > 2.0)
            new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge massively.");
          else if (map->shopgreed > 1.5)
            new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge substantially.");
          else if (map->shopgreed > 1.1)
            new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge slightly.");
          else if (map->shopgreed < 0.9)
            new_draw_info (NDI_UNIQUE, 0, op, "It tends to undercharge.");
        }

      if (map->shoprace)
        {
          opinion = shopkeeper_approval (map, op);
          if (opinion > 0.8)
            new_draw_info (NDI_UNIQUE, 0, op, "You think the shopkeeper likes you.");
          else if (opinion > 0.5)
            new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper seems unconcerned by you.");
          else
            new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper seems to have taken a dislike to you.");
        }
    }
  else
    new_draw_info (NDI_UNIQUE, 0, op, "There is no shop nearby.");

  return 1;
}

struct shopinv
{
  char *item_sort;
  char *item_real;
  uint16 type;
  uint32 nrof;
};

/* There are a lot fo extra casts in here just to suppress warnings - it
 * makes it look uglier than it really it.
 * The format of the strings we get is type:name.  So we first want to
 * sort by type (numerical) - if the same type, then sort by name.
 */
static int
shop_sort (const void *a1, const void *a2)
{
  shopinv *s1 = (shopinv *) a1, *s2 = (shopinv *) a2;

  if (s1->type < s2->type)
    return -1;
  if (s1->type > s2->type)
    return 1;

  /* the type is the same (what atoi gets), so do a strcasecmp to sort
   * via alphabetical order
   */
  return strcasecmp (s1->item_sort, s2->item_sort);
}

static void
add_shop_item (object *tmp, shopinv * items, int *numitems, int *numallocated)
{
#if 0
  char buf[MAX_BUF];
#endif
  /* clear unpaid flag so that doesn't come up in query
   * string.  We clear nrof so that we can better sort
   * the object names.
   */

  CLEAR_FLAG (tmp, FLAG_UNPAID);
  items[*numitems].nrof = tmp->nrof;
  /* Non mergable items have nrof of 0, but count them as one
   * so the display is properly.
   */
  if (tmp->nrof == 0)
    items[*numitems].nrof++;
  items[*numitems].type = tmp->type;

  switch (tmp->type)
    {
#if 0
        case BOOTS:
        case GLOVES:
        case RING:
        case AMULET:
        case BRACERS:
        case GIRDLE:
          sprintf (buf, "%s %s", query_base_name (tmp, 0), describe_item (tmp, NULL));
          items[*numitems].item_sort = strdup (buf);
          sprintf (buf, "%s %s", query_name (tmp), describe_item (tmp, NULL));
          items[*numitems].item_real = strdup (buf);
          (*numitems)++;
          break;
#endif

        default:
          items[*numitems].item_sort = strdup (query_base_name (tmp, 0));
          items[*numitems].item_real = strdup (query_base_name (tmp, 1));
          (*numitems)++;
          break;
    }
  SET_FLAG (tmp, FLAG_UNPAID);
}

void
shop_listing (object *sign, object *op)
{
  int i, j, numitems = 0, numallocated = 0, x1, x2, y1, y2;
  const char *shop_coords = get_ob_key_value (sign, "shop_coords");
  object *stack;
  shopinv *items;

  /* Should never happen, but just in case a monster does apply a sign */
  if (op->type != PLAYER)
    return;

  if (!(shop_coords && sscanf (shop_coords, "%d,%d,%d,%d", &x1, &y1, &x2, &y2)))
    {
      x1 = 0;
      y1 = 0;
      x2 = op->map->width  - 1;
      y2 = op->map->height - 1;
    }

  items = (shopinv *) malloc (40 * sizeof (shopinv));
  numallocated = 40;

  /* Find all the appropriate items */
  for (i = x1; i <= x2; i++)
    {
      for (j = y1; j < y2; j++)
        {
          if (is_in_shop (op->map, i, j))
            {
              stack = GET_MAP_OB (op->map, i, j);

              while (stack)
                {
                  if (QUERY_FLAG (stack, FLAG_UNPAID))
                    {
                      if (numitems == numallocated)
                        {
                          items = (shopinv *) realloc (items, sizeof (shopinv) * (numallocated + 10));
                          numallocated += 10;
                        }

                      add_shop_item (stack, items, &numitems, &numallocated);
                    }

                  stack = stack->above;
                }
            }
        }
    }

  if (numitems == 0)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "The shop is currently empty.\n");
      free (items);
      return;
    }

  qsort (items, numitems, sizeof (shopinv), (int (*)(const void *, const void *)) shop_sort);

  new_draw_info (NDI_UNIQUE, 0, op, "\nThe shop contains:");

  for (i = 0; i < numitems; i++)
    {
      /* Collapse items of the same name together */
      if ((i + 1) < numitems && !strcmp (items[i].item_real, items[i + 1].item_real))
        {
          items[i + 1].nrof += items[i].nrof;
          free (items[i].item_sort);
          free (items[i].item_real);
        }
      else
        {
          new_draw_info_format (NDI_UNIQUE, 0, op, "%d %s",
                                items[i].nrof ? items[i].nrof : 1, items[i].nrof == 1 ? items[i].item_sort : items[i].item_real);
          free (items[i].item_sort);
          free (items[i].item_real);
        }
    }

  free (items);
}

/* elmex: this function checks whether the object is in a shop */
bool
is_in_shop (object *o)
{
  if (!o->map)
    return false;

  return is_in_shop (o->map, o->x, o->y);
}

/* elmex: this function checks whether we are in a shop or not
   - change 2007-11-26: enhanced the O(n) case by stopping at the first
     floor tile. this possibly will make map bugs where shopfloors are above
     floors more obvious.
*/

bool
is_in_shop (maptile *map, int x, int y)
{
  for (object *floor = GET_MAP_OB (map, x, y); floor; floor = floor->above)
    if (QUERY_FLAG (floor, FLAG_IS_FLOOR))
      return floor->type == SHOP_FLOOR;
  return false;
}

Revision:	1.47
Committed:	Sun Apr 13 01:34:09 2008 UTC (16 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_5
Changes since 1.46:	+2 -3 lines
Log Message:	* empty log message *