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.5 by root, Wed Aug 30 06:06:27 2006 UTC vs.
Revision 1.25 by root, Tue Dec 12 22:37:05 2006 UTC

1
2	/*
3	* static char *rcs_treasure_c =
4	* "$Id: treasure.C,v 1.5 2006/08/30 06:06:27 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 && strcmp(t->name,"NONE"))	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	{
		455	difficulty = clamp (difficulty, 1, settings.max_level);
		456
424	object *ob = get_object(), *tmp;	457	object *ob = object::create (), *tmp;
425		458
426	create_treasure(t, ob, 0, difficulty, 0);	459	create_treasure (t, ob, 0, difficulty, 0);
427		460
428	/* Don't want to free the object we are about to return */	461	/* Don't want to free the object we are about to return */
429	tmp = ob->inv;	462	tmp = ob->inv;
430	if (tmp!=NULL) remove_ob(tmp);	463	if (tmp != NULL)
		464	tmp->remove ();
		465
431	if (ob->inv) {	466	if (ob->inv)
432	LOG(llevError,"In generate treasure, created multiple objects.\n");	467	LOG (llevError, "In generate treasure, created multiple objects.\n");
433	}	468
434	free_object(ob);	469	ob->destroy ();
435	return tmp;	470	return tmp;
436	}	471	}
437		472
438	/*	473	/*
439	* This is a new way of calculating the chance for an item to have	474	* This is a new way of calculating the chance for an item to have
440	* a specific magical bonus.	475	* a specific magical bonus.
441	* The array has two arguments, the difficulty of the level, and the	476	* The array has two arguments, the difficulty of the level, and the
442	* magical bonus "wanted".	477	* magical bonus "wanted".
443	*/	478	*/
444		479
445	static int difftomagic_list[DIFFLEVELS][MAXMAGIC+1] =	480	static int difftomagic_list[DIFFLEVELS][MAXMAGIC + 1] = {
446	{	481
447	/*chance of magic difficulty*/	482	/*chance of magic difficulty*/
		483
448	/* +0 +1 +2 +3 +4 */	484	/* +0 +1 +2 +3 +4 */
449	{ 95, 2, 2, 1, 0 }, /*1*/	485	{95, 2, 2, 1, 0}, /*1 */
450	{ 92, 5, 2, 1, 0 }, /*2*/	486	{92, 5, 2, 1, 0}, /*2 */
451	{ 85,10, 4, 1, 0 }, /*3*/	487	{85, 10, 4, 1, 0}, /*3 */
452	{ 80,14, 4, 2, 0 }, /*4*/	488	{80, 14, 4, 2, 0}, /*4 */
453	{ 75,17, 5, 2, 1 }, /*5*/	489	{75, 17, 5, 2, 1}, /*5 */
454	{ 70,18, 8, 3, 1 }, /*6*/	490	{70, 18, 8, 3, 1}, /*6 */
455	{ 65,21,10, 3, 1 }, /*7*/	491	{65, 21, 10, 3, 1}, /*7 */
456	{ 60,22,12, 4, 2 }, /*8*/	492	{60, 22, 12, 4, 2}, /*8 */
457	{ 55,25,14, 4, 2 }, /*9*/	493	{55, 25, 14, 4, 2}, /*9 */
458	{ 50,27,16, 5, 2 }, /*10*/	494	{50, 27, 16, 5, 2}, /*10 */
459	{ 45,28,18, 6, 3 }, /*11*/	495	{45, 28, 18, 6, 3}, /*11 */
460	{ 42,28,20, 7, 3 }, /*12*/	496	{42, 28, 20, 7, 3}, /*12 */
461	{ 40,27,21, 8, 4 }, /*13*/	497	{40, 27, 21, 8, 4}, /*13 */
462	{ 38,25,22,10, 5 }, /*14*/	498	{38, 25, 22, 10, 5}, /*14 */
463	{ 36,23,23,12, 6 }, /*15*/	499	{36, 23, 23, 12, 6}, /*15 */
464	{ 33,21,24,14, 8 }, /*16*/	500	{33, 21, 24, 14, 8}, /*16 */
465	{ 31,19,25,16, 9 }, /*17*/	501	{31, 19, 25, 16, 9}, /*17 */
466	{ 27,15,30,18,10 }, /*18*/	502	{27, 15, 30, 18, 10}, /*18 */
467	{ 20,12,30,25,13 }, /*19*/	503	{20, 12, 30, 25, 13}, /*19 */
468	{ 15,10,28,30,17 }, /*20*/	504	{15, 10, 28, 30, 17}, /*20 */
469	{ 13, 9,27,28,23 }, /*21*/	505	{13, 9, 27, 28, 23}, /*21 */
470	{ 10, 8,25,28,29 }, /*22*/	506	{10, 8, 25, 28, 29}, /*22 */
471	{ 8, 7,23,26,36 }, /*23*/	507	{8, 7, 23, 26, 36}, /*23 */
472	{ 6, 6,20,22,46 }, /*24*/	508	{6, 6, 20, 22, 46}, /*24 */
473	{ 4, 5,17,18,56 }, /*25*/	509	{4, 5, 17, 18, 56}, /*25 */
474	{ 2, 4,12,14,68 }, /*26*/	510	{2, 4, 12, 14, 68}, /*26 */
475	{ 0, 3, 7,10,80 }, /*27*/	511	{0, 3, 7, 10, 80}, /*27 */
476	{ 0, 0, 3, 7,90 }, /*28*/	512	{0, 0, 3, 7, 90}, /*28 */
477	{ 0, 0, 0, 3,97 }, /*29*/	513	{0, 0, 0, 3, 97}, /*29 */
478	{ 0, 0, 0, 0,100}, /*30*/	514	{0, 0, 0, 0, 100}, /*30 */
479	{ 0, 0, 0, 0,100}, /*31*/	515	{0, 0, 0, 0, 100}, /*31 */
480	};	516	};
481		517
482		518
483	/* calculate the appropriate level for wands staves and scrolls.	519	/* calculate the appropriate level for wands staves and scrolls.
484	* This code presumes that op has had its spell object created (in op->inv)	520	* This code presumes that op has had its spell object created (in op->inv)
485	*	521	*
486	* elmex Wed Aug 9 17:44:59 CEST 2006:	522	* elmex Wed Aug 9 17:44:59 CEST 2006:
487	* Removed multiplicator, too many high-level items were generated on low-difficulty maps.	523	* Removed multiplicator, too many high-level items were generated on low-difficulty maps.
488	*/	524	*/
489		525
		526	int
490	int level_for_item (const object *op, int difficulty)	527	level_for_item (const object *op, int difficulty)
491	{	528	{
492	int mult = 0, olevel = 0;	529	int olevel = 0;
493		530
494	if (!op->inv)	531	if (!op->inv)
495	{	532	{
496	LOG(llevError,"level_for_item: Object %s has no inventory!\n", op->name);	533	LOG (llevError, "level_for_item: Object %s has no inventory!\n", &op->name);
497	return 0;	534	return 0;
498	}	535	}
499		536
500	olevel = (int) (op->inv->level + (double) difficulty * (1 - drand48 () * drand48 () * 2));	537	olevel = (int) (op->inv->level + (double) difficulty * (1 - drand48 () * drand48 () * 2));
501		538
502	if (olevel <= 0)	539	if (olevel <= 0)
…		…
517	* Scaling difficulty by max_level, as difficulty is a level and not some	554	* Scaling difficulty by max_level, as difficulty is a level and not some
518	* weird integer between 1-31.	555	* weird integer between 1-31.
519	*	556	*
520	*/	557	*/
521		558
		559	int
522	int magic_from_difficulty(int difficulty)	560	magic_from_difficulty (int difficulty)
523	{	561	{
524	int percent = 0, magic = 0;	562	int percent = 0, magic = 0;
525	int scaled_diff = (int) (((double) difficulty / settings.max_level) * DIFFLEVELS);	563	int scaled_diff = (int) (((double) difficulty / settings.max_level) * DIFFLEVELS);
526		564
527	scaled_diff--;	565	scaled_diff--;
528		566
529	if(scaled_diff < 0)	567	if (scaled_diff < 0)
530	scaled_diff = 0;	568	scaled_diff = 0;
531		569
532	if (scaled_diff >= DIFFLEVELS)	570	if (scaled_diff >= DIFFLEVELS)
533	scaled_diff = DIFFLEVELS-1;	571	scaled_diff = DIFFLEVELS - 1;
534		572
535	percent = RANDOM()%100;	573	percent = RANDOM () % 100;
536		574
537	for(magic = 0; magic < (MAXMAGIC + 1); magic++)	575	for (magic = 0; magic < (MAXMAGIC + 1); magic++)
538	{	576	{
539	percent -= difftomagic_list[scaled_diff][magic];	577	percent -= difftomagic_list[scaled_diff][magic];
540		578
541	if (percent < 0)	579	if (percent < 0)
542	break;	580	break;
543	}	581	}
544		582
545	if (magic == (MAXMAGIC + 1))	583	if (magic == (MAXMAGIC + 1))
546	{	584	{
547	LOG(llevError,"Warning, table for difficulty (scaled %d) %d bad.\n", scaled_diff, difficulty);	585	LOG (llevError, "Warning, table for difficulty (scaled %d) %d bad.\n", scaled_diff, difficulty);
548	magic = 0;	586	magic = 0;
549	}	587	}
550		588
551	magic = (RANDOM() % 3) ? magic : -magic;	589	magic = (RANDOM () % 3) ? magic : -magic;
552	/* LOG(llevDebug, "Chose magic %d for difficulty (scaled %d) %d\n", magic, scaled_diff, difficulty); */	590	/* LOG(llevDebug, "Chose magic %d for difficulty (scaled %d) %d\n", magic, scaled_diff, difficulty); */
553		591
554	return magic;	592	return magic;
555	}	593	}
556		594
…		…
559	* the armour variable, and the effect on speed of armour.	597	* the armour variable, and the effect on speed of armour.
560	* This function doesn't work properly, should add use of archetypes	598	* This function doesn't work properly, should add use of archetypes
561	* to make it truly absolute.	599	* to make it truly absolute.
562	*/	600	*/
563		601
		602	void
564	void set_abs_magic(object *op, int magic) {	603	set_abs_magic (object *op, int magic)
		604	{
565	if(!magic)	605	if (!magic)
566	return;	606	return;
567		607
568	op->magic=magic;	608	op->magic = magic;
569	if (op->arch) {	609	if (op->arch)
		610	{
570	if (op->type == ARMOUR)	611	if (op->type == ARMOUR)
571	ARMOUR_SPEED(op)=(ARMOUR_SPEED(&op->arch->clone)*(100+magic*10))/100;	612	ARMOUR_SPEED (op) = (ARMOUR_SPEED (&op->arch->clone) * (100 + magic * 10)) / 100;
572		613
573	if (magic < 0 && !(RANDOM()%3)) /* You can't just check the weight always */	614	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */
574	magic = (-magic);	615	magic = (-magic);
575	op->weight = (op->arch->clone.weight*(100-magic*10))/100;	616	op->weight = (op->arch->clone.weight * (100 - magic * 10)) / 100;
		617	}
576	} else {	618	else
		619	{
577	if(op->type==ARMOUR)	620	if (op->type == ARMOUR)
578	ARMOUR_SPEED(op)=(ARMOUR_SPEED(op)*(100+magic*10))/100;	621	ARMOUR_SPEED (op) = (ARMOUR_SPEED (op) * (100 + magic * 10)) / 100;
579	if (magic < 0 && !(RANDOM()%3)) /* You can't just check the weight always */	622	if (magic < 0 && !(RANDOM () % 3)) /* You can't just check the weight always */
580	magic = (-magic);	623	magic = (-magic);
581	op->weight=(op->weight*(100-magic*10))/100;	624	op->weight = (op->weight * (100 - magic * 10)) / 100;
582	}	625	}
583	}	626	}
584		627
585	/*	628	/*
586	* Sets a random magical bonus in the given object based upon	629	* Sets a random magical bonus in the given object based upon
587	* the given difficulty, and the given max possible bonus.	630	* the given difficulty, and the given max possible bonus.
588	*/	631	*/
589		632
		633	static void
590	static void set_magic (int difficulty, object *op, int max_magic, int flags)	634	set_magic (int difficulty, object *op, int max_magic, int flags)
591	{	635	{
592	int i;	636	int i;
		637
593	i = magic_from_difficulty(difficulty);	638	i = magic_from_difficulty (difficulty);
594	if ((flags & GT_ONLY_GOOD) && i < 0)	639	if ((flags & GT_ONLY_GOOD) && i < 0)
595	i = -i;	640	i = -i;
596	if(i > max_magic)	641	if (i > max_magic)
597	i = max_magic;	642	i = max_magic;
598	set_abs_magic(op,i);	643	set_abs_magic (op, i);
599	if (i < 0)	644	if (i < 0)
600	SET_FLAG(op, FLAG_CURSED);	645	SET_FLAG (op, FLAG_CURSED);
601	}	646	}
602		647
603	/*	648	/*
604	* Randomly adds one magical ability to the given object.	649	* Randomly adds one magical ability to the given object.
605	* Modified for Partial Resistance in many ways:	650	* Modified for Partial Resistance in many ways:
…		…
607	* is rolled again, increase it - the bonuses now stack with	652	* is rolled again, increase it - the bonuses now stack with
608	* other bonuses previously rolled and ones the item might natively have.	653	* other bonuses previously rolled and ones the item might natively have.
609	* 2) Add code to deal with new PR method.	654	* 2) Add code to deal with new PR method.
610	*/	655	*/
611		656
		657	void
612	void set_ring_bonus(object *op,int bonus) {	658	set_ring_bonus (object *op, int bonus)
		659	{
613		660
614	int r=RANDOM()%(bonus>0?25:11);	661	int r = RANDOM () % (bonus > 0 ? 25 : 11);
615		662
616	if(op->type==AMULET) {	663	if (op->type == AMULET)
		664	{
617	if(!(RANDOM()%21))	665	if (!(RANDOM () % 21))
618	r=20+RANDOM()%2;	666	r = 20 + RANDOM () % 2;
619	else {	667	else
		668	{
620	if(RANDOM()&2)	669	if (RANDOM () & 2)
621	r=10;	670	r = 10;
622	else	671	else
623	r=11+RANDOM()%9;	672	r = 11 + RANDOM () % 9;
624	}	673	}
625	}	674	}
626		675
627	switch(r) {	676	switch (r)
		677	{
628	/* Redone by MSW 2000-11-26 to have much less code. Also,	678	/* Redone by MSW 2000-11-26 to have much less code. Also,
629	* bonuses and penalties will stack and add to existing values.	679	* bonuses and penalties will stack and add to existing values.
630	* of the item.	680	* of the item.
631	*/	681	*/
632	case 0:	682	case 0:
633	case 1:	683	case 1:
634	case 2:	684	case 2:
635	case 3:	685	case 3:
636	case 4:	686	case 4:
637	case 5:	687	case 5:
638	case 6:	688	case 6:
639	set_attr_value(&op->stats, r, (signed char)(bonus + get_attr_value(&op->stats,r)));	689	set_attr_value (&op->stats, r, (signed char) (bonus + get_attr_value (&op->stats, r)));
640	break;	690	break;
641		691
642	case 7:	692	case 7:
643	op->stats.dam+=bonus;	693	op->stats.dam += bonus;
644	break;	694	break;
645		695
646	case 8:	696	case 8:
647	op->stats.wc+=bonus;	697	op->stats.wc += bonus;
648	break;	698	break;
649		699
650	case 9:	700	case 9:
651	op->stats.food+=bonus; /* hunger/sustenance */	701	op->stats.food += bonus; /* hunger/sustenance */
652	break;	702	break;
653		703
654	case 10:	704	case 10:
655	op->stats.ac+=bonus;	705	op->stats.ac += bonus;
656	break;	706	break;
657		707
658	/* Item that gives protections/vulnerabilities */	708	/* Item that gives protections/vulnerabilities */
659	case 11:	709	case 11:
660	case 12:	710	case 12:
661	case 13:	711	case 13:
662	case 14:	712	case 14:
663	case 15:	713	case 15:
664	case 16:	714	case 16:
665	case 17:	715	case 17:
666	case 18:	716	case 18:
667	case 19:	717	case 19:
668	{	718	{
669	int b=5+FABS(bonus),val,resist=RANDOM() % num_resist_table;	719	int b = 5 + FABS (bonus), val, resist = RANDOM () % num_resist_table;
670		720
671	/* Roughly generate a bonus between 100 and 35 (depending on the bonus) */	721	/* Roughly generate a bonus between 100 and 35 (depending on the bonus) */
672	val = 10 + RANDOM() % b + RANDOM() % b + RANDOM() % b + RANDOM() % b;	722	val = 10 + RANDOM () % b + RANDOM () % b + RANDOM () % b + RANDOM () % b;
673		723
674	/* Cursed items need to have higher negative values to equal out with	724	/* Cursed items need to have higher negative values to equal out with
675	* positive values for how protections work out. Put another	725	* positive values for how protections work out. Put another
676	* little random element in since that they don't always end up with	726	* little random element in since that they don't always end up with
677	* even values.	727	* even values.
678	*/	728	*/
		729	if (bonus < 0)
679	if (bonus<0) val = 2*-val - RANDOM() % b;	730	val = 2 * -val - RANDOM () % b;
680	if (val>35) val=35; /* Upper limit */	731	if (val > 35)
		732	val = 35; /* Upper limit */
681	b=0;	733	b = 0;
682	while (op->resist[resist_table[resist]]!=0 && b<4) {	734	while (op->resist[resist_table[resist]] != 0 && b < 4)
		735	{
683	resist=RANDOM() % num_resist_table;	736	resist = RANDOM () % num_resist_table;
684	}	737	}
		738	if (b == 4)
685	if (b==4) return; /* Not able to find a free resistance */	739	return; /* Not able to find a free resistance */
686	op->resist[resist_table[resist]] = val;	740	op->resist[resist_table[resist]] = val;
687	/* We should probably do something more clever here to adjust value	741	/* We should probably do something more clever here to adjust value
688	* based on how good a resistance we gave.	742	* based on how good a resistance we gave.
689	*/	743	*/
690	break;	744	break;
691	}	745	}
692	case 20:	746	case 20:
693	if(op->type==AMULET) {	747	if (op->type == AMULET)
		748	{
694	SET_FLAG(op,FLAG_REFL_SPELL);	749	SET_FLAG (op, FLAG_REFL_SPELL);
695	op->value*=11;	750	op->value *= 11;
696	} else {
697	op->stats.hp=1; /* regenerate hit points */
698	op->value*=4;
699	}	751	}
		752	else
		753	{
		754	op->stats.hp = 1; /* regenerate hit points */
		755	op->value *= 4;
		756	}
700	break;	757	break;
701		758
702	case 21:	759	case 21:
703	if(op->type==AMULET) {	760	if (op->type == AMULET)
		761	{
704	SET_FLAG(op,FLAG_REFL_MISSILE);	762	SET_FLAG (op, FLAG_REFL_MISSILE);
705	op->value*=9;	763	op->value *= 9;
706	} else {
707	op->stats.sp=1; /* regenerate spell points */
708	op->value*=3;
709	}	764	}
		765	else
		766	{
		767	op->stats.sp = 1; /* regenerate spell points */
		768	op->value *= 3;
		769	}
710	break;	770	break;
711		771
712	case 22:	772	case 22:
713	op->stats.exp+=bonus; /* Speed! */	773	op->stats.exp += bonus; /* Speed! */
714	op->value=(op->value*2)/3;	774	op->value = (op->value * 2) / 3;
715	break;	775	break;
716	}	776	}
717	if(bonus>0)	777	if (bonus > 0)
718	op->value*=2*bonus;	778	op->value *= 2 * bonus;
719	else	779	else
720	op->value= -(op->value*2*bonus)/3;	780	op->value = -(op->value * 2 * bonus) / 3;
721	}	781	}
722		782
723	/*	783	/*
724	* get_magic(diff) will return a random number between 0 and 4.	784	* 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	785	* 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	787	* It is only used in fix_generated_treasure() to set bonuses on
728	* rings and amulets.	788	* rings and amulets.
729	* Another scheme is used to calculate the magic of weapons and armours.	789	* Another scheme is used to calculate the magic of weapons and armours.
730	*/	790	*/
731		791
		792	int
732	int get_magic(int diff) {	793	get_magic (int diff)
		794	{
733	int i;	795	int i;
		796
734	if(diff<3)	797	if (diff < 3)
735	diff=3;	798	diff = 3;
736	for(i=0;i<4;i++)	799	for (i = 0; i < 4; i++)
737	if(RANDOM()%diff) return i;	800	if (RANDOM () % diff)
		801	return i;
738	return 4;	802	return 4;
739	}	803	}
740		804
741	#define DICE2 (get_magic(2)==2?2:1)	805	#define DICE2 (get_magic(2)==2?2:1)
742	#define DICESPELL (RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3)	806	#define DICESPELL (RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3)
…		…
744	/*	808	/*
745	* fix_generated_item(): This is called after an item is generated, in	809	* 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	810	* order to set it up right. This produced magical bonuses, puts spells
747	* into scrolls/books/wands, makes it unidentified, hides the value, etc.	811	* into scrolls/books/wands, makes it unidentified, hides the value, etc.
748	*/	812	*/
		813
749	/* 4/28/96 added creator object from which op may now inherit properties based on	814	/* 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	815	* 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	816	* dependant. I know this is a spagetti manuever, but is there a cleaner
752	* way to do this? b.t. */	817	* way to do this? b.t. */
		818
753	/*	819	/*
754	* ! (flags & GT_ENVIRONMENT):	820	* ! (flags & GT_ENVIRONMENT):
755	* Automatically calls fix_flesh_item().	821	* Automatically calls fix_flesh_item().
756	*	822	*
757	* flags:	823	* flags:
…		…
760	* GT_MINIMAL: Does minimal processing on the object - just enough to make it	826	* 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	827	* 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	828	* type as appropriate, for objects that need spell objects, set those, etc
763	*/	829	*/
764		830
		831	void
765	void fix_generated_item (object * op, object * creator, int difficulty,	832	fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags)
766	int max_magic, int flags)
767	{	833	{
768	int was_magic = op->magic, num_enchantments = 0, save_item_power = 0;	834	int was_magic = op->magic, num_enchantments = 0, save_item_power = 0;
769		835
770	if (!creator || creator->type == op->type)	836	if (!creator || creator->type == op->type)
771	creator = op; /*safety & to prevent polymorphed objects giving attributes */	837	creator = op; /*safety & to prevent polymorphed objects giving attributes */
…		…
776		842
777	if (op->randomitems && op->type != SPELL)	843	if (op->randomitems && op->type != SPELL)
778	{	844	{
779	create_treasure (op->randomitems, op, flags, difficulty, 0);	845	create_treasure (op->randomitems, op, flags, difficulty, 0);
780	if (!op->inv)	846	if (!op->inv)
781	LOG (llevDebug,
782	"fix_generated_item: Unable to generate treasure for %s\n",	847	LOG (llevDebug, "fix_generated_item: Unable to generate treasure for %s\n", &op->name);
783	op->name);
784		848
785	/* So the treasure doesn't get created again */	849	/* So the treasure doesn't get created again */
786	op->randomitems = NULL;	850	op->randomitems = NULL;
787	}	851	}
788		852
789	if (difficulty < 1)	853	if (difficulty < 1)
790	difficulty = 1;	854	difficulty = 1;
		855
		856	if (INVOKE_OBJECT (ADD_BONUS, op,
		857	ARG_OBJECT (creator != op ? creator : 0),
		858	ARG_INT (difficulty), ARG_INT (max_magic),
		859	ARG_INT (flags)))
		860	return;
791		861
792	if (!(flags & GT_MINIMAL))	862	if (!(flags & GT_MINIMAL))
793	{	863	{
794	if (op->arch == crown_arch)	864	if (op->arch == crown_arch)
795	{	865	{
…		…
802	if (!op->magic && max_magic)	872	if (!op->magic && max_magic)
803	set_magic (difficulty, op, max_magic, flags);	873	set_magic (difficulty, op, max_magic, flags);
804		874
805	num_enchantments = calc_item_power (op, 1);	875	num_enchantments = calc_item_power (op, 1);
806		876
807	if ((!was_magic && !(RANDOM () % CHANCE_FOR_ARTIFACT))	877	if ((!was_magic && !(RANDOM () % CHANCE_FOR_ARTIFACT)) || op->type == HORN || difficulty >= settings.max_level) /* high difficulties always generate an artifact,
808	|| op->type == HORN	878	* 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);	879	generate_artifact (op, difficulty);
812	}	880	}
813		881
814	/* Object was made an artifact. Calculate its item_power rating.	882	/* Object was made an artifact. Calculate its item_power rating.
815	* the item_power in the object is what the artfiact adds.	883	* 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	890	* 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	891	* that since item_power is not quite linear, this actually ends up
824	* being somewhat of a bonus	892	* being somewhat of a bonus
825	*/	893	*/
826	if (save_item_power)	894	if (save_item_power)
827	op->item_power =
828	save_item_power + get_power_from_ench (op->item_power);	895	op->item_power = save_item_power + get_power_from_ench (op->item_power);
829	else	896	else
830	op->item_power =
831	get_power_from_ench (op->item_power + num_enchantments);	897	op->item_power = get_power_from_ench (op->item_power + num_enchantments);
832	}	898	}
833	else if (save_item_power)	899	else if (save_item_power)
834	{	900	{
835	/* restore the item_power field to the object if we haven't changed it.	901	/* 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	902	* we don't care about num_enchantments - that will basically just
…		…
844	* was never previously calculated. Let's compute a value and see if	910	* 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	911	* it is non-zero. If it indeed is, then assign it as the new
846	* item_power value.	912	* item_power value.
847	* - gros, 21th of July 2006.	913	* - gros, 21th of July 2006.
848	*/	914	*/
849	op->item_power = calc_item_power(op,0);	915	op->item_power = calc_item_power (op, 0);
850	save_item_power = op->item_power; /* Just in case it would get used	916	save_item_power = op->item_power; /* Just in case it would get used
851	* again below */	917	* again below */
852	}	918	}
853	}	919	}
854		920
855	/* materialtype modifications. Note we allow this on artifacts. */	921	/* materialtype modifications. Note we allow this on artifacts. */
856	set_materialname (op, difficulty, NULL);	922	set_materialname (op, difficulty, NULL);
…		…
869	}	935	}
870	}	936	}
871	else if (!op->title) /* Only modify object if not special */	937	else if (!op->title) /* Only modify object if not special */
872	switch (op->type)	938	switch (op->type)
873	{	939	{
874	case WEAPON:	940	case WEAPON:
875	case ARMOUR:	941	case ARMOUR:
876	case SHIELD:	942	case SHIELD:
877	case HELMET:	943	case HELMET:
878	case CLOAK:	944	case CLOAK:
879	if (QUERY_FLAG (op, FLAG_CURSED) && !(RANDOM () % 4))	945	if (QUERY_FLAG (op, FLAG_CURSED) && !(RANDOM () % 4))
880	set_ring_bonus (op, -DICE2);	946	set_ring_bonus (op, -DICE2);
881	break;	947	break;
882		948
883	case BRACERS:	949	case BRACERS:
884	if (!(RANDOM () % (QUERY_FLAG (op, FLAG_CURSED) ? 5 : 20)))	950	if (!(RANDOM () % (QUERY_FLAG (op, FLAG_CURSED) ? 5 : 20)))
		951	{
		952	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
		953	if (!QUERY_FLAG (op, FLAG_CURSED))
		954	op->value *= 3;
		955	}
		956	break;
		957
		958	case POTION:
885	{	959	{
		960	int too_many_tries = 0, is_special = 0;
		961
		962	/* Handle healing and magic power potions */
		963	if (op->stats.sp && !op->randomitems)
		964	{
		965	object *tmp;
		966
		967	tmp = get_archetype (spell_mapping[op->stats.sp]);
		968	insert_ob_in_ob (tmp, op);
		969	op->stats.sp = 0;
		970	}
		971
		972	while (!(is_special = special_potion (op)) && !op->inv)
		973	{
		974	generate_artifact (op, difficulty);
		975	if (too_many_tries++ > 10)
		976	break;
		977	}
		978
		979	/* don't want to change value for healing/magic power potions,
		980	* since the value set on those is already correct.
		981	*/
		982	if (op->inv && op->randomitems)
		983	{
		984	/* value multiplier is same as for scrolls */
		985	op->value = (op->value * op->inv->value);
		986	op->level = op->inv->level / 2 + RANDOM () % difficulty + RANDOM () % difficulty;
		987	}
		988	else
		989	{
		990	op->name = "potion";
		991	op->name_pl = "potions";
		992	}
		993
		994	if (!(flags & GT_ONLY_GOOD) && RANDOM () % 2)
		995	SET_FLAG (op, FLAG_CURSED);
		996	break;
		997	}
		998
		999	case AMULET:
		1000	if (op->arch == amulet_arch)
		1001	op->value *= 5; /* Since it's not just decoration */
		1002
		1003	case RING:
		1004	if (op->arch == NULL)
		1005	{
		1006	op->destroy ();
		1007	op = 0;
		1008	break;
		1009	}
		1010
		1011	if (op->arch != ring_arch && op->arch != amulet_arch) /* It's a special artifact! */
		1012	break;
		1013
		1014	if (!(flags & GT_ONLY_GOOD) && !(RANDOM () % 3))
		1015	SET_FLAG (op, FLAG_CURSED);
		1016
886	set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);	1017	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		1018
892	case POTION:	1019	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;	1020	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		1021
968	if (!(RANDOM () % 4))	1022	if (!(RANDOM () % 4))
969	{	1023	{
970	int d = (RANDOM () % 3
971	|| QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;	1024	int d = (RANDOM () % 2 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
		1025
972	if (d > 0)	1026	if (d > 0)
973	op->value *= 5;	1027	op->value *= 3;
		1028
974	set_ring_bonus (op, d);	1029	set_ring_bonus (op, d);
		1030
		1031	if (!(RANDOM () % 4))
		1032	{
		1033	int d = (RANDOM () % 3 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
		1034
		1035	if (d > 0)
		1036	op->value *= 5;
		1037	set_ring_bonus (op, d);
		1038	}
975	}	1039	}
976	}
977		1040
978	if (GET_ANIM_ID (op))	1041	if (GET_ANIM_ID (op))
979	SET_ANIMATION (op, RANDOM () % ((int) NUM_ANIMATIONS (op)));	1042	SET_ANIMATION (op, RANDOM () % ((int) NUM_ANIMATIONS (op)));
980		1043
981	break;	1044	break;
982		1045
983	case BOOK:	1046	case BOOK:
984	/* Is it an empty book?, if yes lets make a special·	1047	/* Is it an empty book?, if yes lets make a special·
985	* msg for it, and tailor its properties based on the·	1048	* msg for it, and tailor its properties based on the·
986	* creator and/or map level we found it on.	1049	* creator and/or map level we found it on.
987	*/	1050	*/
988	if (!op->msg && RANDOM () % 10)	1051	if (!op->msg && RANDOM () % 10)
989	{
990	/* set the book level properly */
991	if (creator->level == 0 || QUERY_FLAG (creator, FLAG_ALIVE))
992	{	1052	{
		1053	/* set the book level properly */
		1054	if (creator->level == 0 || QUERY_FLAG (creator, FLAG_ALIVE))
		1055	{
993	if (op->map && op->map->difficulty)	1056	if (op->map && op->map->difficulty)
994	op->level =
995	RANDOM () % (op->map->difficulty) + RANDOM () % 10 + 1;	1057	op->level = RANDOM () % (op->map->difficulty) + RANDOM () % 10 + 1;
		1058	else
		1059	op->level = RANDOM () % 20 + 1;
		1060	}
996	else	1061	else
997	op->level = RANDOM () % 20 + 1;	1062	op->level = RANDOM () % creator->level;
		1063
		1064	tailor_readable_ob (op, (creator && creator->stats.sp) ? creator->stats.sp : -1);
		1065	/* books w/ info are worth more! */
		1066	op->value *= ((op->level > 10 ? op->level : (op->level + 1) / 2) * ((strlen (op->msg) / 250) + 1));
		1067	/* creator related stuff */
		1068
		1069	/* for library, chained books. Note that some monsters have no_pick
		1070	* set - we don't want to set no pick in that case.
		1071	*/
		1072	if (QUERY_FLAG (creator, FLAG_NO_PICK) && !QUERY_FLAG (creator, FLAG_MONSTER))
		1073	SET_FLAG (op, FLAG_NO_PICK);
		1074	if (creator->slaying && !op->slaying) /* for check_inv floors */
		1075	op->slaying = creator->slaying;
		1076
		1077	/* add exp so reading it gives xp (once) */
		1078	op->stats.exp = op->value > 10000 ? op->value / 5 : op->value / 10;
		1079	}
		1080	break;
		1081
		1082	case SPELLBOOK:
		1083	op->value = op->value * op->inv->value;
		1084	/* add exp so learning gives xp */
		1085	op->level = op->inv->level;
		1086	op->stats.exp = op->value;
		1087	break;
		1088
		1089	case WAND:
		1090	/* nrof in the treasure list is number of charges,
		1091	* not number of wands. So copy that into food (charges),
		1092	* and reset nrof.
		1093	*/
		1094	op->stats.food = op->inv->nrof;
		1095	op->nrof = 1;
		1096	/* If the spell changes by level, choose a random level
		1097	* for it, and adjust price. If the spell doesn't
		1098	* change by level, just set the wand to the level of
		1099	* the spell, and value calculation is simpler.
		1100	*/
		1101	if (op->inv->duration_modifier || op->inv->dam_modifier || op->inv->range_modifier)
		1102	{
		1103	op->level = level_for_item (op, difficulty);
		1104	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
998	}	1105	}
999	else	1106	else
1000	op->level = RANDOM () % creator->level;	1107	{
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 +	1108	op->level = op->inv->level;
1010	1) / 2) * ((strlen (op->msg) / 250) + 1));	1109	op->value = op->value * op->inv->value;
1011	/* creator related stuff */	1110	}
		1111	break;
1012		1112
1013	/* for library, chained books. Note that some monsters have no_pick	1113	case ROD:
1014	* set - we don't want to set no pick in that case.	1114	op->level = level_for_item (op, difficulty);
		1115	/* Add 50 to both level an divisor to keep prices a little more
		1116	* reasonable. Otherwise, a high level version of a low level
		1117	* spell can be worth tons a money (eg, level 20 rod, level 2 spell =
		1118	* 10 time multiplier). This way, the value are a bit more reasonable.
1015	*/	1119	*/
1016	if (QUERY_FLAG (creator, FLAG_NO_PICK) &&	1120	op->value = op->value * op->inv->value * (op->level + 50) / (op->inv->level + 50);
1017	!QUERY_FLAG (creator, FLAG_MONSTER))	1121	/* 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 =	1122	if (op->stats.maxhp)
1024	op->value > 10000 ? op->value / 5 : op->value / 10;	1123	op->stats.maxhp *= MAX (op->inv->stats.sp, op->inv->stats.grace);
1025	}	1124	else
		1125	op->stats.maxhp = 2 * MAX (op->inv->stats.sp, op->inv->stats.grace);
		1126
		1127	op->stats.hp = op->stats.maxhp;
1026	break;	1128	break;
1027		1129
1028	case SPELLBOOK:	1130	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);	1131	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 +	1132	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		1133
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 */	1134	/* add exp so reading them properly gives xp */
1087	op->stats.exp = op->value / 5;	1135	op->stats.exp = op->value / 5;
1088	op->nrof = op->inv->nrof;	1136	op->nrof = op->inv->nrof;
1089	break;	1137	break;
1090		1138
1091	case RUNE:	1139	case RUNE:
1092	trap_adjust (op, difficulty);	1140	trap_adjust (op, difficulty);
1093	break;	1141	break;
1094		1142
1095	case TRAP:	1143	case TRAP:
1096	trap_adjust (op, difficulty);	1144	trap_adjust (op, difficulty);
1097	break;	1145	break;
1098	} /* switch type */	1146	} /* switch type */
1099		1147
1100	if (flags & GT_STARTEQUIP)	1148	if (flags & GT_STARTEQUIP)
1101	{	1149	{
1102	if (op->nrof < 2 && op->type != CONTAINER	1150	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);	1151	SET_FLAG (op, FLAG_STARTEQUIP);
1105	else if (op->type != MONEY)	1152	else if (op->type != MONEY)
1106	op->value = 0;	1153	op->value = 0;
1107	}	1154	}
1108		1155
…		…
1120		1167
1121	/*	1168	/*
1122	* Allocate and return the pointer to an empty artifactlist structure.	1169	* Allocate and return the pointer to an empty artifactlist structure.
1123	*/	1170	*/
1124		1171
1125	static artifactlist *get_empty_artifactlist(void) {	1172	static artifactlist *
		1173	get_empty_artifactlist (void)
		1174	{
1126	artifactlist *tl = (artifactlist *) malloc(sizeof(artifactlist));	1175	artifactlist *tl = (artifactlist *) malloc (sizeof (artifactlist));
		1176
1127	if(tl==NULL)	1177	if (tl == NULL)
1128	fatal(OUT_OF_MEMORY);	1178	fatal (OUT_OF_MEMORY);
1129	tl->next=NULL;	1179	tl->next = NULL;
1130	tl->items=NULL;	1180	tl->items = NULL;
1131	tl->total_chance=0;	1181	tl->total_chance = 0;
1132	return tl;	1182	return tl;
1133	}	1183	}
1134		1184
1135	/*	1185	/*
1136	* Allocate and return the pointer to an empty artifact structure.	1186	* Allocate and return the pointer to an empty artifact structure.
1137	*/	1187	*/
1138		1188
1139	static artifact *get_empty_artifact(void) {	1189	static artifact *
		1190	get_empty_artifact (void)
		1191	{
1140	artifact *t = (artifact *) malloc(sizeof(artifact));	1192	artifact *t = (artifact *) malloc (sizeof (artifact));
		1193
1141	if(t==NULL)	1194	if (t == NULL)
1142	fatal(OUT_OF_MEMORY);	1195	fatal (OUT_OF_MEMORY);
1143	t->item=NULL;	1196	t->item = NULL;
1144	t->next=NULL;	1197	t->next = NULL;
1145	t->chance=0;	1198	t->chance = 0;
1146	t->difficulty=0;	1199	t->difficulty = 0;
1147	t->allowed = NULL;	1200	t->allowed = NULL;
1148	return t;	1201	return t;
1149	}	1202	}
1150		1203
1151	/*	1204	/*
1152	* Searches the artifact lists and returns one that has the same type	1205	* Searches the artifact lists and returns one that has the same type
1153	* of objects on it.	1206	* of objects on it.
1154	*/	1207	*/
1155		1208
		1209	artifactlist *
1156	artifactlist *find_artifactlist(int type) {	1210	find_artifactlist (int type)
		1211	{
1157	artifactlist *al;	1212	artifactlist *al;
1158		1213
1159	for (al=first_artifactlist; al!=NULL; al=al->next)	1214	for (al = first_artifactlist; al != NULL; al = al->next)
1160	if (al->type == type) return al;	1215	if (al->type == type)
		1216	return al;
1161	return NULL;	1217	return NULL;
1162	}	1218	}
1163		1219
1164	/*	1220	/*
1165	* For debugging purposes. Dumps all tables.	1221	* For debugging purposes. Dumps all tables.
1166	*/	1222	*/
1167		1223
		1224	void
1168	void dump_artifacts(void) {	1225	dump_artifacts (void)
		1226	{
1169	artifactlist *al;	1227	artifactlist *al;
1170	artifact *art;	1228	artifact *art;
1171	linked_char *next;	1229	linked_char *next;
1172		1230
1173	fprintf(logfile,"\n");	1231	fprintf (logfile, "\n");
1174	for (al=first_artifactlist; al!=NULL; al=al->next) {	1232	for (al = first_artifactlist; al != NULL; al = al->next)
		1233	{
1175	fprintf(logfile, "Artifact has type %d, total_chance=%d\n", al->type, al->total_chance);	1234	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) {	1235	for (art = al->items; art != NULL; art = art->next)
1177	fprintf(logfile,"Artifact %-30s Difficulty %3d Chance %5d\n",	1236	{
1178	art->item->name, art->difficulty, art->chance);	1237	fprintf (logfile, "Artifact %-30s Difficulty %3d Chance %5d\n", &art->item->name, art->difficulty, art->chance);
1179	if (art->allowed !=NULL) {	1238	if (art->allowed != NULL)
		1239	{
1180	fprintf(logfile,"\tAllowed combinations:");	1240	fprintf (logfile, "\tAllowed combinations:");
1181	for (next=art->allowed; next!=NULL; next=next->next)	1241	for (next = art->allowed; next != NULL; next = next->next)
1182	fprintf(logfile, "%s,", next->name);	1242	fprintf (logfile, "%s,", &next->name);
1183	fprintf(logfile,"\n");	1243	fprintf (logfile, "\n");
		1244	}
1184	}	1245	}
1185	}
1186	}	1246	}
1187	fprintf(logfile,"\n");	1247	fprintf (logfile, "\n");
1188	}	1248	}
1189		1249
1190	/*	1250	/*
1191	* For debugging purposes. Dumps all treasures recursively (see below).	1251	* For debugging purposes. Dumps all treasures recursively (see below).
1192	*/	1252	*/
		1253	void
1193	void dump_monster_treasure_rec (const char *name, treasure *t, int depth)	1254	dump_monster_treasure_rec (const char *name, treasure *t, int depth)
1194	{	1255	{
1195	treasurelist *tl;	1256	treasurelist *tl;
1196	int i;	1257	int i;
1197		1258
1198	if (depth > 100)	1259	if (depth > 100)
1199	return;	1260	return;
1200	while (t != NULL)	1261	while (t != NULL)
1201	{	1262	{
1202	if (t->name != NULL)	1263	if (t->name != NULL)
1203	{	1264	{
1204	for (i = 0; i < depth; i++)	1265	for (i = 0; i < depth; i++)
1205	fprintf (logfile, " ");	1266	fprintf (logfile, " ");
1206	fprintf (logfile, "{ (list: %s)\n", t->name);	1267	fprintf (logfile, "{ (list: %s)\n", &t->name);
1207	tl = find_treasurelist (t->name);	1268	tl = find_treasurelist (t->name);
1208	dump_monster_treasure_rec (name, tl->items, depth + 2);	1269	dump_monster_treasure_rec (name, tl->items, depth + 2);
1209	for (i = 0; i < depth; i++)	1270	for (i = 0; i < depth; i++)
1210	fprintf (logfile, " ");	1271	fprintf (logfile, " ");
1211	fprintf (logfile, "} (end of list: %s)\n", t->name);	1272	fprintf (logfile, "} (end of list: %s)\n", &t->name);
1212	}	1273	}
1213	else	1274	else
1214	{	1275	{
1215	for (i = 0; i < depth; i++)	1276	for (i = 0; i < depth; i++)
1216	fprintf (logfile, " ");	1277	fprintf (logfile, " ");
1217	if (t->item->clone.type == FLESH)	1278	if (t->item->clone.type == FLESH)
1218	fprintf (logfile, "%s's %s\n", name, t->item->clone.name);	1279	fprintf (logfile, "%s's %s\n", name, &t->item->clone.name);
1219	else	1280	else
1220	fprintf (logfile, "%s\n", t->item->clone.name);	1281	fprintf (logfile, "%s\n", &t->item->clone.name);
1221	}	1282	}
1222	if (t->next_yes != NULL)	1283	if (t->next_yes != NULL)
1223	{	1284	{
1224	for (i = 0; i < depth; i++)	1285	for (i = 0; i < depth; i++)
1225	fprintf (logfile, " ");	1286	fprintf (logfile, " ");
…		…
1240	/*	1301	/*
1241	* For debugging purposes. Dumps all treasures for a given monster.	1302	* For debugging purposes. Dumps all treasures for a given monster.
1242	* Created originally by Raphael Quinet for debugging the alchemy code.	1303	* Created originally by Raphael Quinet for debugging the alchemy code.
1243	*/	1304	*/
1244		1305
		1306	void
1245	void dump_monster_treasure (const char *name)	1307	dump_monster_treasure (const char *name)
1246	{	1308	{
1247	archetype *at;	1309	archetype *at;
1248	int found;	1310	int found;
1249		1311
1250	found = 0;	1312	found = 0;
1251	fprintf (logfile, "\n");	1313	fprintf (logfile, "\n");
1252	for (at = first_archetype; at != NULL; at = at->next)	1314	for (at = first_archetype; at != NULL; at = at->next)
1253	if (! strcasecmp (at->clone.name, name) && at->clone.title == NULL)	1315	if (!strcasecmp (at->clone.name, name) && at->clone.title == NULL)
1254	{	1316	{
1255	fprintf (logfile, "treasures for %s (arch: %s)\n", at->clone.name,	1317	fprintf (logfile, "treasures for %s (arch: %s)\n", &at->clone.name, &at->name);
1256	at->name);
1257	if (at->clone.randomitems != NULL)	1318	if (at->clone.randomitems != NULL)
1258	dump_monster_treasure_rec (at->clone.name,	1319	dump_monster_treasure_rec (at->clone.name, at->clone.randomitems->items, 1);
1259	at->clone.randomitems->items, 1);
1260	else	1320	else
1261	fprintf (logfile, "(nothing)\n");	1321	fprintf (logfile, "(nothing)\n");
1262	fprintf (logfile, "\n");	1322	fprintf (logfile, "\n");
1263	found++;	1323	found++;
1264	}	1324	}
…		…
1268		1328
1269	/*	1329	/*
1270	* Builds up the lists of artifacts from the file in the libdir.	1330	* Builds up the lists of artifacts from the file in the libdir.
1271	*/	1331	*/
1272		1332
		1333	void
1273	void init_artifacts(void) {	1334	init_artifacts (void)
		1335	{
1274	static int has_been_inited=0;	1336	static int has_been_inited = 0;
1275	char filename[MAX_BUF], buf[HUGE_BUF], *cp, *next;	1337	char filename[MAX_BUF], buf[HUGE_BUF], *cp, *next;
1276	artifact *art=NULL;	1338	artifact *art = NULL;
1277	linked_char *tmp;	1339	linked_char *tmp;
1278	int value, comp;	1340	int value;
1279	artifactlist *al;	1341	artifactlist *al;
1280		1342
1281	if (has_been_inited) return;	1343	if (has_been_inited)
		1344	return;
		1345	else
1282	else has_been_inited = 1;	1346	has_been_inited = 1;
1283		1347
1284	sprintf(filename, "%s/artifacts", settings.datadir);	1348	sprintf (filename, "%s/artifacts", settings.datadir);
1285	object_thawer thawer (filename);	1349	object_thawer thawer (filename);
1286		1350
1287	if (!thawer)	1351	if (!thawer)
1288	return;	1352	return;
1289		1353
1290	while (fgets(buf, HUGE_BUF, thawer)!=NULL) {	1354	while (fgets (buf, HUGE_BUF, thawer) != NULL)
1291	if (*buf=='#') continue;	1355	{
		1356	if (*buf == '#')
		1357	continue;
1292	if((cp=strchr(buf,'\n'))!=NULL)	1358	if ((cp = strchr (buf, '\n')) != NULL)
1293	*cp='\0';	1359	*cp = '\0';
1294	cp=buf;	1360	cp = buf;
1295	while(*cp==' ') /* Skip blanks */	1361	while (*cp == ' ') /* Skip blanks */
1296	cp++;	1362	cp++;
1297	if (*cp=='\0') continue;	1363	if (*cp == '\0')
1298		1364	continue;
		1365
1299	if (!strncmp(cp, "Allowed", 7)) {	1366	if (!strncmp (cp, "Allowed", 7))
		1367	{
1300	if (art==NULL) {	1368	if (art == NULL)
		1369	{
1301	art=get_empty_artifact();	1370	art = get_empty_artifact ();
1302	nrofartifacts++;	1371	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	}	1372	}
		1373	cp = strchr (cp, ' ') + 1;
		1374	if (!strcmp (cp, "all"))
		1375	continue;
		1376
		1377	do
		1378	{
		1379	nrofallowedstr++;
		1380	if ((next = strchr (cp, ',')) != NULL)
		1381	*(next++) = '\0';
		1382	tmp = new linked_char;
		1383
		1384	tmp->name = cp;
		1385	tmp->next = art->allowed;
		1386	art->allowed = tmp;
		1387	}
		1388	while ((cp = next) != NULL);
		1389	}
		1390	else if (sscanf (cp, "chance %d", &value))
		1391	art->chance = (uint16) value;
		1392	else if (sscanf (cp, "difficulty %d", &value))
		1393	art->difficulty = (uint8) value;
		1394	else if (!strncmp (cp, "Object", 6))
		1395	{
		1396	art->item = object::create ();
		1397
		1398	if (!load_object (thawer, art->item, 0))
		1399	LOG (llevError, "Init_Artifacts: Could not load object.\n");
		1400
		1401	art->item->name = strchr (cp, ' ') + 1;
		1402	al = find_artifactlist (art->item->type);
		1403	if (al == NULL)
		1404	{
		1405	al = get_empty_artifactlist ();
		1406	al->type = art->item->type;
		1407	al->next = first_artifactlist;
		1408	first_artifactlist = al;
		1409	}
1334	art->next = al->items;	1410	art->next = al->items;
1335	al->items = art;	1411	al->items = art;
1336	art = NULL;	1412	art = NULL;
1337	}	1413	}
1338	else	1414	else
1339	LOG(llevError,"Unknown input in artifact file: %s\n", buf);	1415	LOG (llevError, "Unknown input in artifact file: %s\n", buf);
1340	}	1416	}
1341		1417
1342	for (al=first_artifactlist; al!=NULL; al=al->next) {	1418	for (al = first_artifactlist; al != NULL; al = al->next)
		1419	{
1343	for (art=al->items; art!=NULL; art=art->next) {	1420	for (art = al->items; art != NULL; art = art->next)
		1421	{
1344	if (!art->chance)	1422	if (!art->chance)
1345	LOG(llevError,"Warning: artifact with no chance: %s\n", art->item->name);	1423	LOG (llevError, "Warning: artifact with no chance: %s\n", &art->item->name);
1346	else	1424	else
1347	al->total_chance += art->chance;	1425	al->total_chance += art->chance;
1348	}	1426	}
1349	#if 0	1427	#if 0
1350	LOG(llevDebug,"Artifact list type %d has %d total chance\n",	1428	LOG (llevDebug, "Artifact list type %d has %d total chance\n", al->type, al->total_chance);
1351	al->type, al->total_chance);
1352	#endif	1429	#endif
1353	}	1430	}
1354		1431
1355	LOG(llevDebug,"done.\n");	1432	LOG (llevDebug, "done.\n");
1356	}	1433	}
1357		1434
1358		1435
1359	/*	1436	/*
1360	* Used in artifact generation. The bonuses of the first object	1437	* Used in artifact generation. The bonuses of the first object
1361	* is modified by the bonuses of the second object.	1438	* is modified by the bonuses of the second object.
1362	*/	1439	*/
1363		1440
		1441	void
1364	void add_abilities(object *op, object *change) {	1442	add_abilities (object *op, object *change)
		1443	{
1365	int i,j, tmp;	1444	int i, tmp;
1366		1445
1367	if (change->face != blank_face) {	1446	if (change->face != blank_face)
		1447	{
1368	#ifdef TREASURE_VERBOSE	1448	#ifdef TREASURE_VERBOSE
1369	LOG(llevDebug, "FACE: %d\n", change->face->number);	1449	LOG (llevDebug, "FACE: %d\n", change->face->number);
1370	#endif	1450	#endif
1371	op->face = change->face;	1451	op->face = change->face;
1372	}	1452	}
		1453
1373	for (i = 0; i < NUM_STATS; i++)	1454	for (i = 0; i < NUM_STATS; i++)
1374	change_attr_value(&(op->stats), i, get_attr_value(&(change->stats), i));	1455	change_attr_value (&(op->stats), i, get_attr_value (&(change->stats), i));
1375		1456
1376	op->attacktype |= change->attacktype;	1457	op->attacktype |= change->attacktype;
1377	op->path_attuned |= change->path_attuned;	1458	op->path_attuned |= change->path_attuned;
1378	op->path_repelled |= change->path_repelled;	1459	op->path_repelled |= change->path_repelled;
1379	op->path_denied |= change->path_denied;	1460	op->path_denied |= change->path_denied;
1380	op->move_type |= change->move_type;	1461	op->move_type |= change->move_type;
1381	op->stats.luck += change->stats.luck;	1462	op->stats.luck += change->stats.luck;
1382		1463
1383	if (QUERY_FLAG(change,FLAG_CURSED)) SET_FLAG(op, FLAG_CURSED);	1464	if (QUERY_FLAG (change, FLAG_CURSED))
1384	if (QUERY_FLAG(change,FLAG_DAMNED)) SET_FLAG(op, FLAG_DAMNED);	1465	SET_FLAG (op, FLAG_CURSED);
		1466	if (QUERY_FLAG (change, FLAG_DAMNED))
		1467	SET_FLAG (op, FLAG_DAMNED);
1385	if ((QUERY_FLAG(change,FLAG_CURSED) || QUERY_FLAG(change,FLAG_DAMNED))	1468	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);	1469	set_abs_magic (op, -op->magic);
1388		1470
1389	if (QUERY_FLAG(change,FLAG_LIFESAVE)) SET_FLAG(op,FLAG_LIFESAVE);	1471	if (QUERY_FLAG (change, FLAG_LIFESAVE))
1390	if (QUERY_FLAG(change,FLAG_REFL_SPELL)) SET_FLAG(op,FLAG_REFL_SPELL);	1472	SET_FLAG (op, FLAG_LIFESAVE);
1391	if (QUERY_FLAG(change,FLAG_STEALTH)) SET_FLAG(op,FLAG_STEALTH);	1473	if (QUERY_FLAG (change, FLAG_REFL_SPELL))
1392	if (QUERY_FLAG(change,FLAG_XRAYS)) SET_FLAG(op,FLAG_XRAYS);	1474	SET_FLAG (op, FLAG_REFL_SPELL);
1393	if (QUERY_FLAG(change,FLAG_BLIND)) SET_FLAG(op,FLAG_BLIND);	1475	if (QUERY_FLAG (change, FLAG_STEALTH))
1394	if (QUERY_FLAG(change,FLAG_SEE_IN_DARK)) SET_FLAG(op,FLAG_SEE_IN_DARK);	1476	SET_FLAG (op, FLAG_STEALTH);
1395	if (QUERY_FLAG(change,FLAG_REFL_MISSILE)) SET_FLAG(op,FLAG_REFL_MISSILE);	1477	if (QUERY_FLAG (change, FLAG_XRAYS))
1396	if (QUERY_FLAG(change,FLAG_MAKE_INVIS)) SET_FLAG(op,FLAG_MAKE_INVIS);	1478	SET_FLAG (op, FLAG_XRAYS);
		1479	if (QUERY_FLAG (change, FLAG_BLIND))
		1480	SET_FLAG (op, FLAG_BLIND);
		1481	if (QUERY_FLAG (change, FLAG_SEE_IN_DARK))
		1482	SET_FLAG (op, FLAG_SEE_IN_DARK);
		1483	if (QUERY_FLAG (change, FLAG_REFL_MISSILE))
		1484	SET_FLAG (op, FLAG_REFL_MISSILE);
		1485	if (QUERY_FLAG (change, FLAG_MAKE_INVIS))
		1486	SET_FLAG (op, FLAG_MAKE_INVIS);
1397		1487
1398	if (QUERY_FLAG(change,FLAG_STAND_STILL)) {	1488	if (QUERY_FLAG (change, FLAG_STAND_STILL))
		1489	{
1399	CLEAR_FLAG(op,FLAG_ANIMATE);	1490	CLEAR_FLAG (op, FLAG_ANIMATE);
1400	/* so artifacts will join */	1491	/* so artifacts will join */
1401	if(!QUERY_FLAG(op,FLAG_ALIVE)) op->speed = 0.0;	1492	if (!QUERY_FLAG (op, FLAG_ALIVE))
		1493	op->speed = 0.0;
		1494
1402	update_ob_speed(op);	1495	update_ob_speed (op);
1403	}	1496	}
1404	if(change->nrof) op->nrof=RANDOM()%((int) change->nrof) + 1;	1497
		1498	if (change->nrof)
		1499	op->nrof = RANDOM () % ((int) change->nrof) + 1;
		1500
1405	op->stats.exp += change->stats.exp; /* Speed modifier */	1501	op->stats.exp += change->stats.exp; /* Speed modifier */
1406	op->stats.wc += change->stats.wc;	1502	op->stats.wc += change->stats.wc;
1407	op->stats.ac += change->stats.ac;	1503	op->stats.ac += change->stats.ac;
1408		1504
1409	if (change->other_arch) {	1505	if (change->other_arch)
		1506	{
1410	/* Basically, for horns & potions, the other_arch field is the spell	1507	/* 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	1508	* to cast. So convert that to into a spell and put it into
1412	* this object.	1509	* this object.
1413	*/	1510	*/
1414	if (op->type == HORN || op->type == POTION) {	1511	if (op->type == HORN || op->type == POTION)
		1512	{
1415	object *tmp_obj;	1513	object *tmp_obj;
		1514
1416	/* Remove any spells this object currently has in it */	1515	/* Remove any spells this object currently has in it */
1417	while (op->inv) {	1516	while (op->inv)
1418	tmp_obj = op->inv;	1517	op->inv->destroy ();
1419	remove_ob(tmp_obj);	1518
1420	free_object(tmp_obj);	1519	tmp_obj = arch_to_object (change->other_arch);
		1520	insert_ob_in_ob (tmp_obj, op);
		1521	}
		1522	/* No harm setting this for potions/horns */
		1523	op->other_arch = change->other_arch;
		1524	}
		1525
		1526	if (change->stats.hp < 0)
		1527	op->stats.hp = -change->stats.hp;
		1528	else
		1529	op->stats.hp += change->stats.hp;
		1530
		1531	if (change->stats.maxhp < 0)
		1532	op->stats.maxhp = -change->stats.maxhp;
		1533	else
		1534	op->stats.maxhp += change->stats.maxhp;
		1535
		1536	if (change->stats.sp < 0)
		1537	op->stats.sp = -change->stats.sp;
		1538	else
		1539	op->stats.sp += change->stats.sp;
		1540
		1541	if (change->stats.maxsp < 0)
		1542	op->stats.maxsp = -change->stats.maxsp;
		1543	else
		1544	op->stats.maxsp += change->stats.maxsp;
		1545
		1546	if (change->stats.food < 0)
		1547	op->stats.food = -(change->stats.food);
		1548	else
		1549	op->stats.food += change->stats.food;
		1550
		1551	if (change->level < 0)
		1552	op->level = -(change->level);
		1553	else
		1554	op->level += change->level;
		1555
		1556	if (change->gen_sp_armour < 0)
		1557	op->gen_sp_armour = -(change->gen_sp_armour);
		1558	else
		1559	op->gen_sp_armour = (op->gen_sp_armour * (change->gen_sp_armour)) / 100;
		1560
		1561	op->item_power = change->item_power;
		1562
		1563	for (i = 0; i < NROFATTACKS; i++)
		1564	if (change->resist[i])
		1565	op->resist[i] += change->resist[i];
		1566
		1567	if (change->stats.dam)
		1568	{
		1569	if (change->stats.dam < 0)
		1570	op->stats.dam = (-change->stats.dam);
		1571	else if (op->stats.dam)
		1572	{
		1573	tmp = (signed char) (((int) op->stats.dam * (int) change->stats.dam) / 10);
		1574	if (tmp == op->stats.dam)
		1575	{
		1576	if (change->stats.dam < 10)
		1577	op->stats.dam--;
		1578	else
		1579	op->stats.dam++;
1421	}	1580	}
1422	tmp_obj = arch_to_object(change->other_arch);	1581	else
1423	insert_ob_in_ob(tmp_obj, op);	1582	op->stats.dam = tmp;
1424	}	1583	}
1425	/* No harm setting this for potions/horns */	1584	}
1426	op->other_arch = change->other_arch;	1585
		1586	if (change->weight)
1427	}	1587	{
1428
1429	if (change->stats.hp < 0)	1588	if (change->weight < 0)
1430	op->stats.hp = -change->stats.hp;	1589	op->weight = (-change->weight);
1431	else	1590	else
1432	op->stats.hp += change->stats.hp;	1591	op->weight = (op->weight * (change->weight)) / 100;
		1592	}
		1593
		1594	if (change->last_sp)
		1595	{
1433	if (change->stats.maxhp < 0)	1596	if (change->last_sp < 0)
1434	op->stats.maxhp = -change->stats.maxhp;	1597	op->last_sp = (-change->last_sp);
1435	else	1598	else
1436	op->stats.maxhp += change->stats.maxhp;	1599	op->last_sp = (signed char) (((int) op->last_sp * (int) change->last_sp) / (int) 100);
1437	if (change->stats.sp < 0)	1600	}
1438	op->stats.sp = -change->stats.sp;
1439	else
1440	op->stats.sp += change->stats.sp;
1441	if (change->stats.maxsp < 0)
1442	op->stats.maxsp = -change->stats.maxsp;
1443	else
1444	op->stats.maxsp += change->stats.maxsp;
1445	if (change->stats.food < 0)
1446	op->stats.food = -(change->stats.food);
1447	else
1448	op->stats.food += change->stats.food;
1449	if (change->level < 0)
1450	op->level = -(change->level);
1451	else
1452	op->level += change->level;
1453		1601
		1602	if (change->gen_sp_armour)
		1603	{
1454	if (change->gen_sp_armour < 0)	1604	if (change->gen_sp_armour < 0)
1455	op->gen_sp_armour = -(change->gen_sp_armour);	1605	op->gen_sp_armour = (-change->gen_sp_armour);
1456	else
1457	op->gen_sp_armour = (op->gen_sp_armour * (change->gen_sp_armour)) / 100;
1458
1459	op->item_power = change->item_power;
1460
1461	for (i=0; i<NROFATTACKS; i++) {
1462	if (change->resist[i]) {
1463	op->resist[i] += change->resist[i];
1464	}
1465	}
1466	if (change->stats.dam) {
1467	if (change->stats.dam < 0)
1468	op->stats.dam = (-change->stats.dam);
1469	else if (op->stats.dam) {
1470	tmp = (signed char) (((int)op->stats.dam * (int)change->stats.dam)/10);
1471	if (tmp == op->stats.dam) {
1472	if (change->stats.dam < 10)
1473	op->stats.dam--;
1474	else
1475	op->stats.dam++;
1476	}
1477	else
1478	op->stats.dam = tmp;
1479	}
1480	}
1481	if (change->weight) {
1482	if (change->weight < 0)
1483	op->weight = (-change->weight);
1484	else	1606	else
1485	op->weight = (op->weight * (change->weight)) / 100;
1486	}
1487	if (change->last_sp) {
1488	if (change->last_sp < 0)
1489	op->last_sp = (-change->last_sp);
1490	else
1491	op->last_sp = (signed char) (((int)op->last_sp * (int)change->last_sp) / (int) 100);
1492	}
1493	if (change->gen_sp_armour) {
1494	if (change->gen_sp_armour < 0)
1495	op->gen_sp_armour = (-change->gen_sp_armour);
1496	else
1497	op->gen_sp_armour = (signed char) (((int)op->gen_sp_armour * ((int)change->gen_sp_armour))	1607	op->gen_sp_armour = (signed char) (((int) op->gen_sp_armour * ((int) change->gen_sp_armour)) / (int) 100);
1498	/ (int)100);
1499	}	1608	}
		1609
1500	op->value *= change->value;	1610	op->value *= change->value;
1501		1611
		1612	if (change->material)
1502	if(change->material) op->material = change->material;	1613	op->material = change->material;
1503		1614
1504	if (change->materialname) {	1615	if (change->materialname)
1505	if (op->materialname)
1506	free_string(op->materialname);
1507	op->materialname = add_refcount(change->materialname);	1616	op->materialname = change->materialname;
1508	}
1509		1617
1510	if (change->slaying) {	1618	if (change->slaying)
1511	if (op->slaying)
1512	free_string(op->slaying);
1513	op->slaying = add_refcount(change->slaying);	1619	op->slaying = change->slaying;
1514	}	1620
1515	if (change->race) {	1621	if (change->race)
1516	if (op->race)
1517	free_string(op->race);
1518	op->race = add_refcount(change->race);	1622	op->race = change->race;
1519	}	1623
1520	if (change->msg) {	1624	if (change->msg)
1521	if (op->msg)	1625	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	}	1626	}
1579		1627
		1628	static int
1580	static int legal_artifact_combination(object *op, artifact *art) {	1629	legal_artifact_combination (object *op, artifact * art)
		1630	{
1581	int neg, success = 0;	1631	int neg, success = 0;
1582	linked_char *tmp;	1632	linked_char *tmp;
1583	const char *name;	1633	const char *name;
1584		1634
1585	if (art->allowed == (linked_char *) NULL)	1635	if (art->allowed == (linked_char *) NULL)
1586	return 1; /* Ie, "all" */	1636	return 1; /* Ie, "all" */
1587	for (tmp = art->allowed; tmp; tmp = tmp->next) {	1637	for (tmp = art->allowed; tmp; tmp = tmp->next)
		1638	{
1588	#ifdef TREASURE_VERBOSE	1639	#ifdef TREASURE_VERBOSE
1589	LOG(llevDebug, "legal_art: %s\n", tmp->name);	1640	LOG (llevDebug, "legal_art: %s\n", tmp->name);
1590	#endif	1641	#endif
1591	if (*tmp->name == '!')	1642	if (*tmp->name == '!')
1592	name = tmp->name + 1, neg = 1;	1643	name = tmp->name + 1, neg = 1;
1593	else	1644	else
1594	name = tmp->name, neg = 0;	1645	name = tmp->name, neg = 0;
1595		1646
1596	/* If we match name, then return the opposite of 'neg' */	1647	/* If we match name, then return the opposite of 'neg' */
1597	if (!strcmp(name,op->name) || (op->arch && !strcmp(name,op->arch->name)))	1648	if (!strcmp (name, op->name) || (op->arch && !strcmp (name, op->arch->name)))
1598	return !neg;	1649	return !neg;
1599		1650
1600	/* Set success as true, since if the match was an inverse, it means	1651	/* Set success as true, since if the match was an inverse, it means
1601	* everything is allowed except what we match	1652	* everything is allowed except what we match
1602	*/	1653	*/
1603	else if (neg)	1654	else if (neg)
1604	success = 1;	1655	success = 1;
1605	}	1656	}
1606	return success;	1657	return success;
1607	}	1658	}
1608		1659
1609	/*	1660	/*
1610	* Fixes the given object, giving it the abilities and titles	1661	* Fixes the given object, giving it the abilities and titles
1611	* it should have due to the second artifact-template.	1662	* it should have due to the second artifact-template.
1612	*/	1663	*/
1613		1664
		1665	void
1614	void give_artifact_abilities(object *op, object *artifct) {	1666	give_artifact_abilities (object *op, object *artifct)
		1667	{
1615	char new_name[MAX_BUF];	1668	char new_name[MAX_BUF];
1616		1669
1617	sprintf(new_name, "of %s", artifct->name);	1670	sprintf (new_name, "of %s", &artifct->name);
1618	if (op->title)
1619	free_string(op->title);
1620	op->title = add_string(new_name);	1671	op->title = new_name;
1621	add_abilities(op, artifct); /* Give out the bonuses */	1672	add_abilities (op, artifct); /* Give out the bonuses */
1622		1673
1623	#if 0 /* Bit verbose, but keep it here until next time I need it... */	1674	#if 0 /* Bit verbose, but keep it here until next time I need it... */
1624	{	1675	{
1625	char identified = QUERY_FLAG(op, FLAG_IDENTIFIED);	1676	char identified = QUERY_FLAG (op, FLAG_IDENTIFIED);
		1677
1626	SET_FLAG(op, FLAG_IDENTIFIED);	1678	SET_FLAG (op, FLAG_IDENTIFIED);
1627	LOG(llevDebug, "Generated artifact %s %s [%s]\n",	1679	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)	1680	if (!identified)
1630	CLEAR_FLAG(op, FLAG_IDENTIFIED);	1681	CLEAR_FLAG (op, FLAG_IDENTIFIED);
1631	}	1682	}
1632	#endif	1683	#endif
1633	return;	1684	return;
1634	}	1685	}
1635		1686
…		…
1642	*/	1693	*/
1643		1694
1644	/* Give 1 re-roll attempt per artifact */	1695	/* Give 1 re-roll attempt per artifact */
1645	#define ARTIFACT_TRIES 2	1696	#define ARTIFACT_TRIES 2
1646		1697
		1698	void
1647	void generate_artifact(object *op, int difficulty) {	1699	generate_artifact (object *op, int difficulty)
		1700	{
1648	artifactlist *al;	1701	artifactlist *al;
1649	artifact *art;	1702	artifact *art;
1650	int i;	1703	int i;
1651		1704
1652	al = find_artifactlist(op->type);	1705	al = find_artifactlist (op->type);
1653		1706
1654	if (al==NULL) {	1707	if (al == NULL)
		1708	{
1655	#if 0 /* This is too verbose, usually */	1709	#if 0 /* This is too verbose, usually */
1656	LOG(llevDebug, "Couldn't change %s into artifact - no table.\n", op->name);	1710	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	1711	#endif
1674	return;	1712	return;
1675	}	1713	}
		1714
		1715	for (i = 0; i < ARTIFACT_TRIES; i++)
		1716	{
		1717	int roll = RANDOM () % al->total_chance;
		1718
		1719	for (art = al->items; art != NULL; art = art->next)
		1720	{
		1721	roll -= art->chance;
		1722	if (roll < 0)
		1723	break;
		1724	}
		1725
		1726	if (art == NULL || roll >= 0)
		1727	{
		1728	#if 1
		1729	LOG (llevError, "Got null entry and non zero roll in generate_artifact, type %d\n", op->type);
		1730	#endif
		1731	return;
		1732	}
1676	if (!strcmp(art->item->name,"NONE"))	1733	if (!strcmp (art->item->name, "NONE"))
1677	return;	1734	return;
1678	if (FABS(op->magic) < art->item->magic)	1735	if (FABS (op->magic) < art->item->magic)
1679	continue; /* Not magic enough to be this item */	1736	continue; /* Not magic enough to be this item */
1680		1737
1681	/* Map difficulty not high enough */	1738	/* Map difficulty not high enough */
1682	if (difficulty<art->difficulty)	1739	if (difficulty < art->difficulty)
1683	continue;	1740	continue;
1684		1741
1685	if (!legal_artifact_combination(op, art)) {	1742	if (!legal_artifact_combination (op, art))
		1743	{
1686	#ifdef TREASURE_VERBOSE	1744	#ifdef TREASURE_VERBOSE
1687	LOG(llevDebug, "%s of %s was not a legal combination.\n",	1745	LOG (llevDebug, "%s of %s was not a legal combination.\n", op->name, art->item->name);
1688	op->name, art->item->name);
1689	#endif	1746	#endif
1690	continue;	1747	continue;
1691	}	1748	}
1692	give_artifact_abilities(op, art->item);	1749	give_artifact_abilities (op, art->item);
1693	return;	1750	return;
1694	}	1751	}
1695	}	1752	}
1696		1753
1697	/* fix_flesh_item() - objects of type FLESH are similar to type	1754	/* fix_flesh_item() - objects of type FLESH are similar to type
1698	* FOOD, except they inherit properties (name, food value, etc).	1755	* FOOD, except they inherit properties (name, food value, etc).
1699	* based on the original owner (or 'donor' if you like). -b.t.	1756	* based on the original owner (or 'donor' if you like). -b.t.
1700	*/	1757	*/
1701		1758
		1759	void
1702	void fix_flesh_item(object *item, object *donor) {	1760	fix_flesh_item (object *item, object *donor)
		1761	{
1703	char tmpbuf[MAX_BUF];	1762	char tmpbuf[MAX_BUF];
1704	int i;	1763	int i;
1705		1764
1706	if(item->type==FLESH && donor) {	1765	if (item->type == FLESH && donor)
		1766	{
1707	/* change the name */	1767	/* change the name */
1708	sprintf(tmpbuf,"%s's %s",donor->name,item->name);	1768	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name);
1709	FREE_AND_COPY(item->name, tmpbuf);	1769	item->name = tmpbuf;
1710	sprintf(tmpbuf,"%s's %s",donor->name,item->name_pl);	1770	sprintf (tmpbuf, "%s's %s", &donor->name, &item->name_pl);
1711	FREE_AND_COPY(item->name_pl, tmpbuf);	1771	item->name_pl = tmpbuf;
1712		1772
1713	/* weight is FLESH weight/100 * donor */	1773	/* weight is FLESH weight/100 * donor */
1714	if((item->weight = (signed long) (((double)item->weight/(double)100.0) * (double)donor->weight))==0)	1774	if ((item->weight = (signed long) (((double) item->weight / (double) 100.0) * (double) donor->weight)) == 0)
1715	item->weight=1;	1775	item->weight = 1;
1716		1776
1717	/* value is multiplied by level of donor */	1777	/* value is multiplied by level of donor */
1718	item->value *= isqrt(donor->level*2);	1778	item->value *= isqrt (donor->level * 2);
1719		1779
1720	/* food value */	1780	/* food value */
1721	item->stats.food += (donor->stats.hp/100) + donor->stats.Con;	1781	item->stats.food += (donor->stats.hp / 100) + donor->stats.Con;
1722		1782
1723	/* flesh items inherit some abilities of donor, but not	1783	/* flesh items inherit some abilities of donor, but not
1724	* full effect.	1784	* full effect.
1725	*/	1785	*/
1726	for (i=0; i<NROFATTACKS; i++)	1786	for (i = 0; i < NROFATTACKS; i++)
1727	item->resist[i] = donor->resist[i]/2;	1787	item->resist[i] = donor->resist[i] / 2;
1728		1788
1729	/* item inherits donor's level (important for quezals) */	1789	/* item inherits donor's level (important for quezals) */
1730	item->level = donor->level;	1790	item->level = donor->level;
1731		1791
1732	/* if donor has some attacktypes, the flesh is poisonous */	1792	/* if donor has some attacktypes, the flesh is poisonous */
1733	if(donor->attacktype&AT_POISON)	1793	if (donor->attacktype & AT_POISON)
1734	item->type=POISON;	1794	item->type = POISON;
1735	if(donor->attacktype&AT_ACID) item->stats.hp = -1*item->stats.food;	1795	if (donor->attacktype & AT_ACID)
		1796	item->stats.hp = -1 * item->stats.food;
1736	SET_FLAG(item,FLAG_NO_STEAL);	1797	SET_FLAG (item, FLAG_NO_STEAL);
1737	}	1798	}
1738	}	1799	}
1739		1800
1740	/* special_potion() - so that old potion code is still done right. */	1801	/* special_potion() - so that old potion code is still done right. */
1741		1802
		1803	int
1742	int special_potion (object *op) {	1804	special_potion (object *op)
		1805	{
1743		1806
1744	int i;	1807	int i;
1745		1808
1746	if(op->attacktype) return 1;	1809	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;	1810	return 1;
1755	}
1756		1811
		1812	if (op->stats.Str || op->stats.Dex || op->stats.Con || op->stats.Pow || op->stats.Wis || op->stats.Int || op->stats.Cha)
		1813	return 1;
		1814
		1815	for (i = 0; i < NROFATTACKS; i++)
		1816	if (op->resist[i])
		1817	return 1;
		1818
		1819	return 0;
		1820	}
		1821
		1822	void
1757	void free_treasurestruct(treasure *t)	1823	free_treasurestruct (treasure *t)
1758	{	1824	{
		1825	if (t->next)
1759	if (t->next) free_treasurestruct(t->next);	1826	free_treasurestruct (t->next);
		1827	if (t->next_yes)
1760	if (t->next_yes) free_treasurestruct(t->next_yes);	1828	free_treasurestruct (t->next_yes);
		1829	if (t->next_no)
1761	if (t->next_no) free_treasurestruct(t->next_no);	1830	free_treasurestruct (t->next_no);
1762	free(t);
1763	}
1764		1831
		1832	delete t;
		1833	}
		1834
		1835	void
1765	void free_charlinks(linked_char *lc)	1836	free_charlinks (linked_char *lc)
1766	{	1837	{
		1838	if (lc->next)
1767	if (lc->next) free_charlinks(lc->next);	1839	free_charlinks (lc->next);
1768	free(lc);
1769	}
1770		1840
		1841	delete lc;
		1842	}
		1843
		1844	void
1771	void free_artifact(artifact *at)	1845	free_artifact (artifact * at)
1772	{	1846	{
1773		1847	if (at->next)
1774	if (at->next) free_artifact(at->next);	1848	free_artifact (at->next);
		1849
		1850	if (at->allowed)
1775	if (at->allowed) free_charlinks(at->allowed);	1851	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		1852
		1853	at->item->destroy (1);
		1854
		1855	delete at;
		1856	}
		1857
		1858	void
1786	void free_artifactlist(artifactlist *al)	1859	free_artifactlist (artifactlist * al)
1787	{	1860	{
1788	artifactlist *nextal;	1861	artifactlist *nextal;
		1862
1789	for (al=first_artifactlist; al!=NULL; al=nextal) {	1863	for (al = first_artifactlist; al; al = nextal)
		1864	{
1790	nextal=al->next;	1865	nextal = al->next;
		1866
1791	if (al->items) {	1867	if (al->items)
1792	free_artifact(al->items);	1868	free_artifact (al->items);
1793	}	1869
1794	free(al);	1870	free (al);
1795	}	1871	}
1796	}	1872	}
1797		1873
		1874	void
1798	void free_all_treasures(void) {	1875	free_all_treasures (void)
		1876	{
1799	treasurelist *tl, *next;	1877	treasurelist *tl, *next;
1800		1878
1801		1879
1802	for (tl=first_treasurelist; tl!=NULL; tl=next) {	1880	for (tl = first_treasurelist; tl != NULL; tl = next)
		1881	{
1803	next=tl->next;	1882	next = tl->next;
1804	if (tl->name) free_string(tl->name);	1883	if (tl->items)
1805	if (tl->items) free_treasurestruct(tl->items);	1884	free_treasurestruct (tl->items);
1806	free(tl);	1885	delete tl;
1807	}	1886	}
1808	free_artifactlist(first_artifactlist);	1887	free_artifactlist (first_artifactlist);
1809	}	1888	}

Diff Legend

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