/*
* This file is part of Deliantra, the Roguelike Realtime MMORPG.
*
* Copyright (©) 2005,2006,2007,2008 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 .
*
* The authors can be reached via e-mail to
*/
#include
#include
#include
#include
#include
#include
/* 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 && who->type == PLAYER)
{
int lev_bargain = 0;
int lev_identify = 0;
if (find_skill_by_number (who, SK_BARGAINING))
lev_bargain = find_skill_by_number (who, SK_BARGAINING)->level;
if (const typedata *tmptype = get_typedata (tmp->type))
{
if (int idskill1 = tmptype->identifyskill)
{
int 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;
}
}
/* 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]);
coin_objs[i]->nrof += tmp->nrof;
tmp->destroy ();
}
else
{
tmp->remove ();
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)
insert_ob_in_ob (coin_objs [i], pouch);
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)
{
dynbuf_text buf;
buf << "You have " << unpaid_count
<< " unpaid item(s) that would cost you " << cost_string_from_value (unpaid_price, 0)
<< ". You need another " << cost_string_from_value (unpaid_price - player_wealth, 0)
<< " to be able to afford that.";
pl->failmsg (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
{
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));
if (!merge_ob (op, op->env->inv))
esrv_update_item (UPD_FLAGS, 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;
object *tmp = arch_to_object (at);
tmp->nrof = n;
amount -= tmp->nrof * tmp->value;
pouch->insert (tmp);
}
}
}
if (amount / at->value > 0)
{
object *tmp = arch_to_object (at);
tmp->nrof = amount / tmp->value;
amount -= tmp->nrof * tmp->value;
pl->insert (tmp);
}
}
}
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)
{
if (amount)
{
object *ob = archetype::get (arch);
if (!ob)
return 0;
ob->nrof = amount;
pl->insert (ob);
}
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.
*/
bool
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 false;
}
op->custom_name = 0;
if (!amount)
{
new_draw_info_format (NDI_UNIQUE, 0, pl, "We're not interested in %s.",
query_name (op));
// elmex: change: the player now gets the item back if the shop is not
// interested in it.
return false;
}
/* 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);
return true;
}
/* 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 = sign->kv (shstr_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->is_on_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;
}