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.5 by root, Tue Aug 29 07:34:00 2006 UTC vs.
Revision 1.32 by root, Thu Feb 8 13:41:44 2007 UTC

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

Diff Legend

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