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.6 by root, Thu Aug 31 18:59:23 2006 UTC vs.
Revision 1.21 by root, Wed Sep 27 00:36:08 2006 UTC

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

Diff Legend

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