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.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.81 by root, Wed Apr 28 19:20:48 2010 UTC

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

Diff Legend

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