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.15 by root, Sat Sep 9 21:48:28 2006 UTC vs.
Revision 1.19 by root, Thu Sep 14 22:34:00 2006 UTC

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

Diff Legend

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