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.4 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.29 by root, Tue Dec 26 20:04:09 2006 UTC

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

Diff Legend

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