ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/treasure.C

Comparing deliantra/server/common/treasure.C (file contents):
Revision 1.12 by root, Mon Sep 4 13:55:54 2006 UTC vs.
Revision 1.31 by pippijn, Sat Jan 6 14:42:29 2007 UTC

1
2	/*
3	* static char *rcs_treasure_c =
4	* "$Id: treasure.C,v 1.12 2006/09/04 13:55:54 root Exp $";
5	*/
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
		4	Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	6	Copyright (C) 1992 Frank Tore Johansen
12		7
13	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
14	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
…		…
22		17
23	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
24	along with this program; if not, write to the Free Software	19	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		21
27	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	The authors can be reached via e-mail at <crossfire@schmorp.de>
28	*/	23	*/
29		24
30	#define ALLOWED_COMBINATION	25	#define ALLOWED_COMBINATION
31		26
32	/* TREASURE_DEBUG does some checking on the treasurelists after loading.	27	/* TREASURE_DEBUG does some checking on the treasurelists after loading.
…		…
35	* left on	30	* left on
36	*/	31	*/
37	#define TREASURE_DEBUG	32	#define TREASURE_DEBUG
38		33
39	/* TREASURE_VERBOSE enables copious output concerning artifact generation */	34	/* TREASURE_VERBOSE enables copious output concerning artifact generation */
		35
40	/* #define TREASURE_VERBOSE */	36	/* #define TREASURE_VERBOSE */
41		37
42	#include <global.h>	38	#include <global.h>
43	#include <treasure.h>	39	#include <treasure.h>
44	#include <funcpoint.h>	40	#include <funcpoint.h>
45	#include <loader.h>	41	#include <loader.h>
46		42
47		43
48	static void change_treasure (treasure * t, object * op); /* overrule default values */	44	static void change_treasure (treasure *t, object *op); /* overrule default values */
49	extern char *spell_mapping[];	45	extern char *spell_mapping[];
50		46
51	/*	47	/*
52	* Initialize global archtype pointers:	48	* Initialize global archtype pointers:
53	*/	49	*/
54		50
55	void	51	void
56	init_archetype_pointers ()	52	init_archetype_pointers ()
57	{	53	{
58	int prev_warn = warn_archetypes;	54	int prev_warn = warn_archetypes;
		55
59	warn_archetypes = 1;	56	warn_archetypes = 1;
60	if (ring_arch == NULL)	57	if (ring_arch == NULL)
61	ring_arch = find_archetype ("ring");	58	ring_arch = archetype::find ("ring");
62	if (amulet_arch == NULL)	59	if (amulet_arch == NULL)
63	amulet_arch = find_archetype ("amulet");	60	amulet_arch = archetype::find ("amulet");
64	if (staff_arch == NULL)	61	if (staff_arch == NULL)
65	staff_arch = find_archetype ("staff");	62	staff_arch = archetype::find ("staff");
66	if (crown_arch == NULL)	63	if (crown_arch == NULL)
67	crown_arch = find_archetype ("crown");	64	crown_arch = archetype::find ("crown");
68	warn_archetypes = prev_warn;	65	warn_archetypes = prev_warn;
69	}	66	}
70		67
71	/*	68	/*
72	* Allocate and return the pointer to an empty treasurelist structure.	69	* Allocate and return the pointer to an empty treasurelist structure.
…		…
108	while (fgets (buf, MAX_BUF, fp) != NULL)	105	while (fgets (buf, MAX_BUF, fp) != NULL)
109	{	106	{
110	(*line)++;	107	(*line)++;
111		108
112	if (*buf == '#')	109	if (*buf == '#')
113	continue;	110	continue;
114	if ((cp = strchr (buf, '\n')) != NULL)	111	if ((cp = strchr (buf, '\n')) != NULL)
115	*cp = '\0';	112	*cp = '\0';
116	cp = buf;	113	cp = buf;
117	while (isspace (*cp)) /* Skip blanks */	114	while (isspace (*cp)) /* Skip blanks */
118	cp++;	115	cp++;
119		116
120	if (sscanf (cp, "arch %s", variable))	117	if (sscanf (cp, "arch %s", variable))
121	{	118	{
122	if ((t->item = find_archetype (variable)) == NULL)	119	if ((t->item = archetype::find (variable)) == NULL)
123	LOG (llevError, "Treasure lacks archetype: %s\n", variable);	120	LOG (llevError, "Treasure lacks archetype: %s\n", variable);
124	}	121	}
125	else if (sscanf (cp, "list %s", variable))	122	else if (sscanf (cp, "list %s", variable))
126	t->name = variable;	123	t->name = variable;
127	else if (sscanf (cp, "change_name %s", variable))	124	else if (sscanf (cp, "change_name %s", variable))
128	t->change_arch.name = variable;	125	t->change_arch.name = variable;
129	else if (sscanf (cp, "change_title %s", variable))	126	else if (sscanf (cp, "change_title %s", variable))
130	t->change_arch.title = variable;	127	t->change_arch.title = variable;
131	else if (sscanf (cp, "change_slaying %s", variable))	128	else if (sscanf (cp, "change_slaying %s", variable))
132	t->change_arch.slaying = variable;	129	t->change_arch.slaying = variable;
133	else if (sscanf (cp, "chance %d", &value))	130	else if (sscanf (cp, "chance %d", &value))
134	t->chance = (uint8) value;	131	t->chance = (uint8) value;
135	else if (sscanf (cp, "nrof %d", &value))	132	else if (sscanf (cp, "nrof %d", &value))
136	t->nrof = (uint16) value;	133	t->nrof = (uint16) value;
137	else if (sscanf (cp, "magic %d", &value))	134	else if (sscanf (cp, "magic %d", &value))
138	t->magic = (uint8) value;	135	t->magic = (uint8) value;
139	else if (!strcmp (cp, "yes"))	136	else if (!strcmp (cp, "yes"))
140	t->next_yes = load_treasure (fp, line);	137	t->next_yes = load_treasure (fp, line);
141	else if (!strcmp (cp, "no"))	138	else if (!strcmp (cp, "no"))
142	t->next_no = load_treasure (fp, line);	139	t->next_no = load_treasure (fp, line);
143	else if (!strcmp (cp, "end"))	140	else if (!strcmp (cp, "end"))
144	return t;	141	return t;
145	else if (!strcmp (cp, "more"))	142	else if (!strcmp (cp, "more"))
146	{	143	{
147	t->next = load_treasure (fp, line);	144	t->next = load_treasure (fp, line);
148	return t;	145	return t;
149	}	146	}
150	else	147	else
151	LOG (llevError, "Unknown treasure-command: '%s', last entry %s, line %d\n", cp, &t->name, *line);	148	LOG (llevError, "Unknown treasure-command: '%s', last entry %s, line %d\n", cp, &t->name, *line);
152	}	149	}
153	LOG (llevError, "treasure lacks 'end'.\n");	150	LOG (llevError, "treasure lacks 'end'.\n");
154	return t;	151	return t;
155	}	152	}
156		153
157	#ifdef TREASURE_DEBUG	154	#ifdef TREASURE_DEBUG
		155
158	/* recursived checks the linked list. Treasurelist is passed only	156	/* recursived checks the linked list. Treasurelist is passed only
159	* so that the treasure name can be printed out	157	* so that the treasure name can be printed out
160	*/	158	*/
161	static void	159	static void
162	check_treasurelist (const treasure * t, const treasurelist * tl)	160	check_treasurelist (const treasure *t, const treasurelist * tl)
163	{	161	{
164	if (t->item == NULL && t->name == NULL)
165	LOG (llevError, "Treasurelist %s has element with no name or archetype\n", &tl->name);
166	if (t->chance >= 100 && t->next_yes && (t->next || t->next_no))	162	if (t->chance >= 100 && t->next_yes && (t->next || t->next_no))
167	LOG (llevError, "Treasurelist %s has element that has 100%% generation, next_yes field as well as next or next_no\n", &tl->name);	163	LOG (llevError, "Treasurelist %s has element that has 100%% generation, next_yes field as well as next or next_no\n", &tl->name);
168	/* find_treasurelist will print out its own error message */	164	/* find_treasurelist will print out its own error message */
169	if (t->name && *t->name)	165	if (t->name && *t->name)
170	(void) find_treasurelist (t->name);	166	find_treasurelist (t->name);
171	if (t->next)	167	if (t->next)
172	check_treasurelist (t->next, tl);	168	check_treasurelist (t->next, tl);
173	if (t->next_yes)	169	if (t->next_yes)
174	check_treasurelist (t->next_yes, tl);	170	check_treasurelist (t->next_yes, tl);
175	if (t->next_no)	171	if (t->next_no)
…		…
199	}	195	}
200	while (fgets (buf, MAX_BUF, fp) != NULL)	196	while (fgets (buf, MAX_BUF, fp) != NULL)
201	{	197	{
202	line++;	198	line++;
203	if (*buf == '#')	199	if (*buf == '#')
204	continue;	200	continue;
205		201
206	if (sscanf (buf, "treasureone %s\n", name) || sscanf (buf, "treasure %s\n", name))	202	if (sscanf (buf, "treasureone %s\n", name) || sscanf (buf, "treasure %s\n", name))
207	{	203	{
208	treasurelist *tl = get_empty_treasurelist ();	204	treasurelist *tl = get_empty_treasurelist ();
		205
209	tl->name = name;	206	tl->name = name;
210	if (previous == NULL)	207	if (previous == NULL)
211	first_treasurelist = tl;	208	first_treasurelist = tl;
212	else	209	else
213	previous->next = tl;	210	previous->next = tl;
214	previous = tl;	211	previous = tl;
215	tl->items = load_treasure (fp, &line);	212	tl->items = load_treasure (fp, &line);
216		213
217	/* This is a one of the many items on the list should be generated.	214	/* This is a one of the many items on the list should be generated.
218	* Add up the chance total, and check to make sure the yes & no	215	* Add up the chance total, and check to make sure the yes & no
219	* fields of the treasures are not being used.	216	* fields of the treasures are not being used.
220	*/	217	*/
221	if (!strncmp (buf, "treasureone", 11))	218	if (!strncmp (buf, "treasureone", 11))
222	{	219	{
223	for (t = tl->items; t != NULL; t = t->next)	220	for (t = tl->items; t != NULL; t = t->next)
224	{	221	{
225	#ifdef TREASURE_DEBUG	222	#ifdef TREASURE_DEBUG
226	if (t->next_yes || t->next_no)	223	if (t->next_yes || t->next_no)
227	{	224	{
228	LOG (llevError, "Treasure %s is one item, but on treasure %s\n", &tl->name, t->item ? &t->item->name : &t->name);	225	LOG (llevError, "Treasure %s is one item, but on treasure %s\n", &tl->name, t->item ? &t->item->name : &t->name);
229	LOG (llevError, " the next_yes or next_no field is set\n");	226	LOG (llevError, " the next_yes or next_no field is set\n");
230	}	227	}
231	#endif	228	#endif
232	tl->total_chance += t->chance;	229	tl->total_chance += t->chance;
233	}	230	}
234	}	231	}
235	}	232	}
236	else	233	else
237	LOG (llevError, "Treasure-list %s didn't understand: %s, line %d\n", filename, buf, line);	234	LOG (llevError, "Treasure-list %s didn't understand: %s, line %d\n", filename, buf, line);
238	}	235	}
239	close_and_delete (fp, comp);	236	close_and_delete (fp, comp);
240		237
241	#ifdef TREASURE_DEBUG	238	#ifdef TREASURE_DEBUG
242	/* Perform some checks on how valid the treasure data actually is.	239	/* Perform some checks on how valid the treasure data actually is.
…		…
255	*/	252	*/
256		253
257	treasurelist *	254	treasurelist *
258	find_treasurelist (const char *name)	255	find_treasurelist (const char *name)
259	{	256	{
260	/* Special cases - randomitems of NULL is to override default. If	257	shstr_cmp name_ (name);
261	* first_treasurelist is null, it means we are on the first pass of	258
262	* of loading archetypes, so for now, just return - second pass will
263	* init these values.
264	*/
265	if (!name)	259	if (!name_)
266	return 0;	260	return 0;
267		261
268	if (const char *tmp = shstr::find (name))
269	for (treasurelist *tl = first_treasurelist; tl != 0; tl = tl->next)	262	for (treasurelist *tl = first_treasurelist; tl != 0; tl = tl->next)
270	if (tmp == tl->name)	263	if (name_ == tl->name)
271	return tl;	264	return tl;
272		265
273	if (first_treasurelist)	266	if (first_treasurelist)
274	LOG (llevError, "Couldn't find treasurelist %s\n", name);	267	LOG (llevError, "Couldn't find treasurelist %s\n", name);
275		268
276	return 0;	269	return 0;
…		…
286	* being generated.	279	* being generated.
287	* If flag is GT_INVISIBLE, only invisible objects are generated (ie, only	280	* If flag is GT_INVISIBLE, only invisible objects are generated (ie, only
288	* abilities. This is used by summon spells, thus no summoned monsters	281	* abilities. This is used by summon spells, thus no summoned monsters
289	* start with equipment, but only their abilities).	282	* start with equipment, but only their abilities).
290	*/	283	*/
291
292
293	static void	284	static void
294	put_treasure (object * op, object * creator, int flags)	285	put_treasure (object *op, object *creator, int flags)
295	{	286	{
296	object *tmp;	287	object *tmp;
297		288
298	/* Bit of a hack - spells should never be put onto the map. The entire	289	/* Bit of a hack - spells should never be put onto the map. The entire
299	* treasure stuff is a problem - there is no clear idea of knowing	290	* treasure stuff is a problem - there is no clear idea of knowing
300	* this is the original object, or if this is an object that should be created	291	* this is the original object, or if this is an object that should be created
301	* by another object.	292	* by another object.
302	*/	293	*/
303	if (flags & GT_ENVIRONMENT && op->type != SPELL)	294	if (flags & GT_ENVIRONMENT && op->type != SPELL)
304	{	295	{
305	op->x = creator->x;
306	op->y = creator->y;
307	SET_FLAG (op, FLAG_OBJ_ORIGINAL);	296	SET_FLAG (op, FLAG_OBJ_ORIGINAL);
308	insert_ob_in_map (op, creator->map, op, INS_NO_MERGE | INS_NO_WALK_ON);	297	op->insert_at (creator, creator, INS_NO_MERGE | INS_NO_WALK_ON);
309	}	298	}
310	else	299	else
311	{	300	{
312	op = insert_ob_in_ob (op, creator);	301	op = creator->insert (op);
		302
313	if ((flags & GT_APPLY) && QUERY_FLAG (creator, FLAG_MONSTER))	303	if ((flags & GT_APPLY) && QUERY_FLAG (creator, FLAG_MONSTER))
314	monster_check_apply (creator, op);	304	monster_check_apply (creator, op);
		305
315	if ((flags & GT_UPDATE_INV) && (tmp = is_player_inv (creator)) != NULL)	306	if ((flags & GT_UPDATE_INV) && (tmp = creator->in_player ()))
316	esrv_send_item (tmp, op);	307	esrv_send_item (tmp, op);
317	}	308	}
318	}	309	}
319		310
320	/* if there are change_xxx commands in the treasure, we include the changes	311	/* if there are change_xxx commands in the treasure, we include the changes
321	* in the generated object	312	* in the generated object
…		…
343	object *tmp;	334	object *tmp;
344		335
345	if ((int) t->chance >= 100 || (RANDOM () % 100 + 1) < (int) t->chance)	336	if ((int) t->chance >= 100 || (RANDOM () % 100 + 1) < (int) t->chance)
346	{	337	{
347	if (t->name)	338	if (t->name)
348	{	339	{
349	if (strcmp (t->name, "NONE") && difficulty >= t->magic)	340	if (difficulty >= t->magic)
350	create_treasure (find_treasurelist (t->name), op, flag, difficulty, tries);	341	{
351	}	342	treasurelist *tl = find_treasurelist (t->name);
		343	if (tl)
		344	create_treasure (tl, op, flag, difficulty, tries);
		345	}
		346	}
352	else	347	else
353	{	348	{
354	if (t->item->clone.invisible != 0 || !(flag & GT_INVISIBLE))	349	if (t->item && (t->item->clone.invisible != 0 || !(flag & GT_INVISIBLE)))
355	{	350	{
356	tmp = arch_to_object (t->item);	351	tmp = arch_to_object (t->item);
357	if (t->nrof && tmp->nrof <= 1)	352	if (t->nrof && tmp->nrof <= 1)
358	tmp->nrof = RANDOM () % ((int) t->nrof) + 1;	353	tmp->nrof = RANDOM () % ((int) t->nrof) + 1;
359	fix_generated_item (tmp, op, difficulty, t->magic, flag);	354	fix_generated_item (tmp, op, difficulty, t->magic, flag);
360	change_treasure (t, tmp);	355	change_treasure (t, tmp);
361	put_treasure (tmp, op, flag);	356	put_treasure (tmp, op, flag);
362	}	357	}
363	}	358	}
364		359
365	if (t->next_yes != NULL)	360	if (t->next_yes != NULL)
366	create_all_treasures (t->next_yes, op, flag, difficulty, tries);	361	create_all_treasures (t->next_yes, op, flag, difficulty, tries);
367	}	362	}
368	else if (t->next_no != NULL)	363	else if (t->next_no != NULL)
369	create_all_treasures (t->next_no, op, flag, difficulty, tries);	364	create_all_treasures (t->next_no, op, flag, difficulty, tries);
370		365
371	if (t->next != NULL)	366	if (t->next != NULL)
372	create_all_treasures (t->next, op, flag, difficulty, tries);	367	create_all_treasures (t->next, op, flag, difficulty, tries);
373	}	368	}
374		369
375	void	370	void
376	create_one_treasure (treasurelist *tl, object * op, int flag, int difficulty, int tries)	371	create_one_treasure (treasurelist * tl, object *op, int flag, int difficulty, int tries)
377	{	372	{
378	int value = RANDOM () % tl->total_chance;	373	int value = RANDOM () % tl->total_chance;
379	treasure *t;	374	treasure *t;
380		375
381	if (tries++ > 100)	376	if (tries++ > 100)
…		…
387	for (t = tl->items; t != NULL; t = t->next)	382	for (t = tl->items; t != NULL; t = t->next)
388	{	383	{
389	value -= t->chance;	384	value -= t->chance;
390		385
391	if (value < 0)	386	if (value < 0)
392	break;	387	break;
393	}	388	}
394		389
395	if (!t || value >= 0)	390	if (!t || value >= 0)
396	{	391	{
397	LOG (llevError, "create_one_treasure: got null object or not able to find treasure\n");	392	LOG (llevError, "create_one_treasure: got null object or not able to find treasure\n");
…		…
399	return;	394	return;
400	}	395	}
401		396
402	if (t->name)	397	if (t->name)
403	{	398	{
404	if (!strcmp (t->name, "NONE"))
405	return;
406
407	if (difficulty >= t->magic)	399	if (difficulty >= t->magic)
408	create_treasure (find_treasurelist (t->name), op, flag, difficulty, tries);	400	{
		401	treasurelist *tl = find_treasurelist (t->name);
		402	if (tl)
		403	create_treasure (tl, op, flag, difficulty, tries);
		404	}
409	else if (t->nrof)	405	else if (t->nrof)
410	create_one_treasure (tl, op, flag, difficulty, tries);	406	create_one_treasure (tl, op, flag, difficulty, tries);
411		407
412	return;	408	return;
413	}	409	}
414		410
415	if ((t->item && t->item->clone.invisible != 0) || flag != GT_INVISIBLE)	411	if (t->item && (t->item->clone.invisible != 0 || flag != GT_INVISIBLE))
416	{	412	{
417	object *tmp = arch_to_object (t->item);	413	object *tmp = arch_to_object (t->item);
418		414
419	if (!tmp)	415	if (!tmp)
420	return;	416	return;
421		417
422	if (t->nrof && tmp->nrof <= 1)	418	if (t->nrof && tmp->nrof <= 1)
423	tmp->nrof = RANDOM () % ((int) t->nrof) + 1;	419	tmp->nrof = RANDOM () % ((int) t->nrof) + 1;
424		420
425	// fix_generated_item (tmp, op, difficulty, t->magic, flag);	421	fix_generated_item (tmp, op, difficulty, t->magic, flag);
426	// change_treasure (t, tmp);	422	change_treasure (t, tmp);
427	put_treasure (tmp, op, flag);	423	put_treasure (tmp, op, flag);
428	}	424	}
429	}	425	}
430		426
431	/* This calls the appropriate treasure creation function. tries is passed	427	/* This calls the appropriate treasure creation function. tries is passed
…		…
434	* list transitions, or so that excessively good treasure will not be	430	* list transitions, or so that excessively good treasure will not be
435	* created on weak maps, because it will exceed the number of allowed tries	431	* created on weak maps, because it will exceed the number of allowed tries
436	* to do that.	432	* to do that.
437	*/	433	*/
438	void	434	void
439	create_treasure (treasurelist * t, object * op, int flag, int difficulty, int tries)	435	create_treasure (treasurelist *tl, object *op, int flag, int difficulty, int tries)
440	{	436	{
441		437
442	if (tries++ > 100)	438	if (tries++ > 100)
443	{	439	{
444	LOG (llevDebug, "createtreasure: tries exceeded 100, returning without making treasure\n");	440	LOG (llevDebug, "createtreasure: tries exceeded 100, returning without making treasure\n");
445	return;	441	return;
446	}	442	}
447	if (t->total_chance)	443	if (tl->total_chance)
448	create_one_treasure (t, op, flag, difficulty, tries);	444	create_one_treasure (tl, op, flag, difficulty, tries);
449	else	445	else
450	create_all_treasures (t->items, op, flag, difficulty, tries);	446	create_all_treasures (tl->items, op, flag, difficulty, tries);
451	}	447	}
452		448
453	/* This is similar to the old generate treasure function. However,	449	/* This is similar to the old generate treasure function. However,
454	* it instead takes a treasurelist. It is really just a wrapper around	450	* it instead takes a treasurelist. It is really just a wrapper around
455	* create_treasure. We create a dummy object that the treasure gets	451	* create_treasure. We create a dummy object that the treasure gets
456	* inserted into, and then return that treausre	452	* inserted into, and then return that treausre
457	*/	453	*/
458	object *	454	object *
459	generate_treasure (treasurelist * t, int difficulty)	455	generate_treasure (treasurelist *tl, int difficulty)
460	{	456	{
		457	difficulty = clamp (difficulty, 1, settings.max_level);
		458
461	object *ob = get_object (), *tmp;	459	object *ob = object::create (), *tmp;
462		460
463	create_treasure (t, ob, 0, difficulty, 0);	461	create_treasure (tl, ob, 0, difficulty, 0);
464		462
465	/* Don't want to free the object we are about to return */	463	/* Don't want to free the object we are about to return */
466	tmp = ob->inv;	464	tmp = ob->inv;
467	if (tmp != NULL)	465	if (tmp != NULL)
468	remove_ob (tmp);	466	tmp->remove ();
		467
469	if (ob->inv)	468	if (ob->inv)
470	{
471	LOG (llevError, "In generate treasure, created multiple objects.\n");	469	LOG (llevError, "In generate treasure, created multiple objects.\n");
472	}	470
473	free_object (ob);	471	ob->destroy ();
474	return tmp;	472	return tmp;
475	}	473	}
476		474
477	/*	475	/*
478	* This is a new way of calculating the chance for an item to have	476	* This is a new way of calculating the chance for an item to have
…		…
480	* The array has two arguments, the difficulty of the level, and the	478	* The array has two arguments, the difficulty of the level, and the
481	* magical bonus "wanted".	479	* magical bonus "wanted".
482	*/	480	*/
483		481
484	static int difftomagic_list[DIFFLEVELS][MAXMAGIC + 1] = {	482	static int difftomagic_list[DIFFLEVELS][MAXMAGIC + 1] = {
		483
485	/*chance of magic difficulty*/	484	/*chance of magic difficulty*/
		485
486	/* +0 +1 +2 +3 +4 */	486	/* +0 +1 +2 +3 +4 */
487	{95, 2, 2, 1, 0}, /*1 */	487	{95, 2, 2, 1, 0}, /*1 */
488	{92, 5, 2, 1, 0}, /*2 */	488	{92, 5, 2, 1, 0}, /*2 */
489	{85, 10, 4, 1, 0}, /*3 */	489	{85, 10, 4, 1, 0}, /*3 */
490	{80, 14, 4, 2, 0}, /*4 */	490	{80, 14, 4, 2, 0}, /*4 */
491	{75, 17, 5, 2, 1}, /*5 */	491	{75, 17, 5, 2, 1}, /*5 */
492	{70, 18, 8, 3, 1}, /*6 */	492	{70, 18, 8, 3, 1}, /*6 */
493	{65, 21, 10, 3, 1}, /*7 */	493	{65, 21, 10, 3, 1}, /*7 */
494	{60, 22, 12, 4, 2}, /*8 */	494	{60, 22, 12, 4, 2}, /*8 */
495	{55, 25, 14, 4, 2}, /*9 */	495	{55, 25, 14, 4, 2}, /*9 */
496	{50, 27, 16, 5, 2}, /*10 */	496	{50, 27, 16, 5, 2}, /*10 */
497	{45, 28, 18, 6, 3}, /*11 */	497	{45, 28, 18, 6, 3}, /*11 */
498	{42, 28, 20, 7, 3}, /*12 */	498	{42, 28, 20, 7, 3}, /*12 */
499	{40, 27, 21, 8, 4}, /*13 */	499	{40, 27, 21, 8, 4}, /*13 */
500	{38, 25, 22, 10, 5}, /*14 */	500	{38, 25, 22, 10, 5}, /*14 */
501	{36, 23, 23, 12, 6}, /*15 */	501	{36, 23, 23, 12, 6}, /*15 */
502	{33, 21, 24, 14, 8}, /*16 */	502	{33, 21, 24, 14, 8}, /*16 */
503	{31, 19, 25, 16, 9}, /*17 */	503	{31, 19, 25, 16, 9}, /*17 */
504	{27, 15, 30, 18, 10}, /*18 */	504	{27, 15, 30, 18, 10}, /*18 */
505	{20, 12, 30, 25, 13}, /*19 */	505	{20, 12, 30, 25, 13}, /*19 */
506	{15, 10, 28, 30, 17}, /*20 */	506	{15, 10, 28, 30, 17}, /*20 */
507	{13, 9, 27, 28, 23}, /*21 */	507	{13, 9, 27, 28, 23}, /*21 */
508	{10, 8, 25, 28, 29}, /*22 */	508	{10, 8, 25, 28, 29}, /*22 */
509	{8, 7, 23, 26, 36}, /*23 */	509	{8, 7, 23, 26, 36}, /*23 */
510	{6, 6, 20, 22, 46}, /*24 */	510	{6, 6, 20, 22, 46}, /*24 */
511	{4, 5, 17, 18, 56}, /*25 */	511	{4, 5, 17, 18, 56}, /*25 */
512	{2, 4, 12, 14, 68}, /*26 */	512	{2, 4, 12, 14, 68}, /*26 */
513	{0, 3, 7, 10, 80}, /*27 */	513	{0, 3, 7, 10, 80}, /*27 */
514	{0, 0, 3, 7, 90}, /*28 */	514	{0, 0, 3, 7, 90}, /*28 */
515	{0, 0, 0, 3, 97}, /*29 */	515	{0, 0, 0, 3, 97}, /*29 */
516	{0, 0, 0, 0, 100}, /*30 */	516	{0, 0, 0, 0, 100}, /*30 */
517	{0, 0, 0, 0, 100}, /*31 */	517	{0, 0, 0, 0, 100}, /*31 */
518	};	518	};
519		519
520		520
521	/* calculate the appropriate level for wands staves and scrolls.	521	/* calculate the appropriate level for wands staves and scrolls.
522	* This code presumes that op has had its spell object created (in op->inv)	522	* This code presumes that op has had its spell object created (in op->inv)
…		…
524	* elmex Wed Aug 9 17:44:59 CEST 2006:	524	* elmex Wed Aug 9 17:44:59 CEST 2006:
525	* Removed multiplicator, too many high-level items were generated on low-difficulty maps.	525	* Removed multiplicator, too many high-level items were generated on low-difficulty maps.
526	*/	526	*/
527		527
528	int	528	int
529	level_for_item (const object * op, int difficulty)	529	level_for_item (const object *op, int difficulty)
530	{	530	{
531	int mult = 0, olevel = 0;	531	int olevel = 0;
532		532
533	if (!op->inv)	533	if (!op->inv)
534	{	534	{
535	LOG (llevError, "level_for_item: Object %s has no inventory!\n", &op->name);	535	LOG (llevError, "level_for_item: Object %s has no inventory!\n", &op->name);
536	return 0;	536	return 0;
…		…
577	for (magic = 0; magic < (MAXMAGIC + 1); magic++)	577	for (magic = 0; magic < (MAXMAGIC + 1); magic++)
578	{	578	{
579	percent -= difftomagic_list[scaled_diff][magic];	579	percent -= difftomagic_list[scaled_diff][magic];
580		580
581	if (percent < 0)	581	if (percent < 0)
582	break;	582	break;
583	}	583	}
584		584
585	if (magic == (MAXMAGIC + 1))	585	if (magic == (MAXMAGIC + 1))
586	{	586	{
587	LOG (llevError, "Warning, table for difficulty (scaled %d) %d bad.\n", scaled_diff, difficulty);	587	LOG (llevError, "Warning, table for difficulty (scaled %d) %d bad.\n", scaled_diff, difficulty);
…		…
600	* This function doesn't work properly, should add use of archetypes	600	* This function doesn't work properly, should add use of archetypes
601	* to make it truly absolute.	601	* to make it truly absolute.
602	*/	602	*/
603		603
604	void	604	void
605	set_abs_magic (object * op, int magic)	605	set_abs_magic (object *op, int magic)
606	{	606	{
607	if (!magic)	607	if (!magic)
608	return;	608	return;
609		609
610	op->magic = magic;	610	op->magic = magic;
611	if (op->arch)	611	if (op->arch)
612	{	612	{
613	if (op->type == ARMOUR)	613	if (op->type == ARMOUR)
614	ARMOUR_SPEED (op) = (ARMOUR_SPEED (&op->arch->clone) * (100 + magic * 10)) / 100;	614	ARMOUR_SPEED (op) = (ARMOUR_SPEED (&op->arch->clone) * (100 + magic * 10)) / 100;
615		615
616	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */	616	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */
617	magic = (-magic);	617	magic = (-magic);
618	op->weight = (op->arch->clone.weight * (100 - magic * 10)) / 100;	618	op->weight = (op->arch->clone.weight * (100 - magic * 10)) / 100;
619	}	619	}
620	else	620	else
621	{	621	{
622	if (op->type == ARMOUR)	622	if (op->type == ARMOUR)
623	ARMOUR_SPEED (op) = (ARMOUR_SPEED (op) * (100 + magic * 10)) / 100;	623	ARMOUR_SPEED (op) = (ARMOUR_SPEED (op) * (100 + magic * 10)) / 100;
624	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */	624	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */
625	magic = (-magic);	625	magic = (-magic);
626	op->weight = (op->weight * (100 - magic * 10)) / 100;	626	op->weight = (op->weight * (100 - magic * 10)) / 100;
627	}	627	}
628	}	628	}
629		629
630	/*	630	/*
631	* Sets a random magical bonus in the given object based upon	631	* Sets a random magical bonus in the given object based upon
632	* the given difficulty, and the given max possible bonus.	632	* the given difficulty, and the given max possible bonus.
633	*/	633	*/
634		634
635	static void	635	static void
636	set_magic (int difficulty, object * op, int max_magic, int flags)	636	set_magic (int difficulty, object *op, int max_magic, int flags)
637	{	637	{
638	int i;	638	int i;
		639
639	i = magic_from_difficulty (difficulty);	640	i = magic_from_difficulty (difficulty);
640	if ((flags & GT_ONLY_GOOD) && i < 0)	641	if ((flags & GT_ONLY_GOOD) && i < 0)
641	i = -i;	642	i = -i;
642	if (i > max_magic)	643	if (i > max_magic)
643	i = max_magic;	644	i = max_magic;
…		…
654	* other bonuses previously rolled and ones the item might natively have.	655	* other bonuses previously rolled and ones the item might natively have.
655	* 2) Add code to deal with new PR method.	656	* 2) Add code to deal with new PR method.
656	*/	657	*/
657		658
658	void	659	void
659	set_ring_bonus (object * op, int bonus)	660	set_ring_bonus (object *op, int bonus)
660	{	661	{
661		662
662	int r = RANDOM () % (bonus > 0 ? 25 : 11);	663	int r = RANDOM () % (bonus > 0 ? 25 : 11);
663		664
664	if (op->type == AMULET)	665	if (op->type == AMULET)
665	{	666	{
666	if (!(RANDOM () % 21))	667	if (!(RANDOM () % 21))
667	r = 20 + RANDOM () % 2;	668	r = 20 + RANDOM () % 2;
668	else	669	else
669	{	670	{
670	if (RANDOM () & 2)	671	if (RANDOM () & 2)
671	r = 10;	672	r = 10;
672	else	673	else
673	r = 11 + RANDOM () % 9;	674	r = 11 + RANDOM () % 9;
674	}	675	}
675	}	676	}
676		677
677	switch (r)	678	switch (r)
678	{	679	{
679	/* Redone by MSW 2000-11-26 to have much less code. Also,	680	/* Redone by MSW 2000-11-26 to have much less code. Also,
680	* bonuses and penalties will stack and add to existing values.	681	* bonuses and penalties will stack and add to existing values.
681	* of the item.	682	* of the item.
682	*/	683	*/
683	case 0:	684	case 0:
684	case 1:	685	case 1:
685	case 2:	686	case 2:
686	case 3:	687	case 3:
687	case 4:	688	case 4:
688	case 5:	689	case 5:
689	case 6:	690	case 6:
690	set_attr_value (&op->stats, r, (signed char) (bonus + get_attr_value (&op->stats, r)));	691	set_attr_value (&op->stats, r, (signed char) (bonus + get_attr_value (&op->stats, r)));
691	break;	692	break;
692		693
693	case 7:	694	case 7:
694	op->stats.dam += bonus;	695	op->stats.dam += bonus;
695	break;	696	break;
696		697
697	case 8:	698	case 8:
698	op->stats.wc += bonus;	699	op->stats.wc += bonus;
699	break;	700	break;
700		701
701	case 9:	702	case 9:
702	op->stats.food += bonus; /* hunger/sustenance */	703	op->stats.food += bonus; /* hunger/sustenance */
703	break;	704	break;
704		705
705	case 10:	706	case 10:
706	op->stats.ac += bonus;	707	op->stats.ac += bonus;
707	break;	708	break;
708		709
709	/* Item that gives protections/vulnerabilities */	710	/* Item that gives protections/vulnerabilities */
710	case 11:	711	case 11:
711	case 12:	712	case 12:
712	case 13:	713	case 13:
713	case 14:	714	case 14:
714	case 15:	715	case 15:
715	case 16:	716	case 16:
716	case 17:	717	case 17:
717	case 18:	718	case 18:
718	case 19:	719	case 19:
719	{	720	{
720	int b = 5 + FABS (bonus), val, resist = RANDOM () % num_resist_table;	721	int b = 5 + FABS (bonus), val, resist = RANDOM () % num_resist_table;
721		722
722	/* Roughly generate a bonus between 100 and 35 (depending on the bonus) */	723	/* Roughly generate a bonus between 100 and 35 (depending on the bonus) */
723	val = 10 + RANDOM () % b + RANDOM () % b + RANDOM () % b + RANDOM () % b;	724	val = 10 + RANDOM () % b + RANDOM () % b + RANDOM () % b + RANDOM () % b;
724		725
725	/* Cursed items need to have higher negative values to equal out with	726	/* Cursed items need to have higher negative values to equal out with
726	* positive values for how protections work out. Put another	727	* positive values for how protections work out. Put another
727	* little random element in since that they don't always end up with	728	* little random element in since that they don't always end up with
728	* even values.	729	* even values.
729	*/	730	*/
730	if (bonus < 0)	731	if (bonus < 0)
731	val = 2 * -val - RANDOM () % b;	732	val = 2 * -val - RANDOM () % b;
732	if (val > 35)	733	if (val > 35)
733	val = 35; /* Upper limit */	734	val = 35; /* Upper limit */
734	b = 0;	735	b = 0;
735	while (op->resist[resist_table[resist]] != 0 && b < 4)	736	while (op->resist[resist_table[resist]] != 0 && b < 4)
736	{	737	{
737	resist = RANDOM () % num_resist_table;	738	resist = RANDOM () % num_resist_table;
738	}	739	}
739	if (b == 4)	740	if (b == 4)
740	return; /* Not able to find a free resistance */	741	return; /* Not able to find a free resistance */
741	op->resist[resist_table[resist]] = val;	742	op->resist[resist_table[resist]] = val;
742	/* We should probably do something more clever here to adjust value	743	/* We should probably do something more clever here to adjust value
743	* based on how good a resistance we gave.	744	* based on how good a resistance we gave.
744	*/	745	*/
745	break;	746	break;
746	}	747	}
747	case 20:	748	case 20:
748	if (op->type == AMULET)	749	if (op->type == AMULET)
749	{	750	{
750	SET_FLAG (op, FLAG_REFL_SPELL);	751	SET_FLAG (op, FLAG_REFL_SPELL);
751	op->value *= 11;	752	op->value *= 11;
752	}	753	}
753	else	754	else
754	{	755	{
755	op->stats.hp = 1; /* regenerate hit points */	756	op->stats.hp = 1; /* regenerate hit points */
756	op->value *= 4;	757	op->value *= 4;
757	}	758	}
758	break;	759	break;
759		760
760	case 21:	761	case 21:
761	if (op->type == AMULET)	762	if (op->type == AMULET)
762	{	763	{
763	SET_FLAG (op, FLAG_REFL_MISSILE);	764	SET_FLAG (op, FLAG_REFL_MISSILE);
764	op->value *= 9;	765	op->value *= 9;
765	}	766	}
766	else	767	else
767	{	768	{
768	op->stats.sp = 1; /* regenerate spell points */	769	op->stats.sp = 1; /* regenerate spell points */
769	op->value *= 3;	770	op->value *= 3;
770	}	771	}
771	break;	772	break;
772		773
773	case 22:	774	case 22:
774	op->stats.exp += bonus; /* Speed! */	775	op->stats.exp += bonus; /* Speed! */
775	op->value = (op->value * 2) / 3;	776	op->value = (op->value * 2) / 3;
776	break;	777	break;
777	}	778	}
778	if (bonus > 0)	779	if (bonus > 0)
779	op->value *= 2 * bonus;	780	op->value *= 2 * bonus;
780	else	781	else
781	op->value = -(op->value * 2 * bonus) / 3;	782	op->value = -(op->value * 2 * bonus) / 3;
…		…
792		793
793	int	794	int
794	get_magic (int diff)	795	get_magic (int diff)
795	{	796	{
796	int i;	797	int i;
		798
797	if (diff < 3)	799	if (diff < 3)
798	diff = 3;	800	diff = 3;
799	for (i = 0; i < 4; i++)	801	for (i = 0; i < 4; i++)
800	if (RANDOM () % diff)	802	if (RANDOM () % diff)
801	return i;	803	return i;
…		…
808	/*	810	/*
809	* fix_generated_item(): This is called after an item is generated, in	811	* fix_generated_item(): This is called after an item is generated, in
810	* order to set it up right. This produced magical bonuses, puts spells	812	* order to set it up right. This produced magical bonuses, puts spells
811	* into scrolls/books/wands, makes it unidentified, hides the value, etc.	813	* into scrolls/books/wands, makes it unidentified, hides the value, etc.
812	*/	814	*/
		815
813	/* 4/28/96 added creator object from which op may now inherit properties based on	816	/* 4/28/96 added creator object from which op may now inherit properties based on
814	* op->type. Right now, which stuff the creator passes on is object type	817	* op->type. Right now, which stuff the creator passes on is object type
815	* dependant. I know this is a spagetti manuever, but is there a cleaner	818	* dependant. I know this is a spagetti manuever, but is there a cleaner
816	* way to do this? b.t. */	819	* way to do this? b.t. */
		820
817	/*	821	/*
818	* ! (flags & GT_ENVIRONMENT):	822	* ! (flags & GT_ENVIRONMENT):
819	* Automatically calls fix_flesh_item().	823	* Automatically calls fix_flesh_item().
820	*	824	*
821	* flags:	825	* flags:
…		…
825	* a working object - don't change magic, value, etc, but set it material	829	* a working object - don't change magic, value, etc, but set it material
826	* type as appropriate, for objects that need spell objects, set those, etc	830	* type as appropriate, for objects that need spell objects, set those, etc
827	*/	831	*/
828		832
829	void	833	void
830	fix_generated_item (object * op, object * creator, int difficulty, int max_magic, int flags)	834	fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags)
831	{	835	{
832	int was_magic = op->magic, num_enchantments = 0, save_item_power = 0;	836	int was_magic = op->magic, num_enchantments = 0, save_item_power = 0;
833		837
834	if (!creator || creator->type == op->type)	838	if (!creator || creator->type == op->type)
835	creator = op; /*safety & to prevent polymorphed objects giving attributes */	839	creator = op; /*safety & to prevent polymorphed objects giving attributes */
836		840
837	/* If we make an artifact, this information will be destroyed */	841	/* If we make an artifact, this information will be destroyed */
838	save_item_power = op->item_power;	842	save_item_power = op->item_power;
839	op->item_power = 0;	843	op->item_power = 0;
840		844
841	if (op->randomitems && op->type != SPELL)	845	if (op->randomitems && op->type != SPELL)
842	{	846	{
843	create_treasure (op->randomitems, op, flags, difficulty, 0);	847	create_treasure (op->randomitems, op, flags, difficulty, 0);
844	if (!op->inv)	848	if (!op->inv)
845	LOG (llevDebug, "fix_generated_item: Unable to generate treasure for %s\n", &op->name);	849	LOG (llevDebug, "fix_generated_item: Unable to generate treasure for %s\n", &op->name);
846		850
847	/* So the treasure doesn't get created again */	851	/* So the treasure doesn't get created again */
848	op->randomitems = NULL;	852	op->randomitems = NULL;
849	}	853	}
850		854
851	if (difficulty < 1)	855	if (difficulty < 1)
852	difficulty = 1;	856	difficulty = 1;
853		857
		858	if (INVOKE_OBJECT (ADD_BONUS, op,
		859	ARG_OBJECT (creator != op ? creator : 0),
		860	ARG_INT (difficulty), ARG_INT (max_magic),
		861	ARG_INT (flags)))
		862	return;
		863
854	if (!(flags & GT_MINIMAL))	864	if (!(flags & GT_MINIMAL))
855	{	865	{
856	if (op->arch == crown_arch)	866	if (op->arch == crown_arch)
857	{	867	{
858	set_magic (difficulty, op, max_magic, flags);	868	set_magic (difficulty, op, max_magic, flags);
859	num_enchantments = calc_item_power (op, 1);	869	num_enchantments = calc_item_power (op, 1);
860	generate_artifact (op, difficulty);	870	generate_artifact (op, difficulty);
861	}	871	}
862	else	872	else
863	{	873	{
864	if (!op->magic && max_magic)	874	if (!op->magic && max_magic)
865	set_magic (difficulty, op, max_magic, flags);	875	set_magic (difficulty, op, max_magic, flags);
866		876
867	num_enchantments = calc_item_power (op, 1);	877	num_enchantments = calc_item_power (op, 1);
868		878
869	if ((!was_magic && !(RANDOM () % CHANCE_FOR_ARTIFACT)) || op->type == HORN || difficulty >= settings.max_level) /* high difficulties always generate an artifact,	879	if ((!was_magic && !(RANDOM () % CHANCE_FOR_ARTIFACT)) || op->type == HORN || difficulty >= settings.max_level) /* high difficulties always generate an artifact,
870	* used for shop_floors or treasures */	880	* used for shop_floors or treasures */
871	generate_artifact (op, difficulty);	881	generate_artifact (op, difficulty);
872	}	882	}
873		883
874	/* Object was made an artifact. Calculate its item_power rating.	884	/* Object was made an artifact. Calculate its item_power rating.
875	* the item_power in the object is what the artfiact adds.	885	* the item_power in the object is what the artfiact adds.
876	*/	886	*/
877	if (op->title)	887	if (op->title)
878	{	888	{
879	/* if save_item_power is set, then most likely we started with an	889	/* if save_item_power is set, then most likely we started with an
880	* artifact and have added new abilities to it - this is rare, but	890	* artifact and have added new abilities to it - this is rare, but
881	* but I have seen things like 'strange rings of fire'. So just figure	891	* but I have seen things like 'strange rings of fire'. So just figure
882	* out the power from the base power plus what this one adds. Note	892	* out the power from the base power plus what this one adds. Note
883	* that since item_power is not quite linear, this actually ends up	893	* that since item_power is not quite linear, this actually ends up
884	* being somewhat of a bonus	894	* being somewhat of a bonus
885	*/	895	*/
886	if (save_item_power)	896	if (save_item_power)
887	op->item_power = save_item_power + get_power_from_ench (op->item_power);	897	op->item_power = save_item_power + get_power_from_ench (op->item_power);
888	else	898	else
889	op->item_power = get_power_from_ench (op->item_power + num_enchantments);	899	op->item_power = get_power_from_ench (op->item_power + num_enchantments);
890	}	900	}
891	else if (save_item_power)	901	else if (save_item_power)
892	{	902	{
893	/* restore the item_power field to the object if we haven't changed it.	903	/* restore the item_power field to the object if we haven't changed it.
894	* we don't care about num_enchantments - that will basically just	904	* we don't care about num_enchantments - that will basically just
895	* have calculated some value from the base attributes of the archetype.	905	* have calculated some value from the base attributes of the archetype.
896	*/	906	*/
897	op->item_power = save_item_power;	907	op->item_power = save_item_power;
898	}	908	}
899	else	909	else
900	{	910	{
901	/* item_power was zero. This is suspicious, as it may be because it	911	/* item_power was zero. This is suspicious, as it may be because it
902	* was never previously calculated. Let's compute a value and see if	912	* was never previously calculated. Let's compute a value and see if
903	* it is non-zero. If it indeed is, then assign it as the new	913	* it is non-zero. If it indeed is, then assign it as the new
904	* item_power value.	914	* item_power value.
905	* - gros, 21th of July 2006.	915	* - gros, 21th of July 2006.
906	*/	916	*/
907	op->item_power = calc_item_power (op, 0);	917	op->item_power = calc_item_power (op, 0);
908	save_item_power = op->item_power; /* Just in case it would get used	918	save_item_power = op->item_power; /* Just in case it would get used
909	* again below */	919	* again below */
910	}	920	}
911	}	921	}
912		922
913	/* materialtype modifications. Note we allow this on artifacts. */	923	/* materialtype modifications. Note we allow this on artifacts. */
914	set_materialname (op, difficulty, NULL);	924	set_materialname (op, difficulty, NULL);
915		925
916	if (flags & GT_MINIMAL)	926	if (flags & GT_MINIMAL)
917	{	927	{
918	if (op->type == POTION)	928	if (op->type == POTION)
919	/* Handle healing and magic power potions */	929	/* Handle healing and magic power potions */
920	if (op->stats.sp && !op->randomitems)	930	if (op->stats.sp && !op->randomitems)
921	{	931	{
922	object *tmp;	932	object *tmp;
923		933
924	tmp = get_archetype (spell_mapping[op->stats.sp]);	934	tmp = get_archetype (spell_mapping[op->stats.sp]);
925	insert_ob_in_ob (tmp, op);	935	insert_ob_in_ob (tmp, op);
926	op->stats.sp = 0;	936	op->stats.sp = 0;
927	}	937	}
928	}	938	}
929	else if (!op->title) /* Only modify object if not special */	939	else if (!op->title) /* Only modify object if not special */
930	switch (op->type)	940	switch (op->type)
931	{	941	{
932	case WEAPON:	942	case WEAPON:
933	case ARMOUR:	943	case ARMOUR:
934	case SHIELD:	944	case SHIELD:
935	case HELMET:	945	case HELMET:
936	case CLOAK:	946	case CLOAK:
937	if (QUERY_FLAG (op, FLAG_CURSED) && !(RANDOM () % 4))	947	if (QUERY_FLAG (op, FLAG_CURSED) && !(RANDOM () % 4))
938	set_ring_bonus (op, -DICE2);	948	set_ring_bonus (op, -DICE2);
939	break;	949	break;
940		950
941	case BRACERS:	951	case BRACERS:
942	if (!(RANDOM () % (QUERY_FLAG (op, FLAG_CURSED) ? 5 : 20)))	952	if (!(RANDOM () % (QUERY_FLAG (op, FLAG_CURSED) ? 5 : 20)))
943	{	953	{
		954	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
		955	if (!QUERY_FLAG (op, FLAG_CURSED))
		956	op->value *= 3;
		957	}
		958	break;
		959
		960	case POTION:
		961	{
		962	int too_many_tries = 0, is_special = 0;
		963
		964	/* Handle healing and magic power potions */
		965	if (op->stats.sp && !op->randomitems)
		966	{
		967	object *tmp;
		968
		969	tmp = get_archetype (spell_mapping[op->stats.sp]);
		970	insert_ob_in_ob (tmp, op);
		971	op->stats.sp = 0;
		972	}
		973
		974	while (!(is_special = special_potion (op)) && !op->inv)
		975	{
		976	generate_artifact (op, difficulty);
		977	if (too_many_tries++ > 10)
		978	break;
		979	}
		980
		981	/* don't want to change value for healing/magic power potions,
		982	* since the value set on those is already correct.
		983	*/
		984	if (op->inv && op->randomitems)
		985	{
		986	/* value multiplier is same as for scrolls */
		987	op->value = (op->value * op->inv->value);
		988	op->level = op->inv->level / 2 + RANDOM () % difficulty + RANDOM () % difficulty;
		989	}
		990	else
		991	{
		992	op->name = "potion";
		993	op->name_pl = "potions";
		994	}
		995
		996	if (!(flags & GT_ONLY_GOOD) && RANDOM () % 2)
		997	SET_FLAG (op, FLAG_CURSED);
		998	break;
		999	}
		1000
		1001	case AMULET:
		1002	if (op->arch == amulet_arch)
		1003	op->value *= 5; /* Since it's not just decoration */
		1004
		1005	case RING:
		1006	if (op->arch == NULL)
		1007	{
		1008	op->destroy ();
		1009	op = 0;
		1010	break;
		1011	}
		1012
		1013	if (op->arch != ring_arch && op->arch != amulet_arch) /* It's a special artifact! */
		1014	break;
		1015
		1016	if (!(flags & GT_ONLY_GOOD) && !(RANDOM () % 3))
		1017	SET_FLAG (op, FLAG_CURSED);
		1018
944	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);	1019	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
945	if (!QUERY_FLAG (op, FLAG_CURSED))
946	op->value *= 3;
947	}
948	break;
949		1020
950	case POTION:
951	{
952	int too_many_tries = 0, is_special = 0;
953
954	/* Handle healing and magic power potions */
955	if (op->stats.sp && !op->randomitems)
956	{
957	object *tmp;
958
959	tmp = get_archetype (spell_mapping[op->stats.sp]);
960	insert_ob_in_ob (tmp, op);
961	op->stats.sp = 0;
962	}
963
964	while (!(is_special = special_potion (op)) && !op->inv)
965	{
966	generate_artifact (op, difficulty);
967	if (too_many_tries++ > 10)
968	break;
969	}
970
971	/* don't want to change value for healing/magic power potions,
972	* since the value set on those is already correct.
973	*/
974	if (op->inv && op->randomitems)
975	{
976	/* value multiplier is same as for scrolls */
977	op->value = (op->value * op->inv->value);
978	op->level = op->inv->level / 2 + RANDOM () % difficulty + RANDOM () % difficulty;
979	}
980	else
981	{
982	op->name = "potion";
983	op->name_pl = "potions";
984	}
985
986	if (!(flags & GT_ONLY_GOOD) && RANDOM () % 2)
987	SET_FLAG (op, FLAG_CURSED);
988	break;
989	}
990
991	case AMULET:
992	if (op->arch == amulet_arch)
993	op->value *= 5; /* Since it's not just decoration */
994
995	case RING:
996	if (op->arch == NULL)
997	{
998	remove_ob (op);
999	free_object (op);
1000	op = NULL;
1001	break;
1002	}
1003
1004	if (op->arch != ring_arch && op->arch != amulet_arch) /* It's a special artifact! */
1005	break;
1006
1007	if (!(flags & GT_ONLY_GOOD) && !(RANDOM () % 3))
1008	SET_FLAG (op, FLAG_CURSED);
1009
1010	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
1011
1012	if (op->type != RING) /* Amulets have only one ability */	1021	if (op->type != RING) /* Amulets have only one ability */
1013	break;	1022	break;
1014		1023
1015	if (!(RANDOM () % 4))	1024	if (!(RANDOM () % 4))
1016	{	1025	{
1017	int d = (RANDOM () % 2 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;	1026	int d = (RANDOM () % 2 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
1018		1027
1019	if (d > 0)	1028	if (d > 0)
1020	op->value *= 3;	1029	op->value *= 3;
1021		1030
1022	set_ring_bonus (op, d);	1031	set_ring_bonus (op, d);
1023		1032
1024	if (!(RANDOM () % 4))	1033	if (!(RANDOM () % 4))
1025	{	1034	{
1026	int d = (RANDOM () % 3 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;	1035	int d = (RANDOM () % 3 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
1027	if (d > 0)
1028	op->value *= 5;
1029	set_ring_bonus (op, d);
1030	}
1031	}
1032		1036
		1037	if (d > 0)
		1038	op->value *= 5;
		1039	set_ring_bonus (op, d);
		1040	}
		1041	}
		1042
1033	if (GET_ANIM_ID (op))	1043	if (GET_ANIM_ID (op))
1034	SET_ANIMATION (op, RANDOM () % ((int) NUM_ANIMATIONS (op)));	1044	SET_ANIMATION (op, RANDOM () % ((int) NUM_ANIMATIONS (op)));
1035		1045
1036	break;	1046	break;
1037		1047
1038	case BOOK:	1048	case BOOK:
1039	/* Is it an empty book?, if yes lets make a special·	1049	/* Is it an empty book?, if yes lets make a special·
1040	* msg for it, and tailor its properties based on the·	1050	* msg for it, and tailor its properties based on the·
1041	* creator and/or map level we found it on.	1051	* creator and/or map level we found it on.
1042	*/	1052	*/
1043	if (!op->msg && RANDOM () % 10)	1053	if (!op->msg && RANDOM () % 10)
1044	{	1054	{
1045	/* set the book level properly */	1055	/* set the book level properly */
1046	if (creator->level == 0 || QUERY_FLAG (creator, FLAG_ALIVE))	1056	if (creator->level == 0 || QUERY_FLAG (creator, FLAG_ALIVE))
1047	{	1057	{
1048	if (op->map && op->map->difficulty)	1058	if (op->map && op->map->difficulty)
1049	op->level = RANDOM () % (op->map->difficulty) + RANDOM () % 10 + 1;	1059	op->level = RANDOM () % (op->map->difficulty) + RANDOM () % 10 + 1;
1050	else	1060	else
1051	op->level = RANDOM () % 20 + 1;	1061	op->level = RANDOM () % 20 + 1;
1052	}	1062	}
1053	else	1063	else
1054	op->level = RANDOM () % creator->level;	1064	op->level = RANDOM () % creator->level;
1055		1065
1056	tailor_readable_ob (op, (creator && creator->stats.sp) ? creator->stats.sp : -1);	1066	tailor_readable_ob (op, (creator && creator->stats.sp) ? creator->stats.sp : -1);
1057	/* books w/ info are worth more! */	1067	/* books w/ info are worth more! */
1058	op->value *= ((op->level > 10 ? op->level : (op->level + 1) / 2) * ((strlen (op->msg) / 250) + 1));	1068	op->value *= ((op->level > 10 ? op->level : (op->level + 1) / 2) * ((strlen (op->msg) / 250) + 1));
1059	/* creator related stuff */	1069	/* creator related stuff */
1060		1070
1061	/* for library, chained books. Note that some monsters have no_pick	1071	/* for library, chained books. Note that some monsters have no_pick
1062	* set - we don't want to set no pick in that case.	1072	* set - we don't want to set no pick in that case.
1063	*/	1073	*/
1064	if (QUERY_FLAG (creator, FLAG_NO_PICK) && !QUERY_FLAG (creator, FLAG_MONSTER))	1074	if (QUERY_FLAG (creator, FLAG_NO_PICK) && !QUERY_FLAG (creator, FLAG_MONSTER))
1065	SET_FLAG (op, FLAG_NO_PICK);	1075	SET_FLAG (op, FLAG_NO_PICK);
1066	if (creator->slaying && !op->slaying) /* for check_inv floors */	1076	if (creator->slaying && !op->slaying) /* for check_inv floors */
1067	op->slaying = creator->slaying;	1077	op->slaying = creator->slaying;
1068		1078
1069	/* add exp so reading it gives xp (once) */	1079	/* add exp so reading it gives xp (once) */
1070	op->stats.exp = op->value > 10000 ? op->value / 5 : op->value / 10;	1080	op->stats.exp = op->value > 10000 ? op->value / 5 : op->value / 10;
1071	}	1081	}
1072	break;	1082	break;
1073		1083
1074	case SPELLBOOK:	1084	case SPELLBOOK:
1075	op->value = op->value * op->inv->value;	1085	op->value = op->value * op->inv->value;
1076	/* add exp so learning gives xp */	1086	/* add exp so learning gives xp */
1077	op->level = op->inv->level;	1087	op->level = op->inv->level;
1078	op->stats.exp = op->value;	1088	op->stats.exp = op->value;
1079	break;	1089	break;
1080		1090
1081	case WAND:	1091	case WAND:
1082	/* nrof in the treasure list is number of charges,	1092	/* nrof in the treasure list is number of charges,
1083	* not number of wands. So copy that into food (charges),	1093	* not number of wands. So copy that into food (charges),
1084	* and reset nrof.	1094	* and reset nrof.
1085	*/	1095	*/
1086	op->stats.food = op->inv->nrof;	1096	op->stats.food = op->inv->nrof;
1087	op->nrof = 1;	1097	op->nrof = 1;
1088	/* If the spell changes by level, choose a random level	1098	/* If the spell changes by level, choose a random level
1089	* for it, and adjust price. If the spell doesn't	1099	* for it, and adjust price. If the spell doesn't
1090	* change by level, just set the wand to the level of	1100	* change by level, just set the wand to the level of
1091	* the spell, and value calculation is simpler.	1101	* the spell, and value calculation is simpler.
1092	*/	1102	*/
1093	if (op->inv->duration_modifier || op->inv->dam_modifier || op->inv->range_modifier)	1103	if (op->inv->duration_modifier || op->inv->dam_modifier || op->inv->range_modifier)
1094	{	1104	{
		1105	op->level = level_for_item (op, difficulty);
		1106	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
		1107	}
		1108	else
		1109	{
		1110	op->level = op->inv->level;
		1111	op->value = op->value * op->inv->value;
		1112	}
		1113	break;
		1114
		1115	case ROD:
1095	op->level = level_for_item (op, difficulty);	1116	op->level = level_for_item (op, difficulty);
		1117	/* Add 50 to both level an divisor to keep prices a little more
		1118	* reasonable. Otherwise, a high level version of a low level
		1119	* spell can be worth tons a money (eg, level 20 rod, level 2 spell =
		1120	* 10 time multiplier). This way, the value are a bit more reasonable.
		1121	*/
1096	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);	1122	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
1097	}	1123	/* maxhp is used to denote how many 'charges' the rod holds before */
1098	else	1124	if (op->stats.maxhp)
1099	{	1125	op->stats.maxhp *= MAX (op->inv->stats.sp, op->inv->stats.grace);
1100	op->level = op->inv->level;	1126	else
1101	op->value = op->value * op->inv->value;	1127	op->stats.maxhp = 2 * MAX (op->inv->stats.sp, op->inv->stats.grace);
1102	}
1103	break;
1104		1128
		1129	op->stats.hp = op->stats.maxhp;
		1130	break;
		1131
1105	case ROD:	1132	case SCROLL:
1106	op->level = level_for_item (op, difficulty);	1133	op->level = level_for_item (op, difficulty);
1107	/* Add 50 to both level an divisor to keep prices a little more
1108	* reasonable. Otherwise, a high level version of a low level
1109	* spell can be worth tons a money (eg, level 20 rod, level 2 spell =
1110	* 10 time multiplier). This way, the value are a bit more reasonable.
1111	*/
1112	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);	1134	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
1113	/* maxhp is used to denote how many 'charges' the rod holds before */
1114	if (op->stats.maxhp)
1115	op->stats.maxhp *= MAX (op->inv->stats.sp, op->inv->stats.grace);
1116	else
1117	op->stats.maxhp = 2 * MAX (op->inv->stats.sp, op->inv->stats.grace);
1118		1135
1119	op->stats.hp = op->stats.maxhp;
1120	break;
1121
1122	case SCROLL:
1123	op->level = level_for_item (op, difficulty);
1124	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
1125
1126	/* add exp so reading them properly gives xp */	1136	/* add exp so reading them properly gives xp */
1127	op->stats.exp = op->value / 5;	1137	op->stats.exp = op->value / 5;
1128	op->nrof = op->inv->nrof;	1138	op->nrof = op->inv->nrof;
1129	break;	1139	break;
1130		1140
1131	case RUNE:	1141	case RUNE:
1132	trap_adjust (op, difficulty);	1142	trap_adjust (op, difficulty);
1133	break;	1143	break;
1134		1144
1135	case TRAP:	1145	case TRAP:
1136	trap_adjust (op, difficulty);	1146	trap_adjust (op, difficulty);
1137	break;	1147	break;
1138	} /* switch type */	1148	} /* switch type */
1139		1149
1140	if (flags & GT_STARTEQUIP)	1150	if (flags & GT_STARTEQUIP)
1141	{	1151	{
1142	if (op->nrof < 2 && op->type != CONTAINER && op->type != MONEY && !QUERY_FLAG (op, FLAG_IS_THROWN))	1152	if (op->nrof < 2 && op->type != CONTAINER && op->type != MONEY && !QUERY_FLAG (op, FLAG_IS_THROWN))
1143	SET_FLAG (op, FLAG_STARTEQUIP);	1153	SET_FLAG (op, FLAG_STARTEQUIP);
1144	else if (op->type != MONEY)	1154	else if (op->type != MONEY)
1145	op->value = 0;	1155	op->value = 0;
1146	}	1156	}
1147		1157
1148	if (!(flags & GT_ENVIRONMENT))	1158	if (!(flags & GT_ENVIRONMENT))
1149	fix_flesh_item (op, creator);	1159	fix_flesh_item (op, creator);
1150	}	1160	}
…		…
1162	*/	1172	*/
1163		1173
1164	static artifactlist *	1174	static artifactlist *
1165	get_empty_artifactlist (void)	1175	get_empty_artifactlist (void)
1166	{	1176	{
1167	artifactlist *tl = (artifactlist *) malloc (sizeof (artifactlist));	1177	artifactlist *al = (artifactlist *) malloc (sizeof (artifactlist));
		1178
1168	if (tl == NULL)	1179	if (al == NULL)
1169	fatal (OUT_OF_MEMORY);	1180	fatal (OUT_OF_MEMORY);
1170	tl->next = NULL;	1181	al->next = NULL;
1171	tl->items = NULL;	1182	al->items = NULL;
1172	tl->total_chance = 0;	1183	al->total_chance = 0;
1173	return tl;	1184	return al;
1174	}	1185	}
1175		1186
1176	/*	1187	/*
1177	* Allocate and return the pointer to an empty artifact structure.	1188	* Allocate and return the pointer to an empty artifact structure.
1178	*/	1189	*/
1179		1190
1180	static artifact *	1191	static artifact *
1181	get_empty_artifact (void)	1192	get_empty_artifact (void)
1182	{	1193	{
1183	artifact *t = (artifact *) malloc (sizeof (artifact));	1194	artifact *a = (artifact *) malloc (sizeof (artifact));
		1195
1184	if (t == NULL)	1196	if (a == NULL)
1185	fatal (OUT_OF_MEMORY);	1197	fatal (OUT_OF_MEMORY);
1186	t->item = NULL;	1198	a->item = NULL;
1187	t->next = NULL;	1199	a->next = NULL;
1188	t->chance = 0;	1200	a->chance = 0;
1189	t->difficulty = 0;	1201	a->difficulty = 0;
1190	t->allowed = NULL;	1202	a->allowed = NULL;
1191	return t;	1203	return a;
1192	}	1204	}
1193		1205
1194	/*	1206	/*
1195	* Searches the artifact lists and returns one that has the same type	1207	* Searches the artifact lists and returns one that has the same type
1196	* of objects on it.	1208	* of objects on it.
…		…
1221	fprintf (logfile, "\n");	1233	fprintf (logfile, "\n");
1222	for (al = first_artifactlist; al != NULL; al = al->next)	1234	for (al = first_artifactlist; al != NULL; al = al->next)
1223	{	1235	{
1224	fprintf (logfile, "Artifact has type %d, total_chance=%d\n", al->type, al->total_chance);	1236	fprintf (logfile, "Artifact has type %d, total_chance=%d\n", al->type, al->total_chance);
1225	for (art = al->items; art != NULL; art = art->next)	1237	for (art = al->items; art != NULL; art = art->next)
1226	{	1238	{
1227	fprintf (logfile, "Artifact %-30s Difficulty %3d Chance %5d\n", &art->item->name, art->difficulty, art->chance);	1239	fprintf (logfile, "Artifact %-30s Difficulty %3d Chance %5d\n", &art->item->name, art->difficulty, art->chance);
1228	if (art->allowed != NULL)	1240	if (art->allowed != NULL)
1229	{	1241	{
1230	fprintf (logfile, "\tAllowed combinations:");	1242	fprintf (logfile, "\tAllowed combinations:");
1231	for (next = art->allowed; next != NULL; next = next->next)	1243	for (next = art->allowed; next != NULL; next = next->next)
1232	fprintf (logfile, "%s,", &next->name);	1244	fprintf (logfile, "%s,", &next->name);
1233	fprintf (logfile, "\n");	1245	fprintf (logfile, "\n");
1234	}	1246	}
1235	}	1247	}
1236	}	1248	}
1237	fprintf (logfile, "\n");	1249	fprintf (logfile, "\n");
1238	}	1250	}
1239		1251
1240	/*	1252	/*
1241	* For debugging purposes. Dumps all treasures recursively (see below).	1253	* For debugging purposes. Dumps all treasures recursively (see below).
1242	*/	1254	*/
1243	void	1255	void
1244	dump_monster_treasure_rec (const char *name, treasure * t, int depth)	1256	dump_monster_treasure_rec (const char *name, treasure *t, int depth)
1245	{	1257	{
1246	treasurelist *tl;	1258	treasurelist *tl;
1247	int i;	1259	int i;
1248		1260
1249	if (depth > 100)	1261	if (depth > 100)
1250	return;	1262	return;
1251	while (t != NULL)	1263	while (t)
1252	{	1264	{
1253	if (t->name != NULL)	1265	if (t->name)
1254	{	1266	{
1255	for (i = 0; i < depth; i++)	1267	for (i = 0; i < depth; i++)
1256	fprintf (logfile, " ");	1268	fprintf (logfile, " ");
1257	fprintf (logfile, "{ (list: %s)\n", &t->name);	1269	fprintf (logfile, "{ (list: %s)\n", &t->name);
1258	tl = find_treasurelist (t->name);	1270	tl = find_treasurelist (t->name);
		1271	if (tl)
1259	dump_monster_treasure_rec (name, tl->items, depth + 2);	1272	dump_monster_treasure_rec (name, tl->items, depth + 2);
1260	for (i = 0; i < depth; i++)	1273	for (i = 0; i < depth; i++)
1261	fprintf (logfile, " ");	1274	fprintf (logfile, " ");
1262	fprintf (logfile, "} (end of list: %s)\n", &t->name);	1275	fprintf (logfile, "} (end of list: %s)\n", &t->name);
1263	}	1276	}
1264	else	1277	else
1265	{	1278	{
1266	for (i = 0; i < depth; i++)	1279	for (i = 0; i < depth; i++)
1267	fprintf (logfile, " ");	1280	fprintf (logfile, " ");
1268	if (t->item->clone.type == FLESH)	1281	if (t->item && t->item->clone.type == FLESH)
1269	fprintf (logfile, "%s's %s\n", name, &t->item->clone.name);	1282	fprintf (logfile, "%s's %s\n", name, &t->item->clone.name);
1270	else	1283	else
1271	fprintf (logfile, "%s\n", &t->item->clone.name);	1284	fprintf (logfile, "%s\n", &t->item->clone.name);
1272	}	1285	}
		1286
1273	if (t->next_yes != NULL)	1287	if (t->next_yes)
1274	{	1288	{
1275	for (i = 0; i < depth; i++)	1289	for (i = 0; i < depth; i++)
1276	fprintf (logfile, " ");	1290	fprintf (logfile, " ");
1277	fprintf (logfile, " (if yes)\n");	1291	fprintf (logfile, " (if yes)\n");
1278	dump_monster_treasure_rec (name, t->next_yes, depth + 1);	1292	dump_monster_treasure_rec (name, t->next_yes, depth + 1);
1279	}	1293	}
		1294
1280	if (t->next_no != NULL)	1295	if (t->next_no)
1281	{	1296	{
1282	for (i = 0; i < depth; i++)	1297	for (i = 0; i < depth; i++)
1283	fprintf (logfile, " ");	1298	fprintf (logfile, " ");
1284	fprintf (logfile, " (if no)\n");	1299	fprintf (logfile, " (if no)\n");
1285	dump_monster_treasure_rec (name, t->next_no, depth + 1);	1300	dump_monster_treasure_rec (name, t->next_no, depth + 1);
1286	}	1301	}
		1302
1287	t = t->next;	1303	t = t->next;
1288	}	1304	}
1289	}	1305	}
1290		1306
1291	/*	1307	/*
…		…
1302	found = 0;	1318	found = 0;
1303	fprintf (logfile, "\n");	1319	fprintf (logfile, "\n");
1304	for (at = first_archetype; at != NULL; at = at->next)	1320	for (at = first_archetype; at != NULL; at = at->next)
1305	if (!strcasecmp (at->clone.name, name) && at->clone.title == NULL)	1321	if (!strcasecmp (at->clone.name, name) && at->clone.title == NULL)
1306	{	1322	{
1307	fprintf (logfile, "treasures for %s (arch: %s)\n", &at->clone.name, &at->name);	1323	fprintf (logfile, "treasures for %s (arch: %s)\n", &at->clone.name, &at->name);
1308	if (at->clone.randomitems != NULL)	1324	if (at->clone.randomitems != NULL)
1309	dump_monster_treasure_rec (at->clone.name, at->clone.randomitems->items, 1);	1325	dump_monster_treasure_rec (at->clone.name, at->clone.randomitems->items, 1);
1310	else	1326	else
1311	fprintf (logfile, "(nothing)\n");	1327	fprintf (logfile, "(nothing)\n");
1312	fprintf (logfile, "\n");	1328	fprintf (logfile, "\n");
1313	found++;	1329	found++;
1314	}	1330	}
1315	if (found == 0)	1331	if (found == 0)
1316	fprintf (logfile, "No objects have the name %s!\n\n", name);	1332	fprintf (logfile, "No objects have the name %s!\n\n", name);
1317	}	1333	}
1318		1334
…		…
1325	{	1341	{
1326	static int has_been_inited = 0;	1342	static int has_been_inited = 0;
1327	char filename[MAX_BUF], buf[HUGE_BUF], *cp, *next;	1343	char filename[MAX_BUF], buf[HUGE_BUF], *cp, *next;
1328	artifact *art = NULL;	1344	artifact *art = NULL;
1329	linked_char *tmp;	1345	linked_char *tmp;
1330	int value, comp;	1346	int value;
1331	artifactlist *al;	1347	artifactlist *al;
1332		1348
1333	if (has_been_inited)	1349	if (has_been_inited)
1334	return;	1350	return;
1335	else	1351	else
…		…
1342	return;	1358	return;
1343		1359
1344	while (fgets (buf, HUGE_BUF, thawer) != NULL)	1360	while (fgets (buf, HUGE_BUF, thawer) != NULL)
1345	{	1361	{
1346	if (*buf == '#')	1362	if (*buf == '#')
1347	continue;	1363	continue;
1348	if ((cp = strchr (buf, '\n')) != NULL)	1364	if ((cp = strchr (buf, '\n')) != NULL)
1349	*cp = '\0';	1365	*cp = '\0';
1350	cp = buf;	1366	cp = buf;
1351	while (*cp == ' ') /* Skip blanks */	1367	while (*cp == ' ') /* Skip blanks */
1352	cp++;	1368	cp++;
1353	if (*cp == '\0')	1369	if (*cp == '\0')
1354	continue;	1370	continue;
1355		1371
1356	if (!strncmp (cp, "Allowed", 7))	1372	if (!strncmp (cp, "Allowed", 7))
1357	{	1373	{
1358	if (art == NULL)	1374	if (art == NULL)
1359	{	1375	{
1360	art = get_empty_artifact ();	1376	art = get_empty_artifact ();
1361	nrofartifacts++;	1377	nrofartifacts++;
1362	}	1378	}
1363	cp = strchr (cp, ' ') + 1;	1379	cp = strchr (cp, ' ') + 1;
1364	if (!strcmp (cp, "all"))	1380	if (!strcmp (cp, "all"))
1365	continue;	1381	continue;
1366		1382
1367	do	1383	do
1368	{	1384	{
1369	nrofallowedstr++;	1385	nrofallowedstr++;
1370	if ((next = strchr (cp, ',')) != NULL)	1386	if ((next = strchr (cp, ',')) != NULL)
1371	*(next++) = '\0';	1387	*(next++) = '\0';
1372	tmp = new linked_char;	1388	tmp = new linked_char;
		1389
1373	tmp->name = cp;	1390	tmp->name = cp;
1374	tmp->next = art->allowed;	1391	tmp->next = art->allowed;
1375	art->allowed = tmp;	1392	art->allowed = tmp;
1376	}	1393	}
1377	while ((cp = next) != NULL);	1394	while ((cp = next) != NULL);
1378	}	1395	}
1379	else if (sscanf (cp, "chance %d", &value))	1396	else if (sscanf (cp, "chance %d", &value))
1380	art->chance = (uint16) value;	1397	art->chance = (uint16) value;
1381	else if (sscanf (cp, "difficulty %d", &value))	1398	else if (sscanf (cp, "difficulty %d", &value))
1382	art->difficulty = (uint8) value;	1399	art->difficulty = (uint8) value;
1383	else if (!strncmp (cp, "Object", 6))	1400	else if (!strncmp (cp, "Object", 6))
1384	{	1401	{
1385	art->item = get_object ();	1402	art->item = object::create ();
1386		1403
1387	if (!load_object (thawer, art->item, 0))	1404	if (!load_object (thawer, art->item, 0))
1388	LOG (llevError, "Init_Artifacts: Could not load object.\n");	1405	LOG (llevError, "Init_Artifacts: Could not load object.\n");
1389		1406
1390	art->item->name = strchr (cp, ' ') + 1;	1407	art->item->name = strchr (cp, ' ') + 1;
1391	al = find_artifactlist (art->item->type);	1408	al = find_artifactlist (art->item->type);
1392	if (al == NULL)	1409	if (al == NULL)
1393	{	1410	{
1394	al = get_empty_artifactlist ();	1411	al = get_empty_artifactlist ();
1395	al->type = art->item->type;	1412	al->type = art->item->type;
1396	al->next = first_artifactlist;	1413	al->next = first_artifactlist;
1397	first_artifactlist = al;	1414	first_artifactlist = al;
1398	}	1415	}
1399	art->next = al->items;	1416	art->next = al->items;
1400	al->items = art;	1417	al->items = art;
1401	art = NULL;	1418	art = NULL;
1402	}	1419	}
1403	else	1420	else
1404	LOG (llevError, "Unknown input in artifact file: %s\n", buf);	1421	LOG (llevError, "Unknown input in artifact file: %s\n", buf);
1405	}	1422	}
1406		1423
1407	for (al = first_artifactlist; al != NULL; al = al->next)	1424	for (al = first_artifactlist; al != NULL; al = al->next)
1408	{	1425	{
1409	for (art = al->items; art != NULL; art = art->next)	1426	for (art = al->items; art != NULL; art = art->next)
1410	{	1427	{
1411	if (!art->chance)	1428	if (!art->chance)
1412	LOG (llevError, "Warning: artifact with no chance: %s\n", &art->item->name);	1429	LOG (llevError, "Warning: artifact with no chance: %s\n", &art->item->name);
1413	else	1430	else
1414	al->total_chance += art->chance;	1431	al->total_chance += art->chance;
1415	}	1432	}
1416	#if 0	1433	#if 0
1417	LOG (llevDebug, "Artifact list type %d has %d total chance\n", al->type, al->total_chance);	1434	LOG (llevDebug, "Artifact list type %d has %d total chance\n", al->type, al->total_chance);
1418	#endif	1435	#endif
1419	}	1436	}
1420		1437
…		…
1426	* Used in artifact generation. The bonuses of the first object	1443	* Used in artifact generation. The bonuses of the first object
1427	* is modified by the bonuses of the second object.	1444	* is modified by the bonuses of the second object.
1428	*/	1445	*/
1429		1446
1430	void	1447	void
1431	add_abilities (object * op, object * change)	1448	add_abilities (object *op, object *change)
1432	{	1449	{
1433	int i, j, tmp;	1450	int i, tmp;
1434		1451
1435	if (change->face != blank_face)	1452	if (change->face != blank_face)
1436	{	1453	{
1437	#ifdef TREASURE_VERBOSE	1454	#ifdef TREASURE_VERBOSE
1438	LOG (llevDebug, "FACE: %d\n", change->face->number);	1455	LOG (llevDebug, "FACE: %d\n", change->face->number);
…		…
1477	if (QUERY_FLAG (change, FLAG_STAND_STILL))	1494	if (QUERY_FLAG (change, FLAG_STAND_STILL))
1478	{	1495	{
1479	CLEAR_FLAG (op, FLAG_ANIMATE);	1496	CLEAR_FLAG (op, FLAG_ANIMATE);
1480	/* so artifacts will join */	1497	/* so artifacts will join */
1481	if (!QUERY_FLAG (op, FLAG_ALIVE))	1498	if (!QUERY_FLAG (op, FLAG_ALIVE))
1482	op->speed = 0.0;	1499	op->speed = 0.0;
1483		1500
1484	update_ob_speed (op);	1501	op->set_speed (op->speed);
1485	}	1502	}
1486		1503
1487	if (change->nrof)	1504	if (change->nrof)
1488	op->nrof = RANDOM () % ((int) change->nrof) + 1;	1505	op->nrof = RANDOM () % ((int) change->nrof) + 1;
1489		1506
1490	op->stats.exp += change->stats.exp; /* Speed modifier */	1507	op->stats.exp += change->stats.exp; /* Speed modifier */
1491	op->stats.wc += change->stats.wc;	1508	op->stats.wc += change->stats.wc;
1492	op->stats.ac += change->stats.ac;	1509	op->stats.ac += change->stats.ac;
1493		1510
1494	if (change->other_arch)	1511	if (change->other_arch)
1495	{	1512	{
1496	/* Basically, for horns & potions, the other_arch field is the spell	1513	/* Basically, for horns & potions, the other_arch field is the spell
1497	* to cast. So convert that to into a spell and put it into	1514	* to cast. So convert that to into a spell and put it into
1498	* this object.	1515	* this object.
1499	*/	1516	*/
1500	if (op->type == HORN || op->type == POTION)	1517	if (op->type == HORN || op->type == POTION)
1501	{	1518	{
1502	object *tmp_obj;	1519	object *tmp_obj;
		1520
1503	/* Remove any spells this object currently has in it */	1521	/* Remove any spells this object currently has in it */
1504	while (op->inv)	1522	while (op->inv)
1505	{	1523	op->inv->destroy ();
1506	tmp_obj = op->inv;
1507	remove_ob (tmp_obj);
1508	free_object (tmp_obj);
1509	}
1510		1524
1511	tmp_obj = arch_to_object (change->other_arch);	1525	tmp_obj = arch_to_object (change->other_arch);
1512	insert_ob_in_ob (tmp_obj, op);	1526	insert_ob_in_ob (tmp_obj, op);
1513	}	1527	}
1514	/* No harm setting this for potions/horns */	1528	/* No harm setting this for potions/horns */
1515	op->other_arch = change->other_arch;	1529	op->other_arch = change->other_arch;
1516	}	1530	}
1517		1531
1518	if (change->stats.hp < 0)	1532	if (change->stats.hp < 0)
…		…
1551	op->gen_sp_armour = (op->gen_sp_armour * (change->gen_sp_armour)) / 100;	1565	op->gen_sp_armour = (op->gen_sp_armour * (change->gen_sp_armour)) / 100;
1552		1566
1553	op->item_power = change->item_power;	1567	op->item_power = change->item_power;
1554		1568
1555	for (i = 0; i < NROFATTACKS; i++)	1569	for (i = 0; i < NROFATTACKS; i++)
1556	{
1557	if (change->resist[i])	1570	if (change->resist[i])
1558	{
1559	op->resist[i] += change->resist[i];	1571	op->resist[i] += change->resist[i];
1560	}
1561	}
1562		1572
1563	if (change->stats.dam)	1573	if (change->stats.dam)
1564	{	1574	{
1565	if (change->stats.dam < 0)	1575	if (change->stats.dam < 0)
1566	op->stats.dam = (-change->stats.dam);	1576	op->stats.dam = (-change->stats.dam);
1567	else if (op->stats.dam)	1577	else if (op->stats.dam)
1568	{	1578	{
1569	tmp = (signed char) (((int) op->stats.dam * (int) change->stats.dam) / 10);	1579	tmp = (signed char) (((int) op->stats.dam * (int) change->stats.dam) / 10);
1570	if (tmp == op->stats.dam)	1580	if (tmp == op->stats.dam)
1571	{	1581	{
1572	if (change->stats.dam < 10)	1582	if (change->stats.dam < 10)
1573	op->stats.dam--;	1583	op->stats.dam--;
		1584	else
		1585	op->stats.dam++;
		1586	}
1574	else	1587	else
1575	op->stats.dam++;
1576	}
1577	else
1578	op->stats.dam = tmp;	1588	op->stats.dam = tmp;
1579	}	1589	}
1580	}	1590	}
1581		1591
1582	if (change->weight)	1592	if (change->weight)
1583	{	1593	{
1584	if (change->weight < 0)	1594	if (change->weight < 0)
1585	op->weight = (-change->weight);	1595	op->weight = (-change->weight);
1586	else	1596	else
1587	op->weight = (op->weight * (change->weight)) / 100;	1597	op->weight = (op->weight * (change->weight)) / 100;
1588	}	1598	}
1589		1599
1590	if (change->last_sp)	1600	if (change->last_sp)
1591	{	1601	{
1592	if (change->last_sp < 0)	1602	if (change->last_sp < 0)
1593	op->last_sp = (-change->last_sp);	1603	op->last_sp = (-change->last_sp);
1594	else	1604	else
1595	op->last_sp = (signed char) (((int) op->last_sp * (int) change->last_sp) / (int) 100);	1605	op->last_sp = (signed char) (((int) op->last_sp * (int) change->last_sp) / (int) 100);
1596	}	1606	}
1597		1607
1598	if (change->gen_sp_armour)	1608	if (change->gen_sp_armour)
1599	{	1609	{
1600	if (change->gen_sp_armour < 0)	1610	if (change->gen_sp_armour < 0)
1601	op->gen_sp_armour = (-change->gen_sp_armour);	1611	op->gen_sp_armour = (-change->gen_sp_armour);
1602	else	1612	else
1603	op->gen_sp_armour = (signed char) (((int) op->gen_sp_armour * ((int) change->gen_sp_armour)) / (int) 100);	1613	op->gen_sp_armour = (signed char) (((int) op->gen_sp_armour * ((int) change->gen_sp_armour)) / (int) 100);
1604	}	1614	}
1605		1615
1606	op->value *= change->value;	1616	op->value *= change->value;
1607		1617
1608	if (change->material)	1618	if (change->material)
…		…
1620	if (change->msg)	1630	if (change->msg)
1621	op->msg = change->msg;	1631	op->msg = change->msg;
1622	}	1632	}
1623		1633
1624	static int	1634	static int
1625	legal_artifact_combination (object * op, artifact * art)	1635	legal_artifact_combination (object *op, artifact * art)
1626	{	1636	{
1627	int neg, success = 0;	1637	int neg, success = 0;
1628	linked_char *tmp;	1638	linked_char *tmp;
1629	const char *name;	1639	const char *name;
1630		1640
1631	if (art->allowed == (linked_char *) NULL)	1641	if (art->allowed == (linked_char *) NULL)
1632	return 1; /* Ie, "all" */	1642	return 1; /* Ie, "all" */
1633	for (tmp = art->allowed; tmp; tmp = tmp->next)	1643	for (tmp = art->allowed; tmp; tmp = tmp->next)
1634	{	1644	{
1635	#ifdef TREASURE_VERBOSE	1645	#ifdef TREASURE_VERBOSE
1636	LOG (llevDebug, "legal_art: %s\n", tmp->name);	1646	LOG (llevDebug, "legal_art: %s\n", tmp->name);
1637	#endif	1647	#endif
1638	if (*tmp->name == '!')	1648	if (*tmp->name == '!')
1639	name = tmp->name + 1, neg = 1;	1649	name = tmp->name + 1, neg = 1;
1640	else	1650	else
1641	name = tmp->name, neg = 0;	1651	name = tmp->name, neg = 0;
1642		1652
1643	/* If we match name, then return the opposite of 'neg' */	1653	/* If we match name, then return the opposite of 'neg' */
1644	if (!strcmp (name, op->name) || (op->arch && !strcmp (name, op->arch->name)))	1654	if (!strcmp (name, op->name) || (op->arch && !strcmp (name, op->arch->name)))
1645	return !neg;	1655	return !neg;
1646		1656
1647	/* Set success as true, since if the match was an inverse, it means	1657	/* Set success as true, since if the match was an inverse, it means
1648	* everything is allowed except what we match	1658	* everything is allowed except what we match
1649	*/	1659	*/
1650	else if (neg)	1660	else if (neg)
1651	success = 1;	1661	success = 1;
1652	}	1662	}
1653	return success;	1663	return success;
1654	}	1664	}
1655		1665
1656	/*	1666	/*
…		…
1663	{	1673	{
1664	char new_name[MAX_BUF];	1674	char new_name[MAX_BUF];
1665		1675
1666	sprintf (new_name, "of %s", &artifct->name);	1676	sprintf (new_name, "of %s", &artifct->name);
1667	op->title = new_name;	1677	op->title = new_name;
1668	add_abilities (op, artifct); /* Give out the bonuses */	1678	add_abilities (op, artifct); /* Give out the bonuses */
1669		1679
1670	#if 0 /* Bit verbose, but keep it here until next time I need it... */	1680	#if 0 /* Bit verbose, but keep it here until next time I need it... */
1671	{	1681	{
1672	char identified = QUERY_FLAG (op, FLAG_IDENTIFIED);	1682	char identified = QUERY_FLAG (op, FLAG_IDENTIFIED);
		1683
1673	SET_FLAG (op, FLAG_IDENTIFIED);	1684	SET_FLAG (op, FLAG_IDENTIFIED);
1674	LOG (llevDebug, "Generated artifact %s %s [%s]\n", op->name, op->title, describe_item (op, NULL));	1685	LOG (llevDebug, "Generated artifact %s %s [%s]\n", op->name, op->title, describe_item (op, NULL));
1675	if (!identified)	1686	if (!identified)
1676	CLEAR_FLAG (op, FLAG_IDENTIFIED);	1687	CLEAR_FLAG (op, FLAG_IDENTIFIED);
1677	}	1688	}
…		…
1689		1700
1690	/* Give 1 re-roll attempt per artifact */	1701	/* Give 1 re-roll attempt per artifact */
1691	#define ARTIFACT_TRIES 2	1702	#define ARTIFACT_TRIES 2
1692		1703
1693	void	1704	void
1694	generate_artifact (object * op, int difficulty)	1705	generate_artifact (object *op, int difficulty)
1695	{	1706	{
1696	artifactlist *al;	1707	artifactlist *al;
1697	artifact *art;	1708	artifact *art;
1698	int i;	1709	int i;
1699		1710
1700	al = find_artifactlist (op->type);	1711	al = find_artifactlist (op->type);
1701		1712
1702	if (al == NULL)	1713	if (al == NULL)
1703	{	1714	{
1704	#if 0 /* This is too verbose, usually */	1715	#if 0 /* This is too verbose, usually */
1705	LOG (llevDebug, "Couldn't change %s into artifact - no table.\n", op->name);	1716	LOG (llevDebug, "Couldn't change %s into artifact - no table.\n", op->name);
1706	#endif	1717	#endif
1707	return;	1718	return;
1708	}	1719	}
1709		1720
1710	for (i = 0; i < ARTIFACT_TRIES; i++)	1721	for (i = 0; i < ARTIFACT_TRIES; i++)
1711	{	1722	{
1712	int roll = RANDOM () % al->total_chance;	1723	int roll = RANDOM () % al->total_chance;
1713		1724
1714	for (art = al->items; art != NULL; art = art->next)	1725	for (art = al->items; art != NULL; art = art->next)
1715	{	1726	{
1716	roll -= art->chance;	1727	roll -= art->chance;
1717	if (roll < 0)	1728	if (roll < 0)
1718	break;	1729	break;
1719	}	1730	}
1720		1731
1721	if (art == NULL || roll >= 0)	1732	if (art == NULL || roll >= 0)
1722	{	1733	{
1723	#if 1	1734	#if 1
1724	LOG (llevError, "Got null entry and non zero roll in generate_artifact, type %d\n", op->type);	1735	LOG (llevError, "Got null entry and non zero roll in generate_artifact, type %d\n", op->type);
1725	#endif	1736	#endif
1726	return;	1737	return;
1727	}	1738	}
1728	if (!strcmp (art->item->name, "NONE"))	1739	if (!strcmp (art->item->name, "NONE"))
1729	return;	1740	return;
1730	if (FABS (op->magic) < art->item->magic)	1741	if (FABS (op->magic) < art->item->magic)
1731	continue; /* Not magic enough to be this item */	1742	continue; /* Not magic enough to be this item */
1732		1743
1733	/* Map difficulty not high enough */	1744	/* Map difficulty not high enough */
1734	if (difficulty < art->difficulty)	1745	if (difficulty < art->difficulty)
1735	continue;	1746	continue;
1736		1747
1737	if (!legal_artifact_combination (op, art))	1748	if (!legal_artifact_combination (op, art))
1738	{	1749	{
1739	#ifdef TREASURE_VERBOSE	1750	#ifdef TREASURE_VERBOSE
1740	LOG (llevDebug, "%s of %s was not a legal combination.\n", op->name, art->item->name);	1751	LOG (llevDebug, "%s of %s was not a legal combination.\n", op->name, art->item->name);
1741	#endif	1752	#endif
1742	continue;	1753	continue;
1743	}	1754	}
1744	give_artifact_abilities (op, art->item);	1755	give_artifact_abilities (op, art->item);
1745	return;	1756	return;
1746	}	1757	}
1747	}	1758	}
1748		1759
…		…
1750	* FOOD, except they inherit properties (name, food value, etc).	1761	* FOOD, except they inherit properties (name, food value, etc).
1751	* based on the original owner (or 'donor' if you like). -b.t.	1762	* based on the original owner (or 'donor' if you like). -b.t.
1752	*/	1763	*/
1753		1764
1754	void	1765	void
1755	fix_flesh_item (object * item, object * donor)	1766	fix_flesh_item (object *item, object *donor)
1756	{	1767	{
1757	char tmpbuf[MAX_BUF];	1768	char tmpbuf[MAX_BUF];
1758	int i;	1769	int i;
1759		1770
1760	if (item->type == FLESH && donor)	1771	if (item->type == FLESH && donor)
1761	{	1772	{
1762	/* change the name */	1773	/* change the name */
1763	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name); item->name = tmpbuf;	1774	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name);
		1775	item->name = tmpbuf;
1764	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name_pl); item->name_pl = tmpbuf;	1776	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name_pl);
		1777	item->name_pl = tmpbuf;
1765		1778
1766	/* weight is FLESH weight/100 * donor */	1779	/* weight is FLESH weight/100 * donor */
1767	if ((item->weight = (signed long) (((double) item->weight / (double) 100.0) * (double) donor->weight)) == 0)	1780	if ((item->weight = (signed long) (((double) item->weight / (double) 100.0) * (double) donor->weight)) == 0)
1768	item->weight = 1;	1781	item->weight = 1;
1769		1782
1770	/* value is multiplied by level of donor */	1783	/* value is multiplied by level of donor */
1771	item->value *= isqrt (donor->level * 2);	1784	item->value *= isqrt (donor->level * 2);
1772		1785
1773	/* food value */	1786	/* food value */
…		…
1775		1788
1776	/* flesh items inherit some abilities of donor, but not	1789	/* flesh items inherit some abilities of donor, but not
1777	* full effect.	1790	* full effect.
1778	*/	1791	*/
1779	for (i = 0; i < NROFATTACKS; i++)	1792	for (i = 0; i < NROFATTACKS; i++)
1780	item->resist[i] = donor->resist[i] / 2;	1793	item->resist[i] = donor->resist[i] / 2;
1781		1794
1782	/* item inherits donor's level (important for quezals) */	1795	/* item inherits donor's level (important for quezals) */
1783	item->level = donor->level;	1796	item->level = donor->level;
1784		1797
1785	/* if donor has some attacktypes, the flesh is poisonous */	1798	/* if donor has some attacktypes, the flesh is poisonous */
1786	if (donor->attacktype & AT_POISON)	1799	if (donor->attacktype & AT_POISON)
1787	item->type = POISON;	1800	item->type = POISON;
1788	if (donor->attacktype & AT_ACID)	1801	if (donor->attacktype & AT_ACID)
1789	item->stats.hp = -1 * item->stats.food;	1802	item->stats.hp = -1 * item->stats.food;
1790	SET_FLAG (item, FLAG_NO_STEAL);	1803	SET_FLAG (item, FLAG_NO_STEAL);
1791	}	1804	}
1792	}	1805	}
1793		1806
1794	/* special_potion() - so that old potion code is still done right. */	1807	/* special_potion() - so that old potion code is still done right. */
1795		1808
1796	int	1809	int
1797	special_potion (object * op)	1810	special_potion (object *op)
1798	{	1811	{
1799
1800	int i;
1801
1802	if (op->attacktype)	1812	if (op->attacktype)
1803	return 1;	1813	return 1;
1804		1814
1805	if (op->stats.Str || op->stats.Dex || op->stats.Con || op->stats.Pow || op->stats.Wis || op->stats.Int || op->stats.Cha)	1815	if (op->stats.Str || op->stats.Dex || op->stats.Con || op->stats.Pow || op->stats.Wis || op->stats.Int || op->stats.Cha)
1806	return 1;	1816	return 1;
1807		1817
1808	for (i = 0; i < NROFATTACKS; i++)	1818	for (int i = 0; i < NROFATTACKS; i++)
1809	if (op->resist[i])	1819	if (op->resist[i])
1810	return 1;	1820	return 1;
1811		1821
1812	return 0;	1822	return 0;
1813	}	1823	}
1814		1824
1815	void	1825	void
1816	free_treasurestruct (treasure * t)	1826	free_treasurestruct (treasure *t)
1817	{	1827	{
1818	if (t->next)	1828	if (t->next)
1819	free_treasurestruct (t->next);	1829	free_treasurestruct (t->next);
1820	if (t->next_yes)	1830	if (t->next_yes)
1821	free_treasurestruct (t->next_yes);	1831	free_treasurestruct (t->next_yes);
…		…
1824		1834
1825	delete t;	1835	delete t;
1826	}	1836	}
1827		1837
1828	void	1838	void
1829	free_charlinks (linked_char * lc)	1839	free_charlinks (linked_char *lc)
1830	{	1840	{
1831	if (lc->next)	1841	if (lc->next)
1832	free_charlinks (lc->next);	1842	free_charlinks (lc->next);
1833		1843
1834	delete lc;	1844	delete lc;
1835	}	1845	}
1836		1846
1837	void	1847	void
1838	free_artifact (artifact * at)	1848	free_artifact (artifact * at)
1839	{	1849	{
1840
1841	if (at->next)	1850	if (at->next)
1842	free_artifact (at->next);	1851	free_artifact (at->next);
		1852
1843	if (at->allowed)	1853	if (at->allowed)
1844	free_charlinks (at->allowed);	1854	free_charlinks (at->allowed);
1845		1855
1846	delete at->item;	1856	at->item->destroy (1);
1847		1857
1848	delete at;	1858	delete at;
1849	}	1859	}
1850		1860
1851	void	1861	void
1852	free_artifactlist (artifactlist * al)	1862	free_artifactlist (artifactlist * al)
1853	{	1863	{
1854	artifactlist *nextal;	1864	artifactlist *nextal;
		1865
1855	for (al = first_artifactlist; al != NULL; al = nextal)	1866	for (al = first_artifactlist; al; al = nextal)
1856	{	1867	{
1857	nextal = al->next;	1868	nextal = al->next;
		1869
1858	if (al->items)	1870	if (al->items)
1859	{
1860	free_artifact (al->items);	1871	free_artifact (al->items);
1861	}	1872
1862	free (al);	1873	free (al);
1863	}	1874	}
1864	}	1875	}
1865		1876
1866	void	1877	void
…		…
1871		1882
1872	for (tl = first_treasurelist; tl != NULL; tl = next)	1883	for (tl = first_treasurelist; tl != NULL; tl = next)
1873	{	1884	{
1874	next = tl->next;	1885	next = tl->next;
1875	if (tl->items)	1886	if (tl->items)
1876	free_treasurestruct (tl->items);	1887	free_treasurestruct (tl->items);
1877	delete tl;	1888	delete tl;
1878	}	1889	}
1879	free_artifactlist (first_artifactlist);	1890	free_artifactlist (first_artifactlist);
1880	}	1891	}

Diff Legend

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