ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/shop.C

Comparing deliantra/server/server/shop.C (file contents):
Revision 1.10 by root, Sun Sep 10 15:59:57 2006 UTC vs.
Revision 1.92 by root, Mon Oct 29 23:55:55 2012 UTC

1
2	/*	1	/*
3	* static char *rcsid_shop_c =	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4	* "$Id: shop.C,v 1.10 2006/09/10 15:59:57 root Exp $";
5	*/	3	*
6		4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
7	/*
8	CrossFire, A Multiplayer game for X-windows
9
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
12		7	*
13	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
14	it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
15	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
16	(at your option) any later version.	11	* option) any later version.
17		12	*
18	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.	16	* GNU General Public License for more details.
22		17	*
23	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
24	along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
26		21	*
27	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	* The authors can be reached via e-mail to <support@deliantra.net>
28	*/	23	*/
29		24
30	#include <global.h>	25	#include <global.h>
31	#include <spells.h>	26	#include <spells.h>
32	#include <skills.h>	27	#include <skills.h>
33	#include <living.h>	28	#include <living.h>
34	#include <newclient.h>
35	#ifndef __CEXTRACT__
36	# include <sproto.h>	29	#include <sproto.h>
37	#endif
38	#include <math.h>
39		30
40	/* this is a measure of how effective store specialisation is. A general store	31	/* this is a measure of how effective store specialisation is. A general store
41	* will offer this proportion of the 'maximum' price, a specialised store will	32	* will offer this proportion of the 'maximum' price, a specialised store will
42	* offer a range of prices around it such that the maximum price is always one	33	* offer a range of prices around it such that the maximum price is always one
43	* therefore making this number higher, makes specialisation less effective.	34	* therefore making this number higher, makes specialisation less effective.
44	* setting this value above 1 or to a negative value would have interesting,	35	* setting this value above 1 or to a negative value would have interesting,
45	* (though not useful) effects.	36	* (though not useful) effects.
46	*/	37	*/
47	#define SPECIALISATION_EFFECT 0.5	38	#define SPECIALISATION_EFFECT .5
48		39
49	/* price a shopkeeper will give someone they neither like nor dislike */	40	// price a shopkeeper will give someone that is not of their race
50	#define NEUTRAL_RATIO 0.8	41	#define DISLIKE_RATIO 0.8
51		42
52	static uint64 pay_from_container (object *pl, object *pouch, uint64 to_pay);	43	static void pay_from_container (object *pl, object *pouch, sint64 &to_pay);
53	static uint64 value_limit (uint64 val, int quantity, const object *who, int isshop);	44	static sint64 value_limit (sint64 val, int quantity, const object *who, int isshop);
54	static double shop_specialisation_ratio (const object *item, const mapstruct *map);	45	static double shop_specialisation_ratio (const object *item, const maptile *map);
55	static double shop_greed (const mapstruct *map);	46	static double shop_greed (const maptile *map);
56
57	#define NUM_COINS 4 /* number of coin types */
58	static const char *const coins[] = { "royalty", "platinacoin", "goldcoin", "silvercoin", NULL };
59		47
60	/* Added F_TRUE flag to define.h to mean that the price should not	48	/* Added F_TRUE flag to define.h to mean that the price should not
61	* be adjusted by players charisma. With F_TRUE, it returns the amount	49	* be adjusted by players charisma. With F_TRUE, it returns the amount
62	* that the item is worth, if it was sold, but unadjusted by charisma.	50	* that the item is worth, if it was sold, but unadjusted by charisma.
63	* This is needed for alchemy, to to determine what value of gold nuggets	51	* This is needed for alchemy, to to determine what value of gold nuggets
…		…
80	* thus remained 0.	68	* thus remained 0.
81	*	69	*
82	* Mark Wedel (mwedel@pyramid.com)	70	* Mark Wedel (mwedel@pyramid.com)
83	*/	71	*/
84		72
85	static uint64 approx_range;	73	static sint64 approx_range;
86		74
87	uint64	75	sint64
88	query_cost (const object *tmp, object *who, int flag)	76	query_cost (const object *tmp, object *who, int flag)
89	{	77	{
90	double val;	78	double val;
91	int number; /* used to better calculate value */
92	int no_bargain;	79	int no_bargain;
93	int identified;	80	int identified;
94	int not_cursed;	81	int not_cursed;
95	int approximate;	82	int approximate;
96	int shop;	83	int shop;
97	double diff;
98		84
99	approx_range = 0;	85	approx_range = 0;
100		86
101	no_bargain = flag & F_NO_BARGAIN;	87	no_bargain = flag & F_NO_BARGAIN;
102	identified = flag & F_IDENTIFIED;	88	identified = flag & F_IDENTIFIED;
103	not_cursed = flag & F_NOT_CURSED;	89	not_cursed = flag & F_NOT_CURSED;
104	approximate = flag & F_APPROX;	90	approximate = flag & F_APPROX;
105	shop = flag & F_SHOP;	91	shop = flag & F_SHOP;
106	flag &= ~(F_NO_BARGAIN | F_IDENTIFIED | F_NOT_CURSED | F_APPROX | F_SHOP);	92	flag &= ~(F_NO_BARGAIN | F_IDENTIFIED | F_NOT_CURSED | F_APPROX | F_SHOP);
107		93
		94	int number = tmp->number_of ();
		95
108	if (tmp->type == MONEY)	96	if (tmp->type == MONEY)
109	return (tmp->nrof * tmp->value);	97	return number * tmp->value;
		98
110	if (tmp->type == GEM)	99	if (tmp->type == GEM)
111	{	100	{
112	if (flag == F_TRUE)	101	if (flag == F_TRUE)
113	return (tmp->nrof * tmp->value);	102	return number * tmp->value;
		103
114	if (flag == F_BUY)	104	if (flag == F_BUY)
115	return (uint64) (1.03 * tmp->nrof * tmp->value);	105	return 1.03 * number * tmp->value;
		106
116	if (flag == F_SELL)	107	if (flag == F_SELL)
117	return (uint64) (0.97 * tmp->nrof * tmp->value);	108	return 0.97 * number * tmp->value;
		109
118	LOG (llevError, "Query_cost: Gem type with unknown flag : %d\n", flag);	110	LOG (llevError, "Query_cost: Gem type with unknown flag %d: %s\n", flag, tmp->debug_desc ());
119	return 0;	111	return 0;
120	}	112	}
121	number = tmp->nrof;	113
122	if (number == 0)
123	number = 1;
124	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)	114	if (tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified)
125	{	115	{
126	if (!not_cursed && (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	116	if (!not_cursed && (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
127	return 0;	117	return 0;
128	else	118	else
129	val = tmp->value * number;	119	val = number * tmp->value;
130	}	120	}
131	/* This area deals with objects that are not identified, but can be */	121	/* This area deals with objects that are not identified, but can be */
132	else	122	else
133	{	123	{
134	if (tmp->arch != NULL)
135	{
136	if (flag == F_BUY)	124	if (flag == F_BUY)
		125	{
		126	LOG (llevError | logBacktrace, "Asking for buy-value of unidentified object: %s\n", tmp->debug_desc ());
		127	val = tmp->arch->value * 50 * number;
		128	}
		129	else
		130	{ /* Trying to sell something, or get true value */
		131	if (tmp->type == POTION)
		132	val = number * 40; /* Don't want to give anything away */
		133	else
137	{	134	{
138	LOG (llevError, "Asking for buy-value of unidentified object.\n");	135	/* Get 2/3'rd value for applied objects, 1/3'rd for totally
139	val = tmp->arch->clone.value * 50 * number;	136	* unknown objects
		137	*/
		138	if (tmp->flag [FLAG_BEEN_APPLIED])
		139	val = number * tmp->arch->value * 2 / 3;
		140	else
		141	val = number * tmp->arch->value / 3;
140	}	142	}
141	else
142	{ /* Trying to sell something, or get true value */
143	if (tmp->type == POTION)
144	val = number * 40; /* Don't want to give anything away */
145	else
146	{
147	/* Get 2/3'rd value for applied objects, 1/3'rd for totally
148	* unknown objects
149	*/
150	if (QUERY_FLAG (tmp, FLAG_BEEN_APPLIED))
151	val = number * tmp->arch->clone.value * 2 / 3;
152	else
153	val = number * tmp->arch->clone.value / 3;
154	}
155	}
156	}
157	else
158	{ /* No archetype with this object */
159	LOG (llevDebug, "In sell item: Have object with no archetype: %s\n", &tmp->name);
160	if (flag == F_BUY)
161	{
162	LOG (llevError, "Asking for buy-value of unidentified object without arch.\n");
163	val = number * tmp->value * 10;
164	}
165	else
166	val = number * tmp->value / 5;
167	}	143	}
168	}	144	}
169		145
170	/* If the item has been applied or identifed or does not need to be	146	/* If the item has been applied or identifed or does not need to be
171	* identified, AND the object is magical and the archetype is non	147	* identified, AND the object is magical and the archetype is non
172	* magical, then change values accordingly. The tmp->arch==NULL is	148	* magical, then change values accordingly. The tmp->arch==NULL is
173	* really just a check to prevent core dumps for when it checks	149	* really just a check to prevent core dumps for when it checks
174	* tmp->arch->clone.magic for any magic. The check for archetype	150	* tmp->arch->magic for any magic. The check for archetype
175	* magic is to not give extra money for archetypes that are by	151	* magic is to not give extra money for archetypes that are by
176	* default magical. This is because the archetype value should have	152	* default magical. This is because the archetype value should have
177	* already figured in that value.	153	* already figured in that value.
178	*/	154	*/
179	if ((QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified ||	155	if ((tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified || tmp->flag [FLAG_BEEN_APPLIED])
180	QUERY_FLAG (tmp, FLAG_BEEN_APPLIED)) && tmp->magic && (tmp->arch == NULL || !tmp->arch->clone.magic))	156	&& tmp->magic && (!tmp->arch || !tmp->arch->magic))
181	{	157	{
182	if (tmp->magic > 0)	158	if (tmp->magic > 0)
183	val *= (3 * tmp->magic * tmp->magic * tmp->magic);	159	val *= 3 * tmp->magic * tmp->magic * tmp->magic;
184	else	160	else
185	/* Note that tmp->magic is negative, so that this	161	/* Note that tmp->magic is negative, so that this
186	* will actually be something like val /=2, /=3, etc.	162	* will actually be something like val /=2, /=3, etc.
187	*/	163	*/
188	val /= (1 - tmp->magic);	164	val /= 1 - tmp->magic;
189	}	165	}
190		166
191	if (tmp->type == WAND)	167	if (tmp->type == WAND)
192	{	168	{
193	/* Value of the wand is multiplied by the number of	169	/* Value of the wand is multiplied by the number of
194	* charges. the treasure code already sets up the value	170	* charges. the treasure code already sets up the value
195	* 50 charges is used as the baseline.	171	* 50 charges is used as the baseline.
196	*/	172	*/
197	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)	173	if (tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified)
198	val = (val * tmp->stats.food) / 50;	174	val *= tmp->stats.food;
199	else /* if not identified, presume one charge */	175	/* if not identified, presume one charge */
200	val /= 50;	176	val /= 50;
201	}	177	}
202		178
203	/* Limit amount of money you can get for really great items. */	179	/* Limit amount of money you can get for really great items. */
204	if (flag == F_SELL)	180	if (flag == F_SELL)
205	val = value_limit ((uint64) val, number, who, shop);	181	val = value_limit (val, number, who, shop);
206		182
207	// use a nonlinear price adjustment. as my predecessor said, don't change	183	// use a nonlinear price adjustment. as my predecessor said, don't change
208	// the archetypes, its work required for balancing, and we don't care.	184	// the archetypes, its work required for balancing, and we don't care.
209	//val = pow (val, 1.05);	185	//val = pow (val, 1.05);
210		186
…		…
213	* AND Cha = 30 will get optimal price.	189	* AND Cha = 30 will get optimal price.
214	* Thus charisma will never get useless.	190	* Thus charisma will never get useless.
215	* -b.e. edler@heydernet.de	191	* -b.e. edler@heydernet.de
216	*/	192	*/
217		193
218	if (who != NULL && who->type == PLAYER)	194	if (who && who->is_player ())
219	{	195	{
220	int lev_bargain = 0;	196	int lev_bargain = 0;
221	int lev_identify = 0;	197	int lev_identify = 0;
222	int idskill1 = 0;
223	int idskill2 = 0;
224	const typedata *tmptype;
225		198
		199	if (!no_bargain)
		200	if (object *skill = find_skill_by_name (who, shstr_bargaining))
		201	lev_bargain = skill->level;
		202
226	tmptype = get_typedata (tmp->type);	203	if (const typedata *tmptype = get_typedata (tmp->type))
227
228	if (find_skill_by_number (who, SK_BARGAINING))
229	{
230	lev_bargain = find_skill_by_number (who, SK_BARGAINING)->level;
231	}	204	{
232	if (tmptype)
233	{
234	idskill1 = tmptype->identifyskill;	205	if (int idskill1 = tmptype->identifyskill)
235	if (idskill1)
236	{	206	{
237	idskill2 = tmptype->identifyskill2;	207	int idskill2 = tmptype->identifyskill2;
		208
238	if (find_skill_by_number (who, idskill1))	209	if (find_skill_by_number (who, idskill1))
239	{
240	lev_identify = find_skill_by_number (who, idskill1)->level;	210	lev_identify = find_skill_by_number (who, idskill1)->level;
241	}	211
242	if (idskill2 && find_skill_by_number (who, idskill2))	212	if (idskill2 && find_skill_by_number (who, idskill2))
243	{
244	lev_identify += find_skill_by_number (who, idskill2)->level;	213	lev_identify += find_skill_by_number (who, idskill2)->level;
245	}
246	}	214	}
247	}	215	}
248	else
249	LOG (llevError, "Query_cost: item %s hasn't got a valid type\n", &tmp->name);
250		216
251	/* ratio determines how much of the price modification	217	/* ratio determines how much of the price modification
252	* will come from the basic stat charisma	218	* will come from the basic stat charisma
253	* the rest will come from the level in bargaining skill	219	* the rest will come from the level in bargaining skill
254	*/	220	*/
255	const double cha_ratio = 0.40;	221	const double cha_ratio = 0.40;
256		222	double bargaining = max (0., 1. - powf (double (lev_bargain) / MAXLEVEL_TREASURE, 0.25));
257	diff = no_bargain ? 1.0 : 1. - pow (lev_bargain / (double) settings.max_level, 0.25);
258
259	diff = (1. - cha_ratio) * diff + cha_ratio * (cha_bonus[who->stats.Cha] - 1.) / (cha_bonus[who->stats.Cha] + 1.);	223	double charisma = (cha_bonus[who->stats.Cha] - 1.) / (cha_bonus[who->stats.Cha] + 1.);
260		224
261	diff = .02 + (.80 - .02) * diff;	225	double factor = (1. - cha_ratio) * bargaining + cha_ratio * charisma;
		226
		227	// scale 0..1 to 2 .. 80%
		228	factor = lerp (factor, 0., 1., 0.02, 0.80);
262		229
263	if (flag == F_BUY)	230	if (flag == F_BUY)
264	val += (val * diff);	231	val += val * factor;
265	else if (flag == F_SELL)	232	else if (flag == F_SELL)
266	val -= (val * diff);	233	val -= val * factor;
267		234
268	// now find a price range. the less good we can judge, the larger the range is	235	// now find a price range. the less good we can judge, the larger the range is
269	// then the range is adjusted randomly around the correct value	236	// then the range is adjusted randomly around the correct value
270	if (approximate)	237	if (approximate)
271	approx_range = uint64 (val / sqrt (lev_identify * 3 + 1));	238	approx_range = val / sqrt (lev_identify * 3 + 1);
272	}	239	}
273		240
274	/* I don't think this should really happen - if it does, it indicates and	241	/* I don't think this should really happen - if it does, it indicates and
275	* overflow of diff above. That shoudl only happen if	242	* overflow of diff above. That should only happen if
276	* we are selling objects - in that case, the person just	243	* we are selling objects - in that case, the person just
277	* gets no money.	244	* gets no money.
278	*/	245	*/
279	if ((sint64) val < 0)	246	if ((sint64) val < 0)
280	val = 0;	247	val = 0;
281		248
282	/* Unidentified stuff won't sell for more than 60gp */	249	/* Unidentified stuff won't sell for more than 10gp */
283	if (flag == F_SELL && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && need_identify (tmp) && !identified)	250	if (flag == F_SELL && !tmp->flag [FLAG_IDENTIFIED] && tmp->need_identify () && !identified)
284	{	251	min_it (val, 1000);
285	val = (val > 600) ? 600 : val;
286	}
287		252
288	/* if we are in a shop, check how the type of shop should affect the price */	253	/* if we are in a shop, check how the type of shop should affect the price */
289	if (shop && who)	254	if (shop && who)
290	{	255	{
291	if (flag == F_SELL)	256	if (flag == F_SELL)
292	val = (val * shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who) / shop_greed (who->map));	257	val *= shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who) / shop_greed (who->map);
293	else if (flag == F_BUY)	258	else if (flag == F_BUY)
294	{	259	{
295	/*	260	/*
296	* when buying, if the item was sold by another player, it is ok to	261	* when buying, if the item was sold by another player, it is ok to
297	* let the item be sold cheaper, according to the specialisation of	262	* let the item be sold cheaper, according to the specialisation of
…		…
303	* be sold for (otherwise players could camp map resets to make money).	268	* be sold for (otherwise players could camp map resets to make money).
304	* In game terms, a non-specialist shop, might not recognise the true	269	* In game terms, a non-specialist shop, might not recognise the true
305	* value of the items they sell (much like how people sometimes find	270	* value of the items they sell (much like how people sometimes find
306	* antiques in a junk shop in real life).	271	* antiques in a junk shop in real life).
307	*/	272	*/
308	if (QUERY_FLAG (tmp, FLAG_PLAYER_SOLD))	273	if (tmp->flag [FLAG_PLAYER_SOLD])
309	val = (val * shop_greed (who->map) * shop_specialisation_ratio (tmp, who->map) / shopkeeper_approval (who->map, who));	274	val *= shop_specialisation_ratio (tmp, who->map);
310	else	275	else
311	val = (val * shop_greed (who->map) / (shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who)));	276	val /= shop_specialisation_ratio (tmp, who->map);
		277
		278	val *= shop_greed (who->map) / shopkeeper_approval (who->map, who);
312	}	279	}
		280
313	/* we will also have an extra 0-5% variation between shops of the same type	281	/* we will also have an extra 0-5% variation between shops of the same type
314	* for valuable items (below a value of 50 this effect wouldn't be very	282	* for valuable items (below a value of 50 this effect wouldn't be very
315	* pointful, and could give fun with rounding.	283	* pointful, and could give fun with rounding.
316	*/	284	*/
317	if (who->map->path != NULL && val > 50)	285	//TODO: why use cosf at all, just % and scale linearly, gives more even distribution
318	val = (val + 0.05 * (sint64) val * cos (tmp->count + strlen (who->map->path)));	286	if (val > 50)
		287	val *= 1 + .05f * cosf ((tmp->uuid.seq & 0xffff) * M_PI * 2. / 0x10000);
319	}	288	}
320	return (uint64) val;	289
		290	return val;
321	}	291	}
322		292
323	/* Find the coin type that is worth more the 'c'. Starts at the	293	/* Find the coin type that is worth more the 'c'. Starts at the
324	* cointype placement.	294	* cointype placement.
325	*/	295	*/
326		296
327	static archetype *	297	static archetype *
328	find_next_coin (uint64 c, int *cointype)	298	find_next_coin (sint64 c, int *cointype)
329	{	299	{
330	archetype *coin;	300	archetype *coin;
331		301
332	do	302	do
333	{	303	{
334	if (coins[*cointype] == NULL)	304	if (!coins [*cointype])
335	return NULL;	305	return 0;
		306
336	coin = find_archetype (coins[*cointype]);	307	coin = archetype::find (coins [*cointype]);
		308
337	if (coin == NULL)	309	if (!coin)
338	return NULL;	310	return 0;
		311
339	*cointype += 1;	312	*cointype += 1;
340	}	313	}
341	while ((uint64) coin->clone.value > c);	314	while (coin->value > c);
342		315
343	return coin;	316	return coin;
344	}	317	}
345		318
346	/* This returns a string of how much something is worth based on	319	/* This returns a string of how much something is worth based on
…		…
352	* coins, there are certainly issues - the easiest fix at that	325	* coins, there are certainly issues - the easiest fix at that
353	* time is to add a higher denomination (mithril piece with	326	* time is to add a higher denomination (mithril piece with
354	* 10,000 silver or something)	327	* 10,000 silver or something)
355	*/	328	*/
356	const char *	329	const char *
357	cost_string_from_value (uint64 cost, int approx)	330	cost_string_from_value (sint64 cost, int approx)
358	{	331	{
359	static char buf[MAX_BUF];
360	archetype *coin, *next_coin;	332	archetype *coin, *next_coin;
361	int num, cointype = 0;	333	int num, cointype = 0;
362		334
363	coin = find_next_coin (cost, &cointype);	335	coin = find_next_coin (cost, &cointype);
364	if (coin == NULL)	336	if (!coin)
365	return "nothing";	337	return "nothing";
366		338
367	num = cost / coin->clone.value;	339	num = cost / coin->value;
368	/* so long as nrof is 32 bit, this is true.	340	/* so long as nrof is 32 bit, this is true.
369	* If it takes more coins than a person can possibly carry, this	341	* If it takes more coins than a person can possibly carry, this
370	* is basically true.	342	* is basically true.
371	*/	343	*/
372	if ((cost / coin->clone.value) > UINT32_MAX)	344	if (cost / coin->value > UINT32_MAX)
373	{
374	strcpy (buf, "an unimaginable sum of money");	345	return "an unimaginable sum of money";
375	return buf;
376	}
377		346
378	cost -= (uint64) num *(uint64) coin->clone.value;	347	cost -= num * (sint64)coin->value;
379		348
380	sprintf (buf, "%d %s", num, num > 1 ? &coin->clone.name_pl : &coin->clone.name);	349	char *buf = format ("%d %s", num, num > 1 ? &coin->object::name_pl : &coin->object::name);
381		350
382	next_coin = find_next_coin (cost, &cointype);	351	next_coin = find_next_coin (cost, &cointype);
383	if (next_coin == NULL || approx)	352	if (!next_coin || approx)
384	return buf;	353	return buf;
385		354
386	coin = next_coin;	355	coin = next_coin;
387	num = cost / coin->clone.value;	356	num = cost / coin->value;
388	cost -= (uint64) num *(uint64) coin->clone.value;	357	cost -= num * (sint64)coin->value;
389		358
390	sprintf (buf + strlen (buf), " and %d %s", num, num > 1 ? &coin->clone.name_pl : &coin->clone.name);	359	return format ("%s and %d %s", buf, num, num > 1 ? &coin->object::name_pl : &coin->object::name);
391
392	return buf;
393	}	360	}
394		361
395	const char *	362	const char *
396	query_cost_string (const object *tmp, object *who, int flag)	363	query_cost_string (const object *tmp, object *who, int flag)
397	{	364	{
398	uint64 real_value = query_cost (tmp, who, flag);	365	sint64 real_value = query_cost (tmp, who, flag);
399	int idskill1 = 0;	366	int idskill1 = 0;
400	int idskill2 = 0;	367	int idskill2 = 0;
401	const typedata *tmptype;	368	const typedata *tmptype;
402		369
403	tmptype = get_typedata (tmp->type);	370	tmptype = get_typedata (tmp->type);
…		…
416	{	383	{
417	if (!idskill1 || !find_skill_by_number (who, idskill1))	384	if (!idskill1 || !find_skill_by_number (who, idskill1))
418	{	385	{
419	if (!idskill2 || !find_skill_by_number (who, idskill2))	386	if (!idskill2 || !find_skill_by_number (who, idskill2))
420	{	387	{
421	if (!find_skill_by_number (who, SK_BARGAINING))	388	if (!find_skill_by_name (who, shstr_bargaining))
422	{	389	{
423	static char buf[MAX_BUF];
424	int num, cointype = 0;	390	int num, cointype = 0;
425	archetype *coin = find_next_coin (real_value, &cointype);	391	archetype *coin = find_next_coin (real_value, &cointype);
426		392
427	if (coin == NULL)	393	if (!coin)
428	return "nothing";	394	return "nothing";
429		395
430	num = real_value / coin->clone.value;	396	num = real_value / coin->value;
		397
431	if (num == 1)	398	if (num == 1)
432	sprintf (buf, "about one %s", &coin->clone.name);	399	return format ("about one %s", &coin->object::name);
433	else if (num < 5)	400	else if (num < 5)
434	sprintf (buf, "a few %s", &coin->clone.name_pl);	401	return format ("a few %s", &coin->object::name_pl);
435	else if (num < 10)	402	else if (num < 10)
436	sprintf (buf, "several %s", &coin->clone.name_pl);	403	return format ("several %s", &coin->object::name_pl);
437	else if (num < 25)	404	else if (num < 25)
438	sprintf (buf, "a moderate amount of %s", &coin->clone.name_pl);	405	return format ("a moderate amount of %s", &coin->object::name_pl);
439	else if (num < 100)	406	else if (num < 100)
440	sprintf (buf, "lots of %s", &coin->clone.name_pl);	407	return format ("lots of %s", &coin->object::name_pl);
441	else if (num < 1000)	408	else if (num < 1000)
442	sprintf (buf, "a great many %s", &coin->clone.name_pl);	409	return format ("a great many %s", &coin->object::name_pl);
443	else	410	else
444	sprintf (buf, "a vast quantity of %s", &coin->clone.name_pl);	411	return format ("a vast quantity of %s", &coin->object::name_pl);
445	return buf;
446	}	412	}
447	}	413	}
448	}	414	}
449		415
450	int hash = ((unsigned int) tmp->count * 174364621) & 1023;
451
452	if (approx_range)	416	if (approx_range)
453	{	417	{
		418	int hash = tmp->random_seed () & 1023;
454	uint64 lo = (sint64) real_value - (approx_range * hash >> 10);	419	sint64 lo = real_value - (approx_range * hash >> 10);
455	static char buf[MAX_BUF];
456		420
457	sprintf (buf, "between %s", cost_string_from_value (lo, 1));	421	return format ("between %s and %s",
458	sprintf (buf + strlen (buf), " and %s", cost_string_from_value (lo + approx_range, 1));	422	cost_string_from_value (lo, 1),
459		423	cost_string_from_value (lo + approx_range, 1));
460	return buf;
461	}	424	}
462	}	425	}
463		426
464	return cost_string_from_value (real_value, 0);	427	return cost_string_from_value (real_value, 0);
465	}	428	}
466		429
467	/* This function finds out how much money the player is carrying,	430	/* This function finds out how much money the player is carrying,
468	* including what is in containers.	431	* including what is in containers.
469	*/	432	*/
470	uint64	433	sint64
471	query_money (const object *op)	434	query_money (const object *op)
472	{	435	{
473	object *tmp;	436	object *tmp;
474	uint64 total = 0;	437	sint64 total = 0;
475		438
476	if (op->type != PLAYER && op->type != CONTAINER)	439	if (op->type != PLAYER && op->type != CONTAINER)
477	{	440	{
478	LOG (llevError, "Query money called with non player/container\n");	441	LOG (llevError, "Query money called with non player/container\n");
479	return 0;	442	return 0;
480	}	443	}
		444
481	for (tmp = op->inv; tmp; tmp = tmp->below)	445	for (tmp = op->inv; tmp; tmp = tmp->below)
482	{
483	if (tmp->type == MONEY)	446	if (tmp->type == MONEY)
484	{
485	total += (uint64) tmp->nrof * (uint64) tmp->value;	447	total += tmp->nrof * (sint64)tmp->value;
486	}	448	else if (tmp->type == CONTAINER && tmp->flag [FLAG_APPLIED] && (!tmp->race || tmp->race.contains (shstr_gold)))
487	else if (tmp->type == CONTAINER && QUERY_FLAG (tmp, FLAG_APPLIED) && (tmp->race == NULL || strstr (tmp->race, "gold")))
488	{
489	total += query_money (tmp);	449	total += query_money (tmp);
490	}	450
491	}
492	return total;	451	return total;
493	}	452	}
494		453
495	/* TCHIZE: This function takes the amount of money from the	454	/* TCHIZE: This function takes the amount of money from the
496	* the player inventory and from it's various pouches using the	455	* the player inventory and from it's various pouches using the
497	* pay_from_container function.	456	* pay_from_container function.
498	* returns 0 if not possible. 1 if success	457	* returns 0 if not possible. 1 if success
499	*/	458	*/
500	int	459	int
501	pay_for_amount (uint64 to_pay, object *pl)	460	pay_for_amount (sint64 to_pay, object *pl)
502	{	461	{
503	object *pouch;	462	object *pouch;
504		463
505	if (to_pay == 0)	464	if (to_pay == 0)
506	return 1;	465	return 1;
		466
507	if (to_pay > query_money (pl))	467	if (to_pay > query_money (pl))
508	return 0;	468	return 0;
509		469
510	to_pay = pay_from_container (pl, pl, to_pay);	470	pay_from_container (pl, pl, to_pay);
511		471
512	for (pouch = pl->inv; (pouch != NULL) && (to_pay > 0); pouch = pouch->below)	472	for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
513	{	473	if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains (shstr_gold)))
514	if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (pouch->race == NULL || strstr (pouch->race, "gold")))
515	{
516	to_pay = pay_from_container (pl, pouch, to_pay);	474	pay_from_container (pl, pouch, to_pay);
517	}	475
518	}	476	pl->update_stats ();
519	fix_player (pl);
520	return 1;	477	return 1;
521	}	478	}
522		479
523	/* DAMN: This is now a wrapper for pay_from_container, which is	480	/* DAMN: This is now a wrapper for pay_from_container, which is
524	* called for the player, then for each active container that can hold	481	* called for the player, then for each active container that can hold
…		…
526	* of the price was paid from.	483	* of the price was paid from.
527	*/	484	*/
528	int	485	int
529	pay_for_item (object *op, object *pl)	486	pay_for_item (object *op, object *pl)
530	{	487	{
531	uint64 to_pay = query_cost (op, pl, F_BUY | F_SHOP);	488	sint64 to_pay = query_cost (op, pl, F_BUY | F_SHOP);
532	object *pouch;	489	object *pouch;
533	uint64 saved_money;	490	sint64 saved_money;
534		491
535	if (to_pay == 0)	492	if (to_pay == 0)
536	return 1;	493	return 1;
		494
537	if (to_pay > query_money (pl))	495	if (to_pay > query_money (pl))
538	return 0;	496	return 0;
539		497
540	/* We compare the paid price with the one for a player	498	/* We compare the paid price with the one for a player
541	* without bargaining skill.	499	* without bargaining skill.
542	* This determins the amount of exp (if any) gained for bargaining.	500	* This determins the amount of exp (if any) gained for bargaining.
543	*/	501	*/
544	saved_money = query_cost (op, pl, F_BUY | F_NO_BARGAIN | F_SHOP) - to_pay;	502	saved_money = query_cost (op, pl, F_BUY | F_NO_BARGAIN | F_SHOP) - to_pay;
545		503
546	if (saved_money > 0)	504	if (saved_money > 0)
547	change_exp (pl, saved_money, "bargaining", SK_EXP_NONE);	505	change_exp (pl, saved_money, shstr_bargaining, SK_EXP_NONE);
548		506
549	to_pay = pay_from_container (pl, pl, to_pay);	507	pay_from_container (pl, pl, to_pay);
550		508
551	for (pouch = pl->inv; (pouch != NULL) && (to_pay > 0); pouch = pouch->below)	509	for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
552	{	510	if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains (shstr_gold)))
553	if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (pouch->race == NULL || strstr (pouch->race, "gold")))
554	{
555	to_pay = pay_from_container (pl, pouch, to_pay);	511	pay_from_container (pl, pouch, to_pay);
556	}	512
557	}	513	pl->update_stats ();
558	if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))	514
559	SET_FLAG (op, FLAG_WAS_WIZ);
560	fix_player (pl);
561	return 1;	515	return 1;
562	}	516	}
563		517
564	/* This pays for the item, and takes the proper amount of money off	518	/* This pays for the item, and takes the proper amount of money off
565	* the player.	519	* the player.
…		…
573	*	527	*
574	* pouch is the container (pouch or player) to remove the coins from.	528	* pouch is the container (pouch or player) to remove the coins from.
575	* to_pay is the required amount.	529	* to_pay is the required amount.
576	* returns the amount still missing after using "pouch".	530	* returns the amount still missing after using "pouch".
577	*/	531	*/
578	static uint64	532	static void
579	pay_from_container (object *pl, object *pouch, uint64 to_pay)	533	pay_from_container (object *pl, object *pouch, sint64 &to_pay)
580	{	534	{
581	int count, i;	535	int count, i;
582	uint64 remain;	536	object *tmp, *next;
583	object *tmp, *coin_objs[NUM_COINS], *next;
584	archetype *at;	537	archetype *at;
585		538
586	if (pouch->type != PLAYER && pouch->type != CONTAINER)	539	if (pouch->type != PLAYER && pouch->type != CONTAINER)
587	return to_pay;	540	return;
588		541
589	remain = to_pay;	542	object *coin_objs[NUM_COINS] = { 0 };
590	for (i = 0; i < NUM_COINS; i++)
591	coin_objs[i] = NULL;
592		543
593	/* This hunk should remove all the money objects from the player/container */	544	/* This hunk should remove all the money objects from the player/container */
594	for (tmp = pouch->inv; tmp; tmp = next)	545	for (tmp = pouch->inv; tmp; tmp = next)
595	{	546	{
596	next = tmp->below;	547	next = tmp->below;
597		548
598	if (tmp->type == MONEY)	549	if (tmp->type == MONEY)
599	{	550	{
600	for (i = 0; i < NUM_COINS; i++)	551	for (i = 0; i < NUM_COINS; i++)
601	{	552	{
602	if (!strcmp (coins[NUM_COINS - 1 - i], tmp->arch->name) && (tmp->value == tmp->arch->clone.value))	553	if (tmp->value == tmp->arch->value && !strcmp (coins[NUM_COINS - 1 - i], tmp->arch->archname))
603	{	554	{
604
605	/* This should not happen, but if it does, just *	555	// This should not happen, but if it does, just merge the two.
606	* merge the two. */
607	if (coin_objs[i] != NULL)	556	if (coin_objs [i])
608	{	557	{
609	LOG (llevError, "%s has two money entries of (%s)\n", &pouch->name, coins[NUM_COINS - 1 - i]);	558	LOG (llevError, "%s has two money entries of (%s)\n", &pouch->name, coins[NUM_COINS - 1 - i]);
610	remove_ob (tmp);
611	coin_objs[i]->nrof += tmp->nrof;	559	coin_objs[i]->nrof += tmp->nrof;
612	esrv_del_item (pl->contr, tmp->count);	560	tmp->destroy ();
613	free_object (tmp);
614	}	561	}
615	else	562	else
616	{	563	{
617	remove_ob (tmp);	564	tmp->remove ();
618	if (pouch->type == PLAYER)
619	esrv_del_item (pl->contr, tmp->count);
620	coin_objs[i] = tmp;	565	coin_objs[i] = tmp;
621	}	566	}
		567
622	break;	568	break;
623	}	569	}
624	}	570	}
		571
625	if (i == NUM_COINS)	572	if (i == NUM_COINS)
626	LOG (llevError, "in pay_for_item: Did not find string match for %s\n", &tmp->arch->name);	573	LOG (llevError, "in pay_for_item: Did not find string match for %s\n", &tmp->arch->archname);
627	}	574	}
628	}	575	}
629		576
630	/* Fill in any gaps in the coin_objs array - needed to make change. */	577	/* Fill in any gaps in the coin_objs array - needed to make change. */
631	/* Note that the coin_objs array goes from least value to greatest value */	578	/* Note that the coin_objs array goes from least value to greatest value */
632	for (i = 0; i < NUM_COINS; i++)	579	for (i = 0; i < NUM_COINS; i++)
633	if (coin_objs[i] == NULL)	580	if (!coin_objs[i])
634	{	581	{
635	at = find_archetype (coins[NUM_COINS - 1 - i]);	582	at = archetype::find (coins[NUM_COINS - 1 - i]);
		583
636	if (at == NULL)	584	if (at == NULL)
637	LOG (llevError, "Could not find %s archetype\n", coins[NUM_COINS - 1 - i]);	585	LOG (llevError, "Could not find %s archetype\n", coins[NUM_COINS - 1 - i]);
638	coin_objs[i] = arch_to_object (at);	586
		587	coin_objs[i] = at->instance ();
639	coin_objs[i]->nrof = 0;	588	coin_objs[i]->nrof = 0;
640	}	589	}
641		590
642	for (i = 0; i < NUM_COINS; i++)	591	for (i = 0; i < NUM_COINS; i++)
643	{	592	{
644	int num_coins;	593	object &coin = *coin_objs[i];
		594	sint64 num_coins = min ((to_pay + coin.value - 1) / coin.value, (sint64) coin.nrof);
		595	to_pay -= num_coins * coin.value;
645		596
646	if (coin_objs[i]->nrof * coin_objs[i]->value > remain)
647	{
648	num_coins = remain / coin_objs[i]->value;
649	if ((uint64) num_coins * (uint64) coin_objs[i]->value < remain)
650	num_coins++;
651	}
652	else
653	{
654	num_coins = coin_objs[i]->nrof;
655	}
656	remain -= (sint64) num_coins *(sint64) coin_objs[i]->value;
657
658	coin_objs[i]->nrof -= num_coins;	597	coin.nrof -= num_coins;
659	/* Now start making change. Start at the coin value	598	/* Now start making change. Start at the coin value
660	* below the one we just did, and work down to	599	* below the one we just did, and work down to
661	* the lowest value.	600	* the lowest value.
662	*/	601	*/
663	count = i - 1;	602	count = i - 1;
		603
664	while (remain < 0 && count >= 0)	604	while (to_pay < 0 && count >= 0)
665	{	605	{
666	num_coins = -remain / coin_objs[count]->value;	606	num_coins = (-to_pay) / coin_objs[count]->value;
667	coin_objs[count]->nrof += num_coins;	607	coin_objs[count]->nrof += num_coins;
668	remain += num_coins * coin_objs[count]->value;	608	to_pay += num_coins * coin_objs[count]->value;
669	count--;	609	count--;
670	}	610	}
671	}	611	}
		612
672	for (i = 0; i < NUM_COINS; i++)	613	for (i = 0; i < NUM_COINS; i++)
673	{
674	if (coin_objs[i]->nrof)	614	if (coin_objs[i]->nrof)
675	{
676	object *tmp = insert_ob_in_ob (coin_objs[i], pouch);	615	insert_ob_in_ob (coin_objs [i], pouch);
677
678	esrv_send_item (pl, tmp);
679	esrv_send_item (pl, pouch);
680	if (pl != pouch)
681	esrv_update_item (UPD_WEIGHT, pl, pouch);
682	if (pl->type != PLAYER)
683	{
684	esrv_send_item (pl, pl);
685	}
686	}
687	else	616	else
688	{	617	coin_objs[i]->destroy ();
689	free_object (coin_objs[i]);
690	}
691	}
692	return (remain);
693	}	618	}
694		619
695	/* Checks all unpaid items in op's inventory, adds up all the money they	620	/* Checks all unpaid items in op's inventory, adds up all the money they
696	* have, and checks that they can actually afford what they want to buy.	621	* have, and checks that they can actually afford what they want to buy.
697	* Returns 1 if they can, and 0 if they can't. also prints an appropriate message	622	* Returns 1 if they can, and 0 if they can't. also prints an appropriate message
698	* to the player	623	* to the player
699	*/	624	*/
700
701	int	625	int
702	can_pay (object *pl)	626	can_pay (object *pl)
703	{	627	{
704	int unpaid_count = 0, i;	628	int unpaid_count = 0;
705	uint64 unpaid_price = 0;	629	sint64 unpaid_price = 0;
706	uint64 player_wealth = query_money (pl);	630	sint64 player_wealth = query_money (pl);
707	object *item;
708	uint32 coincount[NUM_COINS];
709		631
710	if (!pl || pl->type != PLAYER)	632	if (!pl || pl->type != PLAYER)
711	{	633	{
712	LOG (llevError, "can_pay(): called against something that isn't a player\n");	634	LOG (llevError, "can_pay(): called against something that isn't a player\n");
713	return 0;	635	return 0;
714	}	636	}
715	for (i = 0; i < NUM_COINS; i++)	637
716	coincount[i] = 0;	638	for (object::depth_iterator item = pl->begin (); item != pl->end (); ++item)
717	for (item = pl->inv; item;)	639	if (item->flag [FLAG_UNPAID])
718	{
719	if QUERY_FLAG
720	(item, FLAG_UNPAID)
721	{	640	{
722	unpaid_count++;	641	unpaid_count++;
723	unpaid_price += query_cost (item, pl, F_BUY | F_SHOP);	642	unpaid_price += query_cost (item, pl, F_BUY | F_SHOP);
724	}	643	}
725	/* merely converting the player's monetary wealth won't do, if we did that,	644
726	* we could print the wrong numbers for the coins, so we count the money instead
727	*/
728	for (i = 0; i < NUM_COINS; i++)
729	if (!strcmp (coins[i], item->arch->name))
730	coincount[i] += item->nrof;
731	if (item->inv)
732	item = item->inv;
733	else if (item->below)
734	item = item->below;
735	else if (item->env && item->env != pl && item->env->below)
736	item = item->env->below;
737	else
738	item = NULL;
739	}
740	if (unpaid_price > player_wealth)	645	if (unpaid_price > player_wealth)
741	{	646	{
742	char buf[MAX_BUF];	647	dynbuf_text &buf = msg_dynbuf; buf.clear ();
743	char cost[MAX_BUF];
744	char missing[MAX_BUF];
745		648
746	sprintf (cost, "%s", cost_string_from_value (unpaid_price, 0));	649	buf << "You have " << unpaid_count
747	sprintf (missing, "%s", cost_string_from_value (unpaid_price - player_wealth, 0));	650	<< " unpaid item(s) that would cost you " << cost_string_from_value (unpaid_price, 0)
		651	<< ". You need another " << cost_string_from_value (unpaid_price - player_wealth, 0)
		652	<< " to be able to afford that. "
		653	"H<You cannot leave a shop without paying - drop unpaid items first to be able to leave.>";
748		654
749	sprintf (buf, "You have %d unpaid items that would cost you %s. You need another %s to be able to afford that.",	655	pl->failmsg (buf);
750	unpaid_count, cost, missing);	656
751	new_draw_info (NDI_UNIQUE, 0, pl, buf);
752	return 0;	657	return 0;
753	}	658	}
754	else	659	else
755	return 1;	660	return 1;
756	}	661	}
757
758		662
759	/* Better get_payment, descends containers looking for	663	/* Better get_payment, descends containers looking for
760	* unpaid items, and pays for them.	664	* unpaid items, and pays for them.
761	* returns 0 if the player still has unpaid items.	665	* returns 0 if the player still has unpaid items.
762	* returns 1 if the player has paid for everything.	666	* returns 1 if the player has paid for everything.
763	* pl is the player buying the stuff.	667	* pl is the player buying the stuff.
764	* op is the object we are examining. If op has
765	* and inventory, we examine that. IF there are objects
766	* below op, we descend down.
767	*/	668	*/
768	int	669	int
769	get_payment (object *pl, object *op)	670	get_payment (object *pl)
770	{	671	{
771	char buf[MAX_BUF];	672	for (;;)
772	int ret = 1;
773
774	if (op != NULL && op->inv)
775	ret = get_payment (pl, op->inv);
776
777	if (!ret)
778	return 0;
779
780	if (op != NULL && op->below)
781	ret = get_payment (pl, op->below);
782
783	if (!ret)
784	return 0;
785
786	if (op != NULL && QUERY_FLAG (op, FLAG_UNPAID))
787	{	673	{
788	strncpy (buf, query_cost_string (op, pl, F_BUY | F_SHOP), MAX_BUF);	674	next_item:
789	buf[MAX_BUF - 1] = '\0';
790	if (!pay_for_item (op, pl))
791	{
792	uint64 i = query_cost (op, pl, F_BUY | F_SHOP) - query_money (pl);
793		675
794	CLEAR_FLAG (op, FLAG_UNPAID);	676	for (object::depth_iterator op = pl->begin (); op != pl->end (); ++op)
795	new_draw_info_format (NDI_UNIQUE, 0, pl, "You lack %s to buy %s.", cost_string_from_value (i, 0), query_name (op));
796	SET_FLAG (op, FLAG_UNPAID);
797	return 0;
798	}	677	{
799	else	678	if (op->flag [FLAG_UNPAID])
800	{
801	object *tmp;
802	tag_t c = op->count;
803
804	CLEAR_FLAG (op, FLAG_UNPAID);
805	CLEAR_FLAG (op, FLAG_PLAYER_SOLD);
806	new_draw_info_format (NDI_UNIQUE, 0, op, "You paid %s for %s.", buf, query_name (op));
807	tmp = merge_ob (op, NULL);
808	if (pl->type == PLAYER)
809	{	679	{
810	if (tmp)	680	const char *buf = query_cost_string (op, pl, F_BUY | F_SHOP);
811	{ /* it was merged */	681
812	esrv_del_item (pl->contr, c);	682	if (!pay_for_item (op, pl))
813	op = tmp;	683	{
		684	sint64 i = query_cost (op, pl, F_BUY | F_SHOP) - query_money (pl);
		685
		686	op->clr_flag (FLAG_UNPAID);
		687	new_draw_info_format (NDI_UNIQUE, 0, pl, "You lack %s to buy %s.", cost_string_from_value (i, 0), query_name (op));
		688	op->set_flag (FLAG_UNPAID);
		689	return 0;
814	}	690	}
815	esrv_send_item (pl, op);	691	else
		692	{
		693	op->clr_flag (FLAG_UNPAID);
		694	op->clr_flag (FLAG_PLAYER_SOLD);
		695	new_draw_info_format (NDI_UNIQUE, 0, pl, "You paid %s for %s.", buf, query_name (op));
		696
		697	if (!merge_ob (op, op->env->inv))
		698	esrv_update_item (UPD_FLAGS, pl, op);
		699
		700	goto next_item;
		701	}
816	}	702	}
817	}	703	}
818	}	704
819	return 1;	705	return 1;
		706	}
820	}	707	}
821		708
822	/* written by elmex:	709	/* written by elmex:
823	* moved this code from sell_item () here to have a function	710	* moved this code from sell_item () here to have a function
824	* that pays the player an amount. Mainly put the code here to	711	* that pays the player an amount. Mainly put the code here to
…		…
829	* or put it on the ground under the player. This way the player can still	716	* or put it on the ground under the player. This way the player can still
830	* go somewhere and unload the money at a safe place.	717	* go somewhere and unload the money at a safe place.
831	*	718	*
832	*/	719	*/
833	void	720	void
834	pay_player (object *pl, uint64 amount)	721	pay_player (object *pl, sint64 amount)
835	{	722	{
836	int count = 0;	723	int count = 0;
837	archetype *at = 0;	724	archetype *at = 0;
838	object *pouch = 0, *tmp = 0;	725	object *pouch = 0;
839		726
840	for (count = 0; coins[count] != NULL; count++)	727	for (count = 0; coins[count]; count++)
841	{	728	{
842	at = find_archetype (coins[count]);	729	at = archetype::find (coins[count]);
843		730
844	if (at == NULL)	731	if (at == NULL)
845	LOG (llevError, "Could not find %s archetype\n", coins[count]);	732	LOG (llevError, "Could not find %s archetype\n", coins[count]);
846	else if ((amount / at->clone.value) > 0)	733	else if ((amount / at->value) > 0)
847	{	734	{
848	for (pouch = pl->inv; pouch; pouch = pouch->below)	735	for (pouch = pl->inv; pouch; pouch = pouch->below)
849	{	736	{
850	if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && pouch->race && strstr (pouch->race, "gold"))	737	if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && pouch->race.contains (shstr_gold))
851	{	738	{
852	int w = at->clone.weight * (100 - pouch->stats.Str) / 100;	739	int w = at->weight * (100 - pouch->stats.Str) / 100;
853	int n = amount / at->clone.value;	740	int n = amount / at->value;
854		741
855	if (w == 0)	742	if (w == 0)
856	w = 1; /* Prevent divide by zero */	743	w = 1; /* Prevent divide by zero */
857		744
858	if (n > 0 && (!pouch->weight_limit || pouch->carrying + w <= pouch->weight_limit))	745	if (n > 0 && (!pouch->weight_limit || pouch->carrying + w <= pouch->weight_limit))
859	{	746	{
860	if (pouch->weight_limit && (pouch->weight_limit - pouch->carrying) / w < n)	747	if (pouch->weight_limit && (pouch->weight_limit - pouch->carrying) / w < n)
861	n = (pouch->weight_limit - pouch->carrying) / w;	748	n = (pouch->weight_limit - pouch->carrying) / w;
862		749
863	tmp = arch_to_object (at);	750	object *tmp = at->instance ();
864	tmp->nrof = n;	751	tmp->nrof = n;
865	amount -= (uint64) tmp->nrof * (uint64) tmp->value;	752	amount -= tmp->nrof * tmp->value;
866	tmp = insert_ob_in_ob (tmp, pouch);	753	pouch->insert (tmp);
867	esrv_send_item (pl, tmp);
868	esrv_send_item (pl, pouch);
869	esrv_update_item (UPD_WEIGHT, pl, pouch);
870	esrv_send_item (pl, pl);
871	}	754	}
872	}	755	}
873	}	756	}
874		757
875	if (amount / at->clone.value > 0)	758	if (amount / at->value > 0)
876	{	759	{
877	tmp = arch_to_object (at);	760	object *tmp = at->instance ();
878	tmp->nrof = amount / tmp->value;	761	tmp->nrof = amount / tmp->value;
879	amount -= (uint64) tmp->nrof * (uint64) tmp->value;	762	amount -= tmp->nrof * tmp->value;
880	tmp = insert_ob_in_ob (tmp, pl);	763	pl->insert (tmp);
881	esrv_send_item (pl, tmp);
882	esrv_send_item (pl, pl);
883	}	764	}
884	}	765	}
885	}	766	}
886		767
887	if (amount != 0)	768	if (amount != 0)
888	#ifndef WIN32
889	LOG (llevError, "Warning - payment in pay_player () not zero: %llu\n", amount);	769	LOG (llevError, "Warning - payment in pay_player () not zero: %llu\n", amount);
890	#else
891	LOG (llevError, "Warning - payment in pay_player () not zero: %I64u\n", amount);
892	#endif
893	}	770	}
894		771
895	/* elmex: this is for the bank plugin :( */	772	/* elmex: this is for the bank plugin :( */
896	uint64	773	sint64
897	pay_player_arch (object *pl, const char *arch, uint64 amount)	774	pay_player_arch (object *pl, const char *arch, sint64 amount)
898	{	775	{
899	archetype *at = find_archetype (arch);
900	object *tmp = NULL;
901
902	if (at == NULL)
903	return 0;
904
905	if (amount > 0)	776	if (amount)
906	{	777	{
907	tmp = arch_to_object (at);	778	object *ob = archetype::get (arch);
		779
		780	if (!ob)
		781	return 0;
		782
908	tmp->nrof = amount;	783	ob->nrof = amount;
909	tmp = insert_ob_in_ob (tmp, pl);	784	pl->insert (ob);
910	esrv_send_item (pl, tmp);
911	esrv_send_item (pl, pl);
912	}	785	}
913		786
914	return 1;	787	return 1;
915	}	788	}
916		789
…		…
919	* buy item.	792	* buy item.
920	*	793	*
921	* Modified to fill available race: gold containers before dumping	794	* Modified to fill available race: gold containers before dumping
922	* remaining coins in character's inventory.	795	* remaining coins in character's inventory.
923	*/	796	*/
924	void	797	bool
925	sell_item (object *op, object *pl)	798	sell_item (object *op, object *pl)
926	{	799	{
927	uint64 amount = query_cost (op, pl, F_SELL | F_SHOP), extra_gain;	800	sint64 amount = query_cost (op, pl, F_SELL | F_SHOP), extra_gain;
928		801
929	if (pl == NULL || pl->type != PLAYER)	802	if (pl == NULL || pl->type != PLAYER)
930	{	803	{
931	LOG (llevDebug, "Object other than player tried to sell something.\n");	804	LOG (llevDebug, "Object other than player tried to sell something.\n");
932	return;	805	return false;
933	}	806	}
934		807
935	op->custom_name = 0;	808	op->custom_name = 0;
936		809
937	if (!amount)	810	if (!amount)
938	{	811	{
939	new_draw_info_format (NDI_UNIQUE, 0, pl, "We're not interested in %s.", query_name (op));	812	new_draw_info_format (NDI_UNIQUE, 0, pl, "We're not interested in %s.",
940		813	query_name (op));
941	/* Even if the character doesn't get anything for it, it may still be	814	// elmex: change: the player now gets the item back if the shop is not
942	* worth something. If so, make it unpaid	815	// interested in it.
943	*/
944	if (op->value)
945	{
946	SET_FLAG (op, FLAG_UNPAID);
947	SET_FLAG (op, FLAG_PLAYER_SOLD);
948	}
949
950	identify (op);
951	return;	816	return false;
952	}	817	}
953		818
954	/* We compare the price with the one for a player	819	/* We compare the price with the one for a player
955	* without bargaining skill.	820	* without bargaining skill.
956	* This determins the amount of exp (if any) gained for bargaining.	821	* This determins the amount of exp (if any) gained for bargaining.
957	* exp/10 -> 1 for each gold coin	822	* exp/10 -> 1 for each gold coin
958	*/	823	*/
959	extra_gain = amount - query_cost (op, pl, F_SELL | F_NO_BARGAIN | F_SHOP);	824	extra_gain = amount - query_cost (op, pl, F_SELL | F_NO_BARGAIN | F_SHOP);
960		825
961	if (extra_gain > 0)	826	if (extra_gain > 0)
962	change_exp (pl, extra_gain / 10, "bargaining", SK_EXP_NONE);	827	change_exp (pl, extra_gain / 10, shstr_bargaining, SK_EXP_NONE);
963		828
964	pay_player (pl, amount);	829	pay_player (pl, amount);
965		830
966	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));	831	new_draw_info_format (NDI_UNIQUE, 0, pl, "You receive %s for %s.",
		832	query_cost_string (op, pl, F_SELL | F_SHOP), query_name (op));
		833	pl->play_sound (sound_find ("shop_sell"));
967		834
968	SET_FLAG (op, FLAG_UNPAID);	835	op->set_flag (FLAG_UNPAID);
969	identify (op);	836	identify (op);
970	}
971		837
		838	return true;
		839	}
972		840
973	/* returns a double that is the ratio of the price that a shop will offer for	841	/* returns a double that is the ratio of the price that a shop will offer for
974	* item based on the shops specialisation. Does not take account of greed,	842	* item based on the shops specialisation. Does not take account of greed,
975	* returned value is between (2*SPECIALISATION_EFFECT-1) and 1 and in any	843	* returned value is between SPECIALISATION_EFFECT and 1.
976	* event is never less than 0.1 (calling functions divide by it)
977	*/	844	*/
978	static double	845	static double
979	shop_specialisation_ratio (const object *item, const mapstruct *map)	846	shop_specialisation_ratio (const object *item, const maptile *map)
980	{	847	{
981	shopitems *items = map->shopitems;	848	shopitems *items = map->shopitems;
982	double ratio = SPECIALISATION_EFFECT, likedness = 0.001;	849	int likedness = 0;
983	int i;	850	int i;
984		851
985	if (item == NULL)	852	if (item == NULL)
986	{	853	{
987	LOG (llevError, "shop_specialisation_ratio: passed a NULL item for map %s\n", map->path);	854	LOG (llevError, "shop_specialisation_ratio: passed a NULL item for map %s\n", &map->path);
988	return 0;	855	return 0;
989	}	856	}
		857
990	if (!item->type)	858	if (!item->type)
991	{	859	{
992	LOG (llevError, "shop_specialisation_ratio: passed an item with an invalid type\n");	860	LOG (llevError, "shop_specialisation_ratio: passed an item with an invalid type: %s\n", item->debug_desc ());
993	/*	861	/*
994	* I'm not really sure what the /right/ thing to do here is, these types of	862	* I'm not really sure what the /right/ thing to do here is, these types of
995	* item shouldn't exist anyway, but returning the ratio is probably the best bet.."	863	* item shouldn't exist anyway, but returning the ratio is probably the best bet.."
996	*/	864	*/
997	return ratio;	865	return SPECIALISATION_EFFECT;
998	}	866	}
		867
999	if (map->shopitems)	868	if (map->shopitems)
1000	{
1001	for (i = 0; i < items[0].index; i++)	869	for (i = 0; i < items[0].index; i++)
1002	if (items[i].typenum == item->type || (!items[i].typenum && likedness == 0.001))	870	if (items[i].typenum == item->type || (!items[i].typenum && !likedness))
1003	likedness = items[i].strength / 100.0;	871	likedness = items[i].strength;
1004	}	872
1005	if (likedness > 1.0)	873	if (likedness > 100)
1006	{ /* someone has been rather silly with the map headers. */	874	{ /* someone has been rather silly with the map headers. */
1007	LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is above 100%%\n", item->type, map->path);	875	LOG (llevDebug, "shop_specialisation ratio: item %s on map %s is above 100%%\n", item->debug_desc (), &map->path);
1008	likedness = 1.0;	876	likedness = 100;
1009	}	877	}
		878
1010	if (likedness < -1.0)	879	if (likedness < -100)
1011	{	880	{
1012	LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is below -100%%\n", item->type, map->path);	881	LOG (llevDebug, "shop_specialisation ratio: item %s on map %s is below -100%%\n", item->debug_desc (), &map->path);
1013	likedness = -1.0;	882	likedness = -100;
1014	}	883	}
1015	ratio = ratio + (1.0 - ratio) * likedness;	884
1016	if (ratio <= 0.1)	885	return lerp (double (likedness), -100., 100., SPECIALISATION_EFFECT, 1.);
1017	ratio = 0.1; /* if the ratio were much lower than this, we would get silly prices */
1018	return ratio;
1019	}	886	}
1020		887
1021	/*returns the greed of the shop on map, or 1 if it isn't specified. */	888	/*returns the greed of the shop on map, or 1 if it isn't specified. */
1022	static double	889	static double
1023	shop_greed (const mapstruct *map)	890	shop_greed (const maptile *map)
1024	{	891	{
1025	double greed = 1.0;
1026
1027	if (map->shopgreed)
1028	return map->shopgreed;	892	return map->shopgreed
1029	return greed;	893	? map->shopgreed
		894	: 1.;
1030	}	895	}
1031		896
1032	/* Returns a double based on how much the shopkeeper approves of the player.	897	/* Returns a double based on how much the shopkeeper approves of the player.
1033	* this is based on the race of the shopkeeper and that of the player.	898	* this is based on the race of the shopkeeper and that of the player.
1034	*/	899	*/
1035	double	900	double
1036	shopkeeper_approval (const mapstruct *map, const object *player)	901	shopkeeper_approval (const maptile *map, const object *player)
1037	{	902	{
1038	double approval = 1.0;	903	return map->shoprace && player->race != map->shoprace
1039		904	? DISLIKE_RATIO
1040	if (map->shoprace)	905	: 1.;
1041	{
1042	approval = NEUTRAL_RATIO;
1043	if (player->race && !strcmp (player->race, map->shoprace))
1044	approval = 1.0;
1045	}
1046	return approval;
1047	}	906	}
1048		907
1049	/* limit the value of items based on the wealth of the shop. If the item is close	908	/* limit the value of items based on the wealth of the shop. If the item is close
1050	* to the maximum value a shop will offer, we start to reduce it, if the item is	909	* to the maximum value a shop will offer, we start to reduce it, if the item is
1051	* below the minimum value the shop is prepared to trade in, then we don't	910	* below the minimum value the shop is prepared to trade in, then we don't
1052	* want it and offer nothing. If it isn't a shop, check whether we should do generic	911	* want it and offer nothing. If it isn't a shop, check whether we should do generic
1053	* value reduction.	912	* value reduction.
1054	*	913	*
1055	*/	914	*/
1056	static uint64	915	static sint64
1057	value_limit (uint64 val, int quantity, const object *who, int isshop)	916	value_limit (sint64 val, int quantity, const object *who, int isshop)
1058	{	917	{
1059	uint64 newval, unit_price, tmpshopmax;	918	sint64 newval, unit_price, tmpshopmax;
1060	mapstruct *map;	919	maptile *map;
1061		920
1062	unit_price = val / quantity;	921	unit_price = val / quantity;
1063		922
1064	if (!isshop || !who)	923	if (!isshop || !who)
1065	{	924	{
1066	if (unit_price > 250000)	925	if (unit_price > 250000)
1067	newval = (uint64) (250000. - pow (250000., .75) * 65. + pow (unit_price, .75) * 65.);	926	newval = (sint64) (250000. - pow (250000., .75) * 65. + pow (unit_price, .75) * 65.);
1068	else	927	else
1069	newval = unit_price;	928	newval = unit_price;
1070	}	929	}
1071	else	930	else
1072	{	931	{
…		…
1081	tmpshopmax = map->shopmax ? map->shopmax : 100000; // 20 royalties default	940	tmpshopmax = map->shopmax ? map->shopmax : 100000; // 20 royalties default
1082		941
1083	if (map->shopmin && unit_price < map->shopmin)	942	if (map->shopmin && unit_price < map->shopmin)
1084	return 0;	943	return 0;
1085	else if (unit_price > tmpshopmax / 2)	944	else if (unit_price > tmpshopmax / 2)
1086	newval = MIN ((tmpshopmax / 2) + isqrt (unit_price - tmpshopmax / 2), tmpshopmax);	945	newval = min ((tmpshopmax / 2) + isqrt (unit_price - tmpshopmax / 2), tmpshopmax);
1087	else	946	else
1088	newval = unit_price;	947	newval = unit_price;
1089	}	948	}
1090		949
1091	newval *= quantity;	950	newval *= quantity;
…		…
1095		954
1096	/* gives a desciption of the shop on their current map to the player op. */	955	/* gives a desciption of the shop on their current map to the player op. */
1097	int	956	int
1098	describe_shop (const object *op)	957	describe_shop (const object *op)
1099	{	958	{
		959	dynbuf_text buf;
1100	mapstruct *map = op->map;	960	maptile *map = op->map;
1101		961
1102	/*shopitems *items=map->shopitems; */	962	/*shopitems *items=map->shopitems; */
1103	int pos = 0, i;	963	int i;
1104	double opinion = 0;	964	double opinion = 0;
1105	char tmp[MAX_BUF] = "\0";
1106		965
1107	if (op->type != PLAYER)	966	if (op->type != PLAYER)
1108	return 0;	967	return 0;
1109		968
1110	/*check if there is a shop specified for this map */	969	/*check if there is a shop specified for this map */
1111	if (map->shopitems || map->shopgreed || map->shoprace || map->shopmin || map->shopmax)	970	if (map->shopitems || map->shopgreed || map->shoprace || map->shopmin || map->shopmax)
1112	{	971	{
1113	new_draw_info (NDI_UNIQUE, 0, op, "From looking at the nearby shop you determine that it trades in:");	972	buf << "From looking at the nearby shop you determine that it trades in ";
		973	int lastcomma = 0, prevcomma = 0;
		974
1114	if (map->shopitems)	975	if (map->shopitems)
1115	{
1116	for (i = 0; i < map->shopitems[0].index; i++)	976	for (i = 0; i < map->shopitems[0].index; i++)
		977	if (map->shopitems[i].name && map->shopitems[i].strength > 10)
1117	{	978	{
1118	if (map->shopitems[i].name && map->shopitems[i].strength > 10)	979	buf << map->shopitems[i].name_pl;
1119	{	980	prevcomma = lastcomma;
1120	snprintf (tmp + pos, sizeof (tmp) - pos, "%s, ", map->shopitems[i].name_pl);	981	lastcomma = buf.size (); // remember offset
1121	pos += strlen (tmp + pos);	982	buf << ", ";
1122	}
1123	}	983	}
		984
		985	if (lastcomma)
1124	}	986	{
1125	if (!pos)	987	buf.splice (lastcomma, 2);
		988
		989	if (prevcomma)
		990	buf.splice (prevcomma, 2, " and ");
		991	}
		992	else
1126	strcat (tmp, "a little of everything.");	993	buf << "a little of everything.";
1127		994
1128	/* format the string into a list */	995	buf << ".\n\n";
1129	make_list_like (tmp);
1130	new_draw_info_format (NDI_UNIQUE, 0, op, "%s", tmp);
1131		996
1132	if (map->shopmax)	997	if (map->shopmax)
1133	new_draw_info_format (NDI_UNIQUE, 0, op, "It won't trade for items above %s.", cost_string_from_value (map->shopmax, 0));	998	buf << "It won't trade for items above " << cost_string_from_value (map->shopmax, 0) << ".\n\n";
		999
1134	if (map->shopmin)	1000	if (map->shopmin)
1135	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));	1001	buf << "It won't trade in items worth less than " << cost_string_from_value (map->shopmin, 0) << ".\n\n";
		1002
1136	if (map->shopgreed)	1003	if (map->shopgreed)
1137	{	1004	{
1138	if (map->shopgreed > 2.0)	1005	if (map->shopgreed > 2.0)
1139	new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge massively.");	1006	buf << "It tends to overcharge massively.\n\n";
1140	else if (map->shopgreed > 1.5)	1007	else if (map->shopgreed > 1.5)
1141	new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge substantially.");	1008	buf << "It tends to overcharge substantially.\n\n";
1142	else if (map->shopgreed > 1.1)	1009	else if (map->shopgreed > 1.1)
1143	new_draw_info (NDI_UNIQUE, 0, op, "It tends to overcharge slightly.");	1010	buf << "It tends to overcharge slightly.\n\n";
1144	else if (map->shopgreed < 0.9)	1011	else if (map->shopgreed < 0.9)
1145	new_draw_info (NDI_UNIQUE, 0, op, "It tends to undercharge.");	1012	buf << "It tends to undercharge.\n\n";
1146	}	1013	}
		1014
1147	if (map->shoprace)	1015	if (map->shoprace)
1148	{	1016	{
1149	opinion = shopkeeper_approval (map, op);	1017	opinion = shopkeeper_approval (map, op);
		1018
1150	if (opinion > 0.8)	1019	if (opinion > 0.8)
1151	new_draw_info (NDI_UNIQUE, 0, op, "You think the shopkeeper likes you.");	1020	buf << "You think the shopkeeper likes you.\n\n";
1152	else if (opinion > 0.5)	1021	else if (opinion > 0.5)
1153	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper seems unconcerned by you.");	1022	buf << "The shopkeeper seems unconcerned by you.\n\n";
1154	else	1023	else
1155	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper seems to have taken a dislike to you.");	1024	buf << "The shopkeeper seems to have taken a dislike to you.\n\n";
1156	}	1025	}
1157	}	1026	}
1158	else	1027	else
1159	new_draw_info (NDI_UNIQUE, 0, op, "There is no shop nearby.");	1028	buf << "There is no shop nearby.\n\n";
		1029
		1030	op->contr->infobox (MSG_CHANNEL ("shopinfo"), buf);
1160		1031
1161	return 1;	1032	return 1;
1162	}	1033	}
		1034
1163	typedef struct shopinv	1035	struct shopinv
1164	{	1036	{
1165	char *item_sort;	1037	char *item_sort;
1166	char *item_real;	1038	char *item_real;
		1039	sint64 value;
1167	uint16 type;	1040	uint16 type;
1168	uint32 nrof;	1041	uint32 nrof;
1169	} shopinv;	1042	};
1170		1043
1171	/* There are a lot fo extra casts in here just to suppress warnings - it	1044	/* There are a lot fo extra casts in here just to suppress warnings - it
1172	* makes it look uglier than it really it.	1045	* makes it look uglier than it really it.
1173	* The format of the strings we get is type:name. So we first want to	1046	* The format of the strings we get is type:name. So we first want to
1174	* sort by type (numerical) - if the same type, then sort by name.	1047	* sort by type (numerical) - if the same type, then sort by name.
…		…
1178	{	1051	{
1179	shopinv *s1 = (shopinv *) a1, *s2 = (shopinv *) a2;	1052	shopinv *s1 = (shopinv *) a1, *s2 = (shopinv *) a2;
1180		1053
1181	if (s1->type < s2->type)	1054	if (s1->type < s2->type)
1182	return -1;	1055	return -1;
		1056
1183	if (s1->type > s2->type)	1057	if (s1->type > s2->type)
1184	return 1;	1058	return 1;
		1059
1185	/* the type is the same (what atoi gets), so do a strcasecmp to sort	1060	/* the type is the same (what atoi gets), so do a strcasecmp to sort
1186	* via alphabetical order	1061	* via alphabetical order
1187	*/	1062	*/
1188	return strcasecmp (s1->item_sort, s2->item_sort);	1063	return strcasecmp (s1->item_sort, s2->item_sort);
1189	}	1064	}
1190		1065
1191	static void	1066	static void
1192	add_shop_item (object *tmp, shopinv * items, int *numitems, int *numallocated)	1067	add_shop_item (object *tmp, shopinv * items, int *numitems, int *numallocated)
1193	{	1068	{
1194	#if 0
1195	char buf[MAX_BUF];
1196	#endif
1197	/* clear unpaid flag so that doesn't come up in query	1069	/* clear unpaid flag so that doesn't come up in query
1198	* string. We clear nrof so that we can better sort	1070	* string. We clear nrof so that we can better sort
1199	* the object names.	1071	* the object names.
1200	*/	1072	*/
1201		1073
1202	CLEAR_FLAG (tmp, FLAG_UNPAID);	1074	tmp->clr_flag (FLAG_UNPAID);
1203	items[*numitems].nrof = tmp->nrof;	1075	items[*numitems].nrof = tmp->nrof;
1204	/* Non mergable items have nrof of 0, but count them as one	1076	/* Non mergable items have nrof of 0, but count them as one
1205	* so the display is properly.	1077	* so the display is properly.
1206	*/	1078	*/
1207	if (tmp->nrof == 0)	1079	if (tmp->nrof == 0)
1208	items[*numitems].nrof++;	1080	items[*numitems].nrof++;
1209	items[*numitems].type = tmp->type;	1081	items[*numitems].type = tmp->type;
		1082
		1083	items[*numitems].value = tmp->value;
1210		1084
1211	switch (tmp->type)	1085	switch (tmp->type)
1212	{	1086	{
1213	#if 0	1087	#if 0
1214	case BOOTS:	1088	case BOOTS:
…		…
1216	case RING:	1090	case RING:
1217	case AMULET:	1091	case AMULET:
1218	case BRACERS:	1092	case BRACERS:
1219	case GIRDLE:	1093	case GIRDLE:
1220	sprintf (buf, "%s %s", query_base_name (tmp, 0), describe_item (tmp, NULL));	1094	sprintf (buf, "%s %s", query_base_name (tmp, 0), describe_item (tmp, NULL));
1221	items[*numitems].item_sort = strdup_local (buf);	1095	items[*numitems].item_sort = strdup (buf);
1222	sprintf (buf, "%s %s", query_name (tmp), describe_item (tmp, NULL));	1096	sprintf (buf, "%s %s", query_name (tmp), describe_item (tmp, NULL));
1223	items[*numitems].item_real = strdup_local (buf);	1097	items[*numitems].item_real = strdup (buf);
1224	(*numitems)++;	1098	(*numitems)++;
1225	break;	1099	break;
1226	#endif	1100	#endif
1227		1101
1228	default:	1102	default:
1229	items[*numitems].item_sort = strdup_local (query_base_name (tmp, 0));	1103	items[*numitems].item_sort = strdup (query_base_name (tmp, 0));
1230	items[*numitems].item_real = strdup_local (query_base_name (tmp, 1));	1104	items[*numitems].item_real = strdup (query_base_name (tmp, 1));
		1105	items[*numitems].value += tmp->value;
1231	(*numitems)++;	1106	(*numitems)++;
1232	break;	1107	break;
1233	}	1108	}
1234	SET_FLAG (tmp, FLAG_UNPAID);	1109
		1110	tmp->set_flag (FLAG_UNPAID);
1235	}	1111	}
1236		1112
1237	void	1113	void
1238	shop_listing (object *op)	1114	shop_listing (object *sign, object *op)
1239	{	1115	{
1240	int i, j, numitems = 0, numallocated = 0, nx, ny;	1116	int i, j, x1, x2, y1, y2;
1241	char *map_mark = (char *) calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1);	1117	const char *shop_coords = sign->kv [shstr_shop_coords];
1242	object *stack;	1118	object *stack;
1243	shopinv *items;	1119	shopinv *items;
1244		1120
1245	/* Should never happen, but just in case a monster does apply a sign */	1121	/* Should never happen, but just in case a monster does apply a sign */
1246	if (op->type != PLAYER)	1122	if (!op->is_player ())
1247	return;	1123	return;
1248		1124
1249	new_draw_info (NDI_UNIQUE, 0, op, "\nThe shop contains:");	1125	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1250		1126
1251	magic_mapping_mark (op, map_mark, 3);	1127	if (!(shop_coords && sscanf (shop_coords, "%d,%d,%d,%d", &x1, &y1, &x2, &y2)))
1252	items = (shopinv *) malloc (40 * sizeof (shopinv));	1128	{
		1129	x1 = 0;
		1130	y1 = 0;
		1131	x2 = op->map->width - 1;
		1132	y2 = op->map->height - 1;
		1133	}
		1134
1253	numallocated = 40;	1135	int numallocated = 40;
		1136	int numitems = 0;
		1137	items = (shopinv *)malloc (sizeof (shopinv) * numallocated);
1254		1138
1255	/* Find all the appropriate items */	1139	/* Find all the appropriate items */
1256	for (i = 0; i < MAP_WIDTH (op->map); i++)	1140	for (i = x1; i <= x2; i++)
1257	{	1141	for (j = y1; j < y2; j++)
1258	for (j = 0; j < MAP_HEIGHT (op->map); j++)	1142	if (op->map->is_in_shop (i, j))
1259	{
1260	/* magic map code now centers the map on the object at MAGIC_MAP_HALF.
1261	*	1143	{
1262	*/	1144	stack = GET_MAP_OB (op->map, i, j);
1263	nx = i - op->x + MAGIC_MAP_HALF;
1264	ny = j - op->y + MAGIC_MAP_HALF;
1265	/* unlikely, but really big shops could run into this issue */
1266	if (nx < 0 || ny < 0 || nx > MAGIC_MAP_SIZE || ny > MAGIC_MAP_SIZE)
1267	continue;
1268		1145
1269	if (map_mark[nx + MAGIC_MAP_SIZE * ny] & FACE_FLOOR)	1146	while (stack)
1270	{	1147	{
1271	stack = get_map_ob (op->map, i, j);	1148	if (stack->flag [FLAG_UNPAID])
1272
1273	while (stack)
1274	{	1149	{
1275	if (QUERY_FLAG (stack, FLAG_UNPAID))
1276	{
1277	if (numitems == numallocated)	1150	if (numitems == numallocated)
1278	{
1279	items = (shopinv *) realloc (items, sizeof (shopinv) * (numallocated + 10));	1151	items = (shopinv *)realloc (items, sizeof (shopinv) * (numallocated *= 2));
1280	numallocated += 10;	1152
1281	}
1282	add_shop_item (stack, items, &numitems, &numallocated);	1153	add_shop_item (stack, items, &numitems, &numallocated);
1283	}
1284	stack = stack->above;
1285	}	1154	}
		1155
		1156	stack = stack->above;
1286	}	1157	}
1287	}	1158	}
1288	}	1159
1289	free (map_mark);	1160	buf << (numitems ? "T<This shop contains:>\n\n"
1290	if (numitems == 0)	1161	: "T<This shop is currently empty.>");
1291	{	1162
1292	new_draw_info (NDI_UNIQUE, 0, op, "The shop is currently empty.\n");
1293	free (items);
1294	return;
1295	}
1296	qsort (items, numitems, sizeof (shopinv), (int (*)(const void *, const void *)) shop_sort);	1163	qsort (items, numitems, sizeof (shopinv), (int (*)(const void *, const void *)) shop_sort);
1297		1164
1298	for (i = 0; i < numitems; i++)	1165	for (i = 0; i < numitems; i++)
1299	{	1166	{
1300	/* Collapse items of the same name together */	1167	/* Collapse items of the same name together */
1301	if ((i + 1) < numitems && !strcmp (items[i].item_real, items[i + 1].item_real))	1168	if ((i + 1) < numitems && !strcmp (items[i].item_real, items[i + 1].item_real))
1302	{
1303	items[i + 1].nrof += items[i].nrof;	1169	items[i + 1].nrof += items[i].nrof;
1304	free (items[i].item_sort);
1305	free (items[i].item_real);
1306	}
1307	else	1170	else
1308	{	1171	{
1309	new_draw_info_format (NDI_UNIQUE, 0, op, "%d %s",	1172	buf.printf (
1310	items[i].nrof ? items[i].nrof : 1, items[i].nrof == 1 ? items[i].item_sort : items[i].item_real);	1173	" %4d %s\n for %s\n",
		1174	items[i].nrof ? items[i].nrof : 1,
		1175	items[i].nrof == 1 ? items[i].item_sort : items[i].item_real,
		1176	cost_string_from_value (items[i].value, op->flag [FLAG_WIZ] ? 0 : 1));
		1177	}
		1178
1311	free (items[i].item_sort);	1179	free (items[i].item_sort);
1312	free (items[i].item_real);	1180	free (items[i].item_real);
1313	}
1314	}	1181	}
		1182
		1183	op->contr->infobox (MSG_CHANNEL ("shopitems"), buf);
		1184
1315	free (items);	1185	free (items);
1316	}	1186	}
1317		1187
1318	/* elmex: this function checks whether the object is in a shop */	1188	/* elmex: this function checks whether we are in a shop or not
		1189	- change 2007-11-26: enhanced the O(n) case by stopping at the first
		1190	floor tile. this possibly will make map bugs where shopfloors are above
		1191	floors more obvious.
		1192	*/
1319	bool	1193	bool
1320	is_in_shop (object *o)	1194	maptile::is_in_shop (int x, int y) const
1321	{	1195	{
1322	if (!o->map)
1323	return false;
1324
1325	return is_in_shop (o->map, o->x, o->y);
1326	}
1327
1328	/* elmex: this function checks whether we are in a shop or not */
1329	bool
1330	is_in_shop (mapstruct *map, int x, int y)
1331	{
1332	for (object *floor = get_map_ob (map, x, y); floor; floor = floor->above)	1196	for (object *floor = at (x, y).bot; floor; floor = floor->above)
		1197	if (floor->flag [FLAG_IS_FLOOR])
1333	if (floor->type == SHOP_FLOOR)	1198	return floor->type == SHOP_FLOOR;
1334	return true;
1335		1199
1336	return false;	1200	return false;
1337	}	1201	}
		1202

Diff Legend

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