[ViewVC] Diff of: cvs/deliantra/server/random

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.19 by root, Wed Jan 17 12:36:31 2007 UTC

…		…
1	/*	1	/*
2	* static char *rcsid_treasure_c =	2	<<<<<<< treasure.C
3	* "$Id: treasure.C,v 1.2 2006/08/29 08:01:36 root Exp $";	3	* CrossFire, A Multiplayer game
		4	*
		5	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
		6	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team
		7	* Copyright (C) 1992 Frank Tore Johansen
		8	*
		9	* This program is free software; you can redistribute it and/or modify
		10	* it under the terms of the GNU General Public License as published by
		11	* the Free Software Foundation; either version 2 of the License, or
		12	* (at your option) any later version.
		13	*
		14	* This program is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	* GNU General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU General Public License
		20	* along with this program; if not, write to the Free Software
		21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		22	*
		23	* The authors can be reached via e-mail at <crossfire@schmorp.de>
4	*/	24	*/
5		25	=======
6	/*
7	CrossFire, A Multiplayer game for X-windows	26	* CrossFire, A Multiplayer game for X-windows
8		27	*
		28	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	29	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	30	* Copyright (C) 1992 Frank Tore Johansen
11		31	*
12	This program is free software; you can redistribute it and/or modify	32	* This program is free software; you can redistribute it and/or modify
13	it under the terms of the GNU General Public License as published by	33	* it under the terms of the GNU General Public License as published by
14	the Free Software Foundation; either version 2 of the License, or	34	* the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.	35	* (at your option) any later version.
16		36	*
17	This program is distributed in the hope that it will be useful,	37	* This program is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of	38	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	39	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.	40	* GNU General Public License for more details.
21		41	*
22	You should have received a copy of the GNU General Public License	42	* You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software	43	* along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	44	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		45	*
26	The authors can be reached via e-mail at crossfire-devel@real-time.com	46	* The authors can be reached via e-mail at <crossfire@schmorp.de>
27	*/	47	*/
		48	>>>>>>> 1.18
28		49
29	/* placing treasure in maps, where appropriate. */	50	/* placing treasure in maps, where appropriate. */
30
31
32		51
33	#include <global.h>	52	#include <global.h>
34	#include <random_map.h>	53	#include <random_map.h>
35	#include <rproto.h>	54	#include <rproto.h>
36		55
37	/* some defines for various options which can be set. */	56	/* some defines for various options which can be set. */
38		57
39	#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */	58	#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */
40	#define HIDDEN 2 /* doors to treasure are hidden. */	59	#define HIDDEN 2 /* doors to treasure are hidden. */
41	#define KEYREQUIRED 4 /* chest has a key, which is placed randomly in the map. */	60	#define KEYREQUIRED 4 /* chest has a key, which is placed randomly in the map. */
42	#define DOORED 8 /* treasure has doors around it. */	61	#define DOORED 8 /* treasure has doors around it. */
43	#define TRAPPED 16 /* trap dropped in same location as chest. */	62	#define TRAPPED 16 /* trap dropped in same location as chest. */
44	#define SPARSE 32 /* 1/2 as much treasure as default */	63	#define SPARSE 32 /* 1/2 as much treasure as default */
45	#define RICH 64 /* 2x as much treasure as default */	64	#define RICH 64 /* 2x as much treasure as default */
46	#define FILLED 128 /* Fill/tile the entire map with treasure */	65	#define FILLED 128 /* Fill/tile the entire map with treasure */
47	#define LAST_OPTION 64 /* set this to the last real option, for random */	66	#define LAST_OPTION 64 /* set this to the last real option, for random */
48		67
49	#define NO_PASS_DOORS 0	68	#define NO_PASS_DOORS 0
50	#define PASS_DOORS 1	69	#define PASS_DOORS 1
51		70
52		71
53	/* returns true if square x,y has P_NO_PASS set, which is true for walls	72	/* returns true if square x,y has P_NO_PASS set, which is true for walls
54	* and doors but not monsters.	73	* and doors but not monsters.
55	* This function is not map tile aware.	74	* This function is not map tile aware.
56	*/	75	*/
57		76	int
58	int wall_blocked(mapstruct *m, int x, int y) {	77	wall_blocked (maptile *m, int x, int y)
59	int r;	78	{
60
61	if(OUT_OF_REAL_MAP(m,x,y))	79	if (OUT_OF_REAL_MAP (m, x, y))
62	return 1;	80	return 1;
		81
63	r = GET_MAP_MOVE_BLOCK(m,x,y) & ~MOVE_BLOCK_DEFAULT;	82	int r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;
64	return r;	83	return r;
65	}	84	}
66		85
67	/* place treasures in the map, given the	86	/* place treasures in the map, given the
68	map, (required)	87	map, (required)
69	layout, (required)	88	layout, (required)
70	treasure style (may be empty or NULL, or "none" to cause no treasure.)	89	treasure style (may be empty or NULL, or "none" to cause no treasure.)
71	treasureoptions (may be 0 for random choices or positive)	90	treasureoptions (may be 0 for random choices or positive)
72	*/	91	*/
73		92	void
74	void place_treasure(mapstruct map,char layout, char treasure_style,int treasureoptions,RMParms *RP) {	93	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)
		94	{
75	char styledirname[256];	95	char styledirname[1024];
76	char stylefilepath[256];	96	char stylefilepath[1024];
77	mapstruct *style_map=0;	97	maptile *style_map = 0;
78	int num_treasures;	98	int num_treasures;
79		99
80	/* bail out if treasure isn't wanted. */	100	/* bail out if treasure isn't wanted. */
81	if(treasure_style) if(!strcmp(treasure_style,"none")) return;	101	if (treasure_style)
		102	if (!strcmp (treasure_style, "none"))
		103	return;
		104	if (treasureoptions <= 0)
82	if(treasureoptions<=0) treasureoptions=RANDOM() % (2*LAST_OPTION);	105	treasureoptions = RANDOM () % (2 * LAST_OPTION);
83		106
84	/* filter out the mutually exclusive options */	107	/* filter out the mutually exclusive options */
85	if((treasureoptions & RICH) &&(treasureoptions &SPARSE)) {	108	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
86	if(RANDOM()%2) treasureoptions -=1;	109	{
		110	if (RANDOM () % 2)
		111	treasureoptions -= 1;
		112	else
87	else treasureoptions-=2;}	113	treasureoptions -= 2;
		114	}
88		115
89	/* pick the number of treasures */	116	/* pick the number of treasures */
90	if(treasureoptions & SPARSE)	117	if (treasureoptions & SPARSE)
91	num_treasures = BC_RANDOM(RP->total_map_hp/600+RP->difficulty/2+1);	118	num_treasures = BC_RANDOM (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);
92	else if(treasureoptions & RICH)	119	else if (treasureoptions & RICH)
93	num_treasures = BC_RANDOM(RP->total_map_hp/150+2*RP->difficulty+1);	120	num_treasures = BC_RANDOM (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);
		121	else
94	else num_treasures = BC_RANDOM(RP->total_map_hp/300+RP->difficulty+1);	122	num_treasures = BC_RANDOM (RP->total_map_hp / 300 + RP->difficulty + 1);
95		123
96	if(num_treasures <= 0 ) return;	124	if (num_treasures <= 0)
		125	return;
97		126
98	/* get the style map */	127	/* get the style map */
99	sprintf(styledirname,"%s","/styles/treasurestyles");	128	sprintf (styledirname, "%s", "/styles/treasurestyles");
100	sprintf(stylefilepath,"%s/%s",styledirname,treasure_style);	129	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
101	style_map = find_style(styledirname,treasure_style,-1);	130	style_map = find_style (styledirname, treasure_style, -1);
102		131
103	/* all the treasure at one spot in the map. */	132	/* all the treasure at one spot in the map. */
104	if(treasureoptions & CONCENTRATED) {	133	if (treasureoptions & CONCENTRATED)
		134	{
105		135
106	/* map_layout_style global, and is previously set */	136	/* map_layout_style global, and is previously set */
107	switch(RP->map_layout_style) {	137	switch (RP->map_layout_style)
108	case ONION_LAYOUT:
109	case SPIRAL_LAYOUT:
110	case SQUARE_SPIRAL_LAYOUT:
111	{	138	{
		139	case LAYOUT_ONION:
		140	case LAYOUT_SPIRAL:
		141	case LAYOUT_SQUARE_SPIRAL:
		142	{
112	int i,j;	143	int i, j;
		144
113	/* search the onion for C's or '>', and put treasure there. */	145	/* search the onion for C's or '>', and put treasure there. */
114	for(i=0;i<RP->Xsize;i++) {	146	for (i = 0; i < RP->Xsize; i++)
		147	{
115	for(j=0;j<RP->Ysize;j++) {	148	for (j = 0; j < RP->Ysize; j++)
		149	{
116	if(layout[i][j]=='C' \|\| layout[i][j]=='>') {	150	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')
		151	{
117	int tdiv = RP->symmetry_used;	152	int tdiv = RP->symmetry_used;
		153	object **doorlist;
		154	object *chest;
		155
		156	if (tdiv == 3)
		157	tdiv = 2; /* this symmetry uses a divisor of 2 */
		158	/* don't put a chest on an exit. */
		159	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
		160	if (!chest)
		161	continue; /* if no chest was placed NEXT */
		162	if (treasureoptions & (DOORED \| HIDDEN))
		163	{
		164	doorlist = find_doors_in_room (map, i, j, RP);
		165	lock_and_hide_doors (doorlist, map, treasureoptions, RP);
		166	free (doorlist);
		167	}
		168	}
		169	}
		170	}
		171	break;
		172	}
		173	default:
		174	{
		175	int i, j, tries;
		176	object *chest;
118	object **doorlist;	177	object **doorlist;
119	object *chest;	178
120	if(tdiv==3) tdiv = 2; /* this symmetry uses a divisor of 2*/	179	i = j = -1;
121	/* don't put a chest on an exit. */	180	tries = 0;
		181	while (i == -1 && tries < 100)
		182	{
		183	i = RANDOM () % (RP->Xsize - 2) + 1;
		184	j = RANDOM () % (RP->Ysize - 2) + 1;
		185	find_enclosed_spot (map, &i, &j, RP);
		186	if (wall_blocked (map, i, j))
		187	i = -1;
		188	tries++;
		189	}
122	chest=place_chest(treasureoptions,i,j,map,style_map,num_treasures/tdiv,RP);	190	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
123	if(!chest) continue; /* if no chest was placed NEXT */	191	if (!chest)
		192	return;
		193	i = chest->x;
		194	j = chest->y;
124	if(treasureoptions & (DOORED\|HIDDEN)) {	195	if (treasureoptions & (DOORED \| HIDDEN))
125	doorlist=find_doors_in_room(map,i,j,RP);	196	{
		197	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
126	lock_and_hide_doors(doorlist,map,treasureoptions,RP);	198	lock_and_hide_doors (doorlist, map, treasureoptions, RP);
127	free(doorlist);	199	free (doorlist);
128	}	200	}
129	}	201	}
130	}	202	}
		203	}
		204	else
		205	{ /* DIFFUSE treasure layout */
		206	int ti, i, j;
		207
		208	for (ti = 0; ti < num_treasures; ti++)
131	}	209	{
132	break;
133	}
134	default:
135	{
136	int i,j,tries;
137	object *chest;
138	object **doorlist;
139	i=j=-1;tries=0;
140	while(i==-1&&tries<100) {
141	i = RANDOM()%(RP->Xsize-2)+1;	210	i = RANDOM () % (RP->Xsize - 2) + 1;
142	j = RANDOM()%(RP->Ysize-2)+1;	211	j = RANDOM () % (RP->Ysize - 2) + 1;
143	find_enclosed_spot(map,&i,&j,RP);
144	if(wall_blocked(map,i,j)) i=-1;
145	tries++;
146	}
147	chest=place_chest(treasureoptions,i,j,map,style_map,num_treasures,RP);
148	if(!chest) return;
149	i = chest->x; j = chest->y;
150	if(treasureoptions & (DOORED\|HIDDEN)) {
151	doorlist=surround_by_doors(map,layout,i,j,treasureoptions);
152	lock_and_hide_doors(doorlist,map,treasureoptions,RP);
153	free(doorlist);
154	}
155	}
156	}
157	}
158	else { /* DIFFUSE treasure layout */
159	int ti,i,j;
160	for(ti=0;ti<num_treasures;ti++) {
161	i = RANDOM()%(RP->Xsize-2)+1;
162	j = RANDOM()%(RP->Ysize-2)+1;
163	place_chest(treasureoptions,i,j,map,style_map,1,RP);	212	place_chest (treasureoptions, i, j, map, style_map, 1, RP);
164	}	213	}
165	}	214	}
166	}	215	}
167
168
169		216
170	/* put a chest into the map, near x and y, with the treasure style	217	/* put a chest into the map, near x and y, with the treasure style
171	determined (may be null, or may be a treasure list from lib/treasures,	218	determined (may be null, or may be a treasure list from lib/treasures,
172	if the global variable "treasurestyle" is set to that treasure list's name */	219	if the global variable "treasurestyle" is set to that treasure list's name */
173		220
		221	object *
174	object * place_chest(int treasureoptions,int x, int y,mapstruct map, mapstruct style_map,int n_treasures,RMParms *RP) {	222	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
		223	{
175	object *the_chest;	224	object *the_chest;
176	int i,xl,yl;	225	int i, xl, yl;
177		226
178	the_chest = get_archetype("chest"); /* was "chest_2" */	227	the_chest = get_archetype ("chest"); /* was "chest_2" */
179		228
180	/* first, find a place to put the chest. */	229	/* first, find a place to put the chest. */
181	i = find_first_free_spot(the_chest,map,x,y);	230	i = find_first_free_spot (the_chest, map, x, y);
182	if (i == -1) {	231	if (i == -1)
183	free_object(the_chest);	232	{
		233	the_chest->destroy ();
184	return NULL;	234	return NULL;
185	}	235	}
186	xl = x + freearr_x[i]; yl = y + freearr_y[i];	236
		237	xl = x + freearr_x[i];
		238	yl = y + freearr_y[i];
187		239
188	/* if the placement is blocked, return a fail. */	240	/* if the placement is blocked, return a fail. */
189	if(wall_blocked(map,xl,yl)) return 0;	241	if (wall_blocked (map, xl, yl))
190		242	return 0;
191		243
192	/* put the treasures in the chest. */	244	/* put the treasures in the chest. */
193	/* if(style_map) { */	245	/* if(style_map) { */
194	#if 0 /* don't use treasure style maps for now! */	246	#if 0 /* don't use treasure style maps for now! */
195	int ti;	247	int ti;
		248
196	/* if treasurestyle lists a treasure list, use it. */	249	/* if treasurestyle lists a treasure list, use it. */
197	treasurelist *tlist=find_treasurelist(RP->treasurestyle);	250	treasurelist *tlist = find_treasurelist (RP->treasurestyle);
		251
198	if(tlist!=NULL)	252	if (tlist != NULL)
199	for(ti=0;ti<n_treasures;ti++) { /* use the treasure list */	253	for (ti = 0; ti < n_treasures; ti++)
		254	{ /* use the treasure list */
200	object *new_treasure=pick_random_object(style_map);	255	object *new_treasure = pick_random_object (style_map);
		256
201	insert_ob_in_ob(arch_to_object(new_treasure->arch),the_chest);	257	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
202	}	258	}
203	else { /* use the style map */	259	else
		260	{ /* use the style map */
		261	the_chest->randomitems = tlist;
		262	the_chest->stats.hp = n_treasures;
		263	}
		264	#endif
		265	{ /* neither style_map no treasure list given */
		266	treasurelist *tlist = find_treasurelist ("chest");
		267
204	the_chest->randomitems=tlist;	268	the_chest->randomitems = tlist;
205	the_chest->stats.hp = n_treasures;	269	the_chest->stats.hp = n_treasures;
206	}	270	}
207	#endif
208	else { /* neither style_map no treasure list given */
209	treasurelist *tlist=find_treasurelist("chest");
210	the_chest->randomitems=tlist;
211	the_chest->stats.hp = n_treasures;
212	}
213		271
214	/* stick a trap in the chest if required */	272	/* stick a trap in the chest if required */
215	if(treasureoptions & TRAPPED) {	273	if (treasureoptions & TRAPPED)
		274	{
216	mapstruct *trap_map=find_style("/styles/trapstyles","traps",-1);	275	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
217	object *the_trap;	276	object *the_trap;
		277
218	if(trap_map) {	278	if (trap_map)
		279	{
219	the_trap= pick_random_object(trap_map);	280	the_trap = pick_random_object (trap_map);
220	the_trap->stats.Cha = 10+RP->difficulty;	281	the_trap->stats.Cha = 10 + RP->difficulty;
221	the_trap->level = BC_RANDOM((3*RP->difficulty)/2);	282	the_trap->level = BC_RANDOM ((3 * RP->difficulty) / 2);
222	if(the_trap) {	283	if (the_trap)
		284	{
223	object *new_trap;	285	object *new_trap;
		286
224	new_trap = arch_to_object(the_trap->arch);	287	new_trap = arch_to_object (the_trap->arch);
225	copy_object(new_trap,the_trap);	288	new_trap->copy_to (the_trap);
226	new_trap->x = x;	289	new_trap->x = x;
227	new_trap->y = y;	290	new_trap->y = y;
228	insert_ob_in_ob(new_trap,the_chest);	291	insert_ob_in_ob (new_trap, the_chest);
		292	}
229	}	293	}
230	}
231	}	294	}
232		295
233	/* set the chest lock code, and call the keyplacer routine with	296	/* set the chest lock code, and call the keyplacer routine with
234	the lockcode. It's not worth bothering to lock the chest if	297	the lockcode. It's not worth bothering to lock the chest if
235	there's only 1 treasure....*/	298	there's only 1 treasure.... */
236		299
237	if((treasureoptions & KEYREQUIRED)&&n_treasures>1) {	300	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
		301	{
238	char keybuf[256];	302	char keybuf[1024];
		303
239	sprintf(keybuf,"%d",(int)RANDOM());	304	sprintf (keybuf, "%d", (int) RANDOM ());
240	the_chest->slaying = add_string(keybuf);	305	the_chest->slaying = keybuf;
241	keyplace(map,x,y,keybuf,PASS_DOORS,1,RP);	306	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
242	}	307	}
243		308
244	/* actually place the chest. */	309	/* actually place the chest. */
245	the_chest->x = xl; the_chest->y = yl;	310	the_chest->x = xl;
		311	the_chest->y = yl;
246	insert_ob_in_map(the_chest,map,NULL,0);	312	insert_ob_in_map (the_chest, map, NULL, 0);
247	return the_chest;	313	return the_chest;
248	}	314	}
249		315
250		316
251	/* finds the closest monster and returns him, regardless of doors	317	/* finds the closest monster and returns him, regardless of doors
252	or walls */	318	or walls */
253	object find_closest_monster(mapstruct map,int x,int y,RMParms *RP) {	319	object *
		320	find_closest_monster (maptile map, int x, int y, random_map_params RP)
		321	{
254	int i;	322	int i;
		323
255	for(i=0;i<SIZEOFFREE;i++) {	324	for (i = 0; i < SIZEOFFREE; i++)
		325	{
256	int lx,ly;	326	int lx, ly;
		327
257	lx=x+freearr_x[i];	328	lx = x + freearr_x[i];
258	ly=y+freearr_y[i];	329	ly = y + freearr_y[i];
259	/* boundscheck */	330	/* boundscheck */
260	if(lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)	331	if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)
261	/* don't bother searching this square unless the map says life exists.*/	332	/* don't bother searching this square unless the map says life exists. */
262	if(GET_MAP_FLAGS(map,lx,ly) & P_IS_ALIVE) {	333	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
		334	{
263	object *the_monster=get_map_ob(map,lx,ly);	335	object *the_monster = GET_MAP_OB (map, lx, ly);
		336
264	for(;the_monster!=NULL&&(!QUERY_FLAG(the_monster,FLAG_MONSTER));the_monster=the_monster->above);	337	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);
265	if(the_monster && QUERY_FLAG(the_monster,FLAG_MONSTER))	338	if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))
266	return the_monster;	339	return the_monster;
		340	}
267	}	341	}
268	}
269	return NULL;	342	return NULL;
270	}	343	}
271		344
272		345
273		346
274	/* places keys in the map, preferably in something alive.	347	/* places keys in the map, preferably in something alive.
275	keycode is the key's code,	348	keycode is the key's code,
276	door_flag is either PASS_DOORS or NO_PASS_DOORS.	349	door_flag is either PASS_DOORS or NO_PASS_DOORS.
279	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.	352	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
280		353
281	The idea is that you call keyplace on x,y where a door is, and it'll make	354	The idea is that you call keyplace on x,y where a door is, and it'll make
282	sure a key is placed on both sides of the door.	355	sure a key is placed on both sides of the door.
283	*/	356	*/
284		357	int
285	int keyplace(mapstruct map,int x,int y,char keycode,int door_flag,int n_keys,RMParms *RP) {	358	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
		359	{
286	int i,j;	360	int i, j;
287	int kx,ky;	361	int kx = 0, ky = 0;
288	object the_keymaster; / the monster that gets the key. */	362	object the_keymaster; / the monster that gets the key. */
289	object *the_key;	363	object *the_key;
290		364
291	/* get a key and set its keycode */	365	/* get a key and set its keycode */
292	the_key = get_archetype("key2");	366	the_key = get_archetype ("key2");
293	the_key->slaying = add_string(keycode);	367	the_key->slaying = keycode;
294		368
295
296	if(door_flag==PASS_DOORS) {	369	if (door_flag == PASS_DOORS)
		370	{
297	int tries=0;	371	int tries = 0;
		372
298	the_keymaster=NULL;	373	the_keymaster = 0;
299	while(tries<15&&the_keymaster==NULL) {	374	while (tries < 15 && !the_keymaster)
		375	{
300	i = (RANDOM()%(RP->Xsize-2))+1;	376	i = (RANDOM () % (RP->Xsize - 2)) + 1;
301	j = (RANDOM()%(RP->Ysize-2))+1;	377	j = (RANDOM () % (RP->Ysize - 2)) + 1;
302	tries++;	378	tries++;
303	the_keymaster=find_closest_monster(map,i,j,RP);	379	the_keymaster = find_closest_monster (map, i, j, RP);
304	}	380	}
		381
305	/* if we don't find a good keymaster, drop the key on the ground. */	382	/* if we don't find a good keymaster, drop the key on the ground. */
306	if(the_keymaster==NULL) {	383	if (!the_keymaster)
		384	{
307	int freeindex;	385	int freeindex;
308		386
309	freeindex = -1;	387	freeindex = -1;
310	for(tries = 0; tries < 15 && freeindex == -1; tries++) {	388	for (tries = 0; tries < 15 && freeindex == -1; tries++)
		389	{
311	kx = (RANDOM()%(RP->Xsize-2))+1;	390	kx = (RANDOM () % (RP->Xsize - 2)) + 1;
312	ky = (RANDOM()%(RP->Ysize-2))+1;	391	ky = (RANDOM () % (RP->Ysize - 2)) + 1;
313	freeindex = find_first_free_spot(the_key,map,kx,ky);	392	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
314	}	393	}
		394
		395	// can freeindex ever be < 0?
315	if(freeindex != -1) {	396	if (freeindex >= 0)
		397	{
316	kx += freearr_x[freeindex];	398	kx += freearr_x [freeindex];
317	ky += freearr_y[freeindex];	399	ky += freearr_y [freeindex];
		400	}
318	}	401	}
319	}
320	}	402	}
		403	else
321	else { /* NO_PASS_DOORS --we have to work harder.*/	404	{ /* NO_PASS_DOORS --we have to work harder. */
322	/* don't try to keyplace if we're sitting on a blocked square and	405	/* don't try to keyplace if we're sitting on a blocked square and
323	NO_PASS_DOORS is set. */	406	NO_PASS_DOORS is set. */
324	if(n_keys==1) {	407	if (n_keys == 1)
		408	{
325	if(wall_blocked(map,x,y)) return 0;	409	if (wall_blocked (map, x, y))
		410	return 0;
		411
326	the_keymaster=find_monster_in_room(map,x,y,RP);	412	the_keymaster = find_monster_in_room (map, x, y, RP);
327	if(the_keymaster==NULL) /* if fail, find a spot to drop the key. */	413	if (!the_keymaster) /* if fail, find a spot to drop the key. */
328	find_spot_in_room(map,x,y,&kx,&ky,RP);	414	find_spot_in_room (map, x, y, &kx, &ky, RP);
329	}	415	}
330	else {	416	else
		417	{
331	int sum=0; /* count how many keys we actually place */	418	int sum = 0; /* count how many keys we actually place */
		419
332	/* I'm lazy, so just try to place in all 4 directions. */	420	/* I'm lazy, so just try to place in all 4 directions. */
333	sum +=keyplace(map,x+1,y,keycode,NO_PASS_DOORS,1,RP);	421	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
334	sum +=keyplace(map,x,y+1,keycode,NO_PASS_DOORS,1,RP);	422	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
335	sum +=keyplace(map,x-1,y,keycode,NO_PASS_DOORS,1,RP);	423	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
336	sum +=keyplace(map,x,y-1,keycode,NO_PASS_DOORS,1,RP);	424	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		425
337	if(sum < 2) /* we might have made a disconnected map-place more keys. */	426	if (sum < 2) /* we might have made a disconnected map-place more keys. */
338	{ /* diagnoally this time. */	427	{ /* diagonally this time. */
339	keyplace(map,x+1,y+1,keycode,NO_PASS_DOORS,1,RP);	428	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
340	keyplace(map,x+1,y-1,keycode,NO_PASS_DOORS,1,RP);	429	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
341	keyplace(map,x-1,y+1,keycode,NO_PASS_DOORS,1,RP);	430	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
342	keyplace(map,x-1,y-1,keycode,NO_PASS_DOORS,1,RP);	431	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
343	}	432	}
		433
		434	return 1;
		435	}
		436	}
		437
		438	if (!the_keymaster)
		439	{
		440	the_key->x = kx;
		441	the_key->y = ky;
		442	insert_ob_in_map (the_key, map, NULL, 0);
344	return 1;	443	return 1;
345	}
346	}	444	}
347		445
348	if(the_keymaster==NULL) {
349	the_key->x = kx;
350	the_key->y = ky;
351	insert_ob_in_map(the_key,map,NULL,0);
352	return 1;
353	}
354
355	insert_ob_in_ob(the_key,the_keymaster);	446	insert_ob_in_ob (the_key, the_keymaster);
356	return 1;	447	return 1;
357	}	448	}
358		449
359		450
360		451
361	/* both find_monster_in_room routines need to have access to this. */	452	/* both find_monster_in_room routines need to have access to this. */
362		453
363	object *theMonsterToFind;	454	object *theMonsterToFind;
364		455
365	/* a recursive routine which will return a monster, eventually,if there is one.	456	/* a recursive routine which will return a monster, eventually,if there is one.
366	it does a check-off on the layout, converting 0's to 1's */	457	it does a check-off on the layout, converting 0's to 1's */
367		458
		459	object *
368	object find_monster_in_room_recursive(char layout, mapstruct map, int x, int y, RMParms *RP) {	460	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)
		461	{
369	int i,j;	462	int i, j;
		463
370	/* if we've found a monster already, leave */	464	/* if we've found a monster already, leave */
371	if(theMonsterToFind!=NULL) return theMonsterToFind;	465	if (theMonsterToFind != NULL)
		466	return theMonsterToFind;
372		467
373	/* bounds check x and y */	468	/* bounds check x and y */
374	if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return theMonsterToFind;	469	if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
		470	return theMonsterToFind;
375		471
376	/* if the square is blocked or searched already, leave */	472	/* if the square is blocked or searched already, leave */
		473	if (layout[x][y] != 0)
377	if(layout[x][y]!=0) return theMonsterToFind; /* might be NULL, that's fine.*/	474	return theMonsterToFind; /* might be NULL, that's fine. */
378		475
379	/* check the current square for a monster. If there is one,	476	/* check the current square for a monster. If there is one,
380	set theMonsterToFind and return it. */	477	set theMonsterToFind and return it. */
381	layout[x][y]=1;	478	layout[x][y] = 1;
382	if(GET_MAP_FLAGS(map,x,y) & P_IS_ALIVE) {	479	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
		480	{
383	object *the_monster = get_map_ob(map,x,y);	481	object *the_monster = GET_MAP_OB (map, x, y);
		482
384	/* check off this point */	483	/* check off this point */
385	for(;the_monster!=NULL&&(!QUERY_FLAG(the_monster,FLAG_ALIVE));the_monster=the_monster->above);	484	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);
386	if(the_monster && QUERY_FLAG(the_monster,FLAG_ALIVE)) {	485	if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
		486	{
387	theMonsterToFind=the_monster;	487	theMonsterToFind = the_monster;
388	return theMonsterToFind;	488	return theMonsterToFind;
389	}	489	}
390	}	490	}
391		491
392	/* now search all the 8 squares around recursively for a monster,in random order */	492	/* now search all the 8 squares around recursively for a monster,in random order */
393	for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) {	493	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
		494	{
394	theMonsterToFind = find_monster_in_room_recursive(layout,map,x+freearr_x[i%8+1],y+freearr_y[i%8+1],RP);	495	theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
395	if(theMonsterToFind!=NULL) return theMonsterToFind;	496	if (theMonsterToFind != NULL)
		497	return theMonsterToFind;
396	}	498	}
397	return theMonsterToFind;	499	return theMonsterToFind;
398	}	500	}
399		501
400		502
401	/* sets up some data structures: the _recursive form does the	503	/* sets up some data structures: the _recursive form does the
402	real work. */	504	real work. */
403		505
404	object find_monster_in_room(mapstruct map,int x,int y,RMParms *RP) {	506	object *
		507	find_monster_in_room (maptile map, int x, int y, random_map_params RP)
		508	{
405	char **layout2;	509	char **layout2;
406	int i,j;	510	int i, j;
		511
407	theMonsterToFind=0;	512	theMonsterToFind = 0;
408	layout2 = (char *) calloc(sizeof(char ),RP->Xsize);	513	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);
409	/* allocate and copy the layout, converting C to 0. */	514	/* allocate and copy the layout, converting C to 0. */
410	for(i=0;i<RP->Xsize;i++) {	515	for (i = 0; i < RP->Xsize; i++)
		516	{
411	layout2[i]=(char *)calloc(sizeof(char),RP->Ysize);	517	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
412	for(j=0;j<RP->Ysize;j++) {	518	for (j = 0; j < RP->Ysize; j++)
413	if(wall_blocked(map,i,j)) layout2[i][j] = '#';	519	{
414	}	520	if (wall_blocked (map, i, j))
		521	layout2[i][j] = '#';
		522	}
415	}	523	}
416	theMonsterToFind = find_monster_in_room_recursive(layout2,map,x,y,RP);	524	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
417		525
418	/* deallocate the temp. layout */	526	/* deallocate the temp. layout */
419	for(i=0;i<RP->Xsize;i++) {	527	for (i = 0; i < RP->Xsize; i++)
		528	{
420	free(layout2[i]);	529	free (layout2[i]);
421	}	530	}
422	free(layout2);	531	free (layout2);
423		532
424	return theMonsterToFind;	533	return theMonsterToFind;
425	}	534	}
426
427		535
428
429
430	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	536	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
431	int *room_free_spots_x;	537	int *room_free_spots_x;
432	int *room_free_spots_y;	538	int *room_free_spots_y;
433	int number_of_free_spots_in_room;	539	int number_of_free_spots_in_room;
434		540
435	/* the workhorse routine, which finds the free spots in a room:	541	/* the workhorse routine, which finds the free spots in a room:
436	a datastructure of free points is set up, and a position chosen from	542	a datastructure of free points is set up, and a position chosen from
437	that datastructure. */	543	that datastructure. */
438		544	void
439	void find_spot_in_room_recursive(char *layout,int x,int y,RMParms RP) {	545	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)
		546	{
440	int i,j;	547	int i, j;
441		548
442	/* bounds check x and y */	549	/* bounds check x and y */
443	if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return;	550	if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
		551	return;
444		552
445	/* if the square is blocked or searched already, leave */	553	/* if the square is blocked or searched already, leave */
446	if(layout[x][y]!=0) return;	554	if (layout[x][y] != 0)
		555	return;
447		556
448	/* set the current square as checked, and add it to the list.	557	/* set the current square as checked, and add it to the list.
449	set theMonsterToFind and return it. */	558	set theMonsterToFind and return it. */
450	/* check off this point */	559	/* check off this point */
451	layout[x][y]=1;	560	layout[x][y] = 1;
452	room_free_spots_x[number_of_free_spots_in_room]=x;	561	room_free_spots_x[number_of_free_spots_in_room] = x;
453	room_free_spots_y[number_of_free_spots_in_room]=y;	562	room_free_spots_y[number_of_free_spots_in_room] = y;
454	number_of_free_spots_in_room++;	563	number_of_free_spots_in_room++;
		564
455	/* now search all the 8 squares around recursively for free spots,in random order */	565	/* now search all the 8 squares around recursively for free spots,in random order */
456	for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) {	566	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
457	find_spot_in_room_recursive(layout,x+freearr_x[i%8+1],y+freearr_y[i%8+1],RP);	567	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
458	}
459		568
460	}	569	}
461		570
462	/* find a random non-blocked spot in this room to drop a key. */	571	/* find a random non-blocked spot in this room to drop a key. */
		572	void
463	void find_spot_in_room(mapstruct map,int x,int y,int kx,int ky,RMParms RP) {	573	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)
		574	{
464	char **layout2;	575	char **layout2;
465	int i,j;	576	int i, j;
		577
466	number_of_free_spots_in_room=0;	578	number_of_free_spots_in_room = 0;
467	room_free_spots_x = (int )calloc(sizeof(int),RP->Xsize RP->Ysize);	579	room_free_spots_x = (int ) calloc (sizeof (int), RP->Xsize RP->Ysize);
468	room_free_spots_y = (int )calloc(sizeof(int),RP->Xsize RP->Ysize);	580	room_free_spots_y = (int ) calloc (sizeof (int), RP->Xsize RP->Ysize);
469		581
470	layout2 = (char *) calloc(sizeof(char ),RP->Xsize);	582	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);
471	/* allocate and copy the layout, converting C to 0. */	583	/* allocate and copy the layout, converting C to 0. */
472	for(i=0;i<RP->Xsize;i++) {	584	for (i = 0; i < RP->Xsize; i++)
		585	{
473	layout2[i]=(char *)calloc(sizeof(char),RP->Ysize);	586	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
474	for(j=0;j<RP->Ysize;j++) {	587	for (j = 0; j < RP->Ysize; j++)
475	if(wall_blocked(map,i,j)) layout2[i][j] = '#';	588	if (wall_blocked (map, i, j))
476	}	589	layout2[i][j] = '#';
477	}	590	}
478		591
479	/* setup num_free_spots and room_free_spots */	592	/* setup num_free_spots and room_free_spots */
480	find_spot_in_room_recursive(layout2,x,y,RP);	593	find_spot_in_room_recursive (layout2, x, y, RP);
481		594
482	if(number_of_free_spots_in_room > 0) {	595	if (number_of_free_spots_in_room > 0)
		596	{
483	i = RANDOM()%number_of_free_spots_in_room;	597	i = RANDOM () % number_of_free_spots_in_room;
484	*kx = room_free_spots_x[i];	598	*kx = room_free_spots_x[i];
485	*ky = room_free_spots_y[i];	599	*ky = room_free_spots_y[i];
486	}	600	}
487		601
488	/* deallocate the temp. layout */	602	/* deallocate the temp. layout */
489	for(i=0;i<RP->Xsize;i++) {	603	for (i = 0; i < RP->Xsize; i++)
490	free(layout2[i]);	604	free (layout2[i]);
491	}	605
492	free(layout2);	606	free (layout2);
493	free(room_free_spots_x);	607	free (room_free_spots_x);
494	free(room_free_spots_y);	608	free (room_free_spots_y);
495	}	609	}
496		610
497		611
498	/* searches the map for a spot with walls around it. The more	612	/* searches the map for a spot with walls around it. The more
499	walls the better, but it'll settle for 1 wall, or even 0, but	613	walls the better, but it'll settle for 1 wall, or even 0, but
500	it'll return 0 if no FREE spots are found.*/	614	it'll return 0 if no FREE spots are found.*/
501		615	void
502	void find_enclosed_spot(mapstruct map, int cx, int cy,RMParms RP) {	616	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)
		617	{
503	int x,y;	618	int x, y;
504	int i;	619	int i;
		620
505	x = cx;y=cy;	621	x = *cx;
		622	y = *cy;
506		623
507	for(i=0;i<=SIZEOFFREE1;i++) {	624	for (i = 0; i <= SIZEOFFREE1; i++)
		625	{
508	int lx,ly,sindex;	626	int lx, ly, sindex;
		627
509	lx = x +freearr_x[i];	628	lx = x + freearr_x[i];
510	ly = y +freearr_y[i];	629	ly = y + freearr_y[i];
511	sindex = surround_flag3(map,lx,ly,RP);	630	sindex = surround_flag3 (map, lx, ly, RP);
512	/* if it's blocked on 3 sides, it's enclosed */	631	/* if it's blocked on 3 sides, it's enclosed */
513	if(sindex==7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14) {	632	if (sindex == 7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14)
514	cx= lx;cy= ly;	633	{
		634	*cx = lx;
		635	*cy = ly;
515	return;	636	return;
516	}	637	}
517	}	638	}
518		639
519	/* OK, if we got here, we're obviously someplace where there's no enclosed	640	/* OK, if we got here, we're obviously someplace where there's no enclosed
520	spots--try to find someplace which is 2x enclosed. */	641	spots--try to find someplace which is 2x enclosed. */
521	for(i=0;i<=SIZEOFFREE1;i++) {	642	for (i = 0; i <= SIZEOFFREE1; i++)
		643	{
522	int lx,ly,sindex;	644	int lx, ly, sindex;
		645
523	lx = x +freearr_x[i];	646	lx = x + freearr_x[i];
524	ly = y +freearr_y[i];	647	ly = y + freearr_y[i];
525	sindex = surround_flag3(map,lx,ly,RP);	648	sindex = surround_flag3 (map, lx, ly, RP);
526	/* if it's blocked on 3 sides, it's enclosed */	649	/* if it's blocked on 3 sides, it's enclosed */
527	if(sindex==3 \|\| sindex == 5 \|\| sindex == 9 \|\| sindex == 6 \|\| sindex==10 \|\| sindex==12) {	650	if (sindex == 3 \|\| sindex == 5 \|\| sindex == 9 \|\| sindex == 6 \|\| sindex == 10 \|\| sindex == 12)
528	cx= lx;cy= ly;	651	{
		652	*cx = lx;
		653	*cy = ly;
529	return;	654	return;
530	}	655	}
531	}	656	}
532		657
533	/* settle for one surround point */	658	/* settle for one surround point */
534	for(i=0;i<=SIZEOFFREE1;i++) {	659	for (i = 0; i <= SIZEOFFREE1; i++)
		660	{
535	int lx,ly,sindex;	661	int lx, ly, sindex;
		662
536	lx = x +freearr_x[i];	663	lx = x + freearr_x[i];
537	ly = y +freearr_y[i];	664	ly = y + freearr_y[i];
538	sindex = surround_flag3(map,lx,ly,RP);	665	sindex = surround_flag3 (map, lx, ly, RP);
539	/* if it's blocked on 3 sides, it's enclosed */	666	/* if it's blocked on 3 sides, it's enclosed */
540	if(sindex) {	667	if (sindex)
541	cx= lx;cy= ly;	668	{
		669	*cx = lx;
		670	*cy = ly;
542	return;	671	return;
543	}	672	}
544	}	673	}
545	/* give up and return the closest free spot. */	674	/* give up and return the closest free spot. */
546	i = find_first_free_spot(&find_archetype("chest")->clone,map,x,y);	675	i = find_free_spot (&archetype::find ("chest")->clone, map, x, y, 1, SIZEOFFREE1 + 1);
547	if(i!=-1&&i<=SIZEOFFREE1) {	676
		677	if (i != -1)
		678	{
548	*cx = x +freearr_x[i];	679	*cx = x + freearr_x[i];
549	*cy = y +freearr_y[i];	680	*cy = y + freearr_y[i];
550	return;
551	}	681	}
		682	else
		683	{
552	/* indicate failure */	684	/* indicate failure */
553	cx=cy=-1;	685	*cx = -1;
		686	*cy = -1;
		687	}
554	}	688	}
555		689
556		690
		691	void
557	void remove_monsters(int x,int y,mapstruct *map) {	692	remove_monsters (int x, int y, maptile *map)
		693	{
558	object *tmp;	694	object *tmp;
559		695
560	for(tmp=get_map_ob(map,x,y);tmp!=NULL;tmp=tmp->above)	696	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
561	if(QUERY_FLAG(tmp,FLAG_ALIVE)) {	697	if (QUERY_FLAG (tmp, FLAG_ALIVE))
562	if(tmp->head) tmp=tmp->head;	698	{
563	remove_ob(tmp);	699	if (tmp->head)
564	free_object(tmp);	700	tmp = tmp->head;
565	tmp=get_map_ob(map,x,y);	701	tmp->remove ();
		702	tmp->destroy ();
		703	tmp = GET_MAP_OB (map, x, y);
566	if(tmp==NULL) break;	704	if (tmp == NULL)
		705	break;
567	};	706	};
568	}	707	}
569		708
570		709
571	/* surrounds the point x,y by doors, so as to enclose something, like	710	/* surrounds the point x,y by doors, so as to enclose something, like
572	a chest. It only goes as far as the 8 squares surrounding, and	711	a chest. It only goes as far as the 8 squares surrounding, and
573	it'll remove any monsters it finds.*/	712	it'll remove any monsters it finds.*/
574		713
		714	object **
575	object ** surround_by_doors(mapstruct map,char *layout,int x,int y,int opts) {	715	surround_by_doors (maptile map, char *layout, int x, int y, int opts)
		716	{
576	int i;	717	int i;
577	char *doors[2];	718	char *doors[2];
578	object **doorlist;	719	object **doorlist;
579	int ndoors_made=0;	720	int ndoors_made = 0;
580	doorlist = (object *) calloc(9, sizeof(object )); /* 9 doors so we can hold termination null */	721	doorlist = (object *) calloc (9, sizeof (object )); /* 9 doors so we can hold termination null */
581		722
582	/* this is a list we pick from, for horizontal and vertical doors */	723	/* this is a list we pick from, for horizontal and vertical doors */
583	if(opts&DOORED) {	724	if (opts & DOORED)
		725	{
584	doors[0]="locked_door2";	726	doors[0] = "locked_door2";
585	doors[1]="locked_door1";	727	doors[1] = "locked_door1";
586	}	728	}
587	else {	729	else
		730	{
588	doors[0]="door_1";	731	doors[0] = "door_1";
589	doors[1]="door_2";	732	doors[1] = "door_2";
590	}	733	}
591		734
592	/* place doors in all the 8 adjacent unblocked squares. */	735	/* place doors in all the 8 adjacent unblocked squares. */
593	for(i=1;i<9;i++) {	736	for (i = 1; i < 9; i++)
		737	{
594	int x1 = x + freearr_x[i], y1 = y+freearr_y[i];	738	int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
595		739
596	if(!wall_blocked(map,x1,y1)	740	if (!wall_blocked (map, x1, y1) \|\| layout[x1][y1] == '>')
597	\|\| layout[x1][y1]=='>') {/* place a door */	741	{ /* place a door */
598	object * new_door=get_archetype( (freearr_x[i]==0)?doors[1]:doors[0]);	742	object *new_door = get_archetype ((freearr_x[i] == 0) ? doors[1] : doors[0]);
		743
599	new_door->x = x + freearr_x[i];	744	new_door->x = x + freearr_x[i];
600	new_door->y = y + freearr_y[i];	745	new_door->y = y + freearr_y[i];
601	remove_monsters(new_door->x,new_door->y,map);	746	remove_monsters (new_door->x, new_door->y, map);
602	insert_ob_in_map(new_door,map,NULL,0);	747	insert_ob_in_map (new_door, map, NULL, 0);
603	doorlist[ndoors_made]=new_door;	748	doorlist[ndoors_made] = new_door;
604	ndoors_made++;	749	ndoors_made++;
605	}	750	}
606	}	751	}
607	return doorlist;	752	return doorlist;
608	}	753	}
609		754
610		755
611	/* returns the first door in this square, or NULL if there isn't a door. */	756	/* returns the first door in this square, or NULL if there isn't a door. */
		757	object *
612	object door_in_square(mapstruct map,int x,int y) {	758	door_in_square (maptile *map, int x, int y)
		759	{
613	object *tmp;	760	object *tmp;
		761
614	for(tmp=get_map_ob(map,x,y);tmp!=NULL;tmp=tmp->above)	762	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
615	if(tmp->type == DOOR \|\| tmp->type== LOCKED_DOOR) return tmp;	763	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
		764	return tmp;
616	return NULL;	765	return NULL;
617	}	766	}
618		767
619		768
620	/* the workhorse routine, which finds the doors in a room */	769	/* the workhorse routine, which finds the doors in a room */
		770	void
621	void find_doors_in_room_recursive(char *layout,mapstruct map,int x,int y,object *doorlist,int ndoors,RMParms *RP) {	771	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)
		772	{
622	int i,j;	773	int i, j;
623	object *door;	774	object *door;
624		775
625	/* bounds check x and y */	776	/* bounds check x and y */
626	if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return;	777	if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
		778	return;
627		779
628	/* if the square is blocked or searched already, leave */	780	/* if the square is blocked or searched already, leave */
629	if(layout[x][y]==1) return;	781	if (layout[x][y] == 1)
		782	return;
630		783
631	/* check off this point */	784	/* check off this point */
632	if(layout[x][y]=='#') { /* there could be a door here */	785	if (layout[x][y] == '#')
		786	{ /* there could be a door here */
633	layout[x][y]=1;	787	layout[x][y] = 1;
634	door=door_in_square(map,x,y);	788	door = door_in_square (map, x, y);
635	if(door!=NULL) {	789	if (door)
		790	{
636	doorlist[*ndoors]=door;	791	doorlist[*ndoors] = door;
637	if(ndoors>254) / eek! out of memory */	792	if (ndoors > 1022) / eek! out of memory */
638	{	793	{
639	LOG(llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");	794	LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
640	return;	795	return;
641	}	796	}
		797
642	ndoors=ndoors+1;	798	ndoors = ndoors + 1;
643	}	799	}
644	}	800	}
645	else {	801	else
		802	{
646	layout[x][y]=1;	803	layout[x][y] = 1;
647	/* now search all the 8 squares around recursively for free spots,in random order */	804	/* now search all the 8 squares around recursively for free spots,in random order */
648	for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) {	805	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
649	find_doors_in_room_recursive(layout,map,x+freearr_x[i%8+1],y+freearr_y[i%8+1],doorlist,ndoors,RP);	806	find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
650	}
651	}	807	}
652	}	808	}
653		809
654	/* find a random non-blocked spot in this room to drop a key. */	810	/* find a random non-blocked spot in this room to drop a key. */
655	object** find_doors_in_room(mapstruct map,int x,int y,RMParms RP) {	811	object **
		812	find_doors_in_room (maptile map, int x, int y, random_map_params RP)
		813	{
656	char **layout2;	814	char **layout2;
657	object **doorlist;	815	object **doorlist;
658	int i,j;	816	int i, j;
659	int ndoors=0;	817	int ndoors = 0;
660		818
661	doorlist = (object **)calloc(sizeof(int),256);	819	doorlist = (object **) calloc (sizeof (int), 1024);
662		820
663
664	layout2 = (char *) calloc(sizeof(char ),RP->Xsize);	821	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);
665	/* allocate and copy the layout, converting C to 0. */	822	/* allocate and copy the layout, converting C to 0. */
666	for(i=0;i<RP->Xsize;i++) {	823	for (i = 0; i < RP->Xsize; i++)
		824	{
667	layout2[i]=(char *)calloc(sizeof(char),RP->Ysize);	825	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
668	for(j=0;j<RP->Ysize;j++) {	826	for (j = 0; j < RP->Ysize; j++)
669	if(wall_blocked(map,i,j)) layout2[i][j] = '#';	827	{
670	}	828	if (wall_blocked (map, i, j))
		829	layout2[i][j] = '#';
		830	}
671	}	831	}
672		832
673	/* setup num_free_spots and room_free_spots */	833	/* setup num_free_spots and room_free_spots */
674	find_doors_in_room_recursive(layout2,map,x,y,doorlist,&ndoors,RP);	834	find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
675		835
676	/* deallocate the temp. layout */	836	/* deallocate the temp. layout */
677	for(i=0;i<RP->Xsize;i++) {	837	for (i = 0; i < RP->Xsize; i++)
678	free(layout2[i]);	838	free (layout2[i]);
679	}	839
680	free(layout2);	840	free (layout2);
681	return doorlist;	841	return doorlist;
682	}	842	}
683		843
684		844
685		845
686	/* locks and/or hides all the doors in doorlist, or does nothing if	846	/* locks and/or hides all the doors in doorlist, or does nothing if
687	opts doesn't say to lock/hide doors. */	847	opts doesn't say to lock/hide doors. */
688		848
		849	void
689	void lock_and_hide_doors(object *doorlist,mapstruct map,int opts,RMParms *RP) {	850	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)
		851	{
690	object *door;	852	object *door;
691	int i;	853	int i;
		854
692	/* lock the doors and hide the keys. */	855	/* lock the doors and hide the keys. */
693		856
694	if(opts & DOORED) {	857	if (opts & DOORED)
		858	{
695	for(i=0,door=doorlist[0];doorlist[i]!=NULL;i++) {	859	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
		860	{
696	object *new_door=get_archetype("locked_door1");	861	object *new_door = get_archetype ("locked_door1");
697	char keybuf[256];	862	char keybuf[1024];
		863
698	door=doorlist[i];	864	door = doorlist[i];
699	new_door->face = door->face;	865	new_door->face = door->face;
700	new_door->x = door->x;	866	new_door->x = door->x;
701	new_door->y = door->y;	867	new_door->y = door->y;
702	remove_ob(door);	868	door->remove ();
703	free_object(door);	869	door->destroy ();
704	doorlist[i]=new_door;	870	doorlist[i] = new_door;
705	insert_ob_in_map(new_door,map,NULL,0);	871	insert_ob_in_map (new_door, map, NULL, 0);
706	sprintf(keybuf,"%d",(int)RANDOM());	872	sprintf (keybuf, "%d", (int) RANDOM ());
707	new_door->slaying = add_string(keybuf);	873	new_door->slaying = keybuf;
708	keyplace(map,new_door->x,new_door->y,keybuf,NO_PASS_DOORS,2,RP);	874	keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);
709	}	875	}
710	}	876	}
711		877
712	/* change the faces of the doors and surrounding walls to hide them. */	878	/* change the faces of the doors and surrounding walls to hide them. */
713	if(opts & HIDDEN) {	879	if (opts & HIDDEN)
		880	{
714	for(i=0,door=doorlist[0];doorlist[i]!=NULL;i++) {	881	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
		882	{
715	object *wallface;	883	object *wallface;
		884
716	door=doorlist[i];	885	door = doorlist[i];
717	wallface=retrofit_joined_wall(map,door->x,door->y,1,RP);	886	wallface = retrofit_joined_wall (map, door->x, door->y, 1, RP);
718	if(wallface!=NULL) {	887	if (wallface != NULL)
		888	{
719	retrofit_joined_wall(map,door->x-1,door->y,0,RP);	889	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
720	retrofit_joined_wall(map,door->x+1,door->y,0,RP);	890	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
721	retrofit_joined_wall(map,door->x,door->y-1,0,RP);	891	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
722	retrofit_joined_wall(map,door->x,door->y+1,0,RP);	892	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
723	door->face = wallface->face;	893	door->face = wallface->face;
724	if(!QUERY_FLAG(wallface,FLAG_REMOVED)) remove_ob(wallface);	894	if (!QUERY_FLAG (wallface, FLAG_REMOVED))
725	free_object(wallface);	895	wallface->remove ();
		896	wallface->destroy ();
		897	}
726	}	898	}
727	}
728	}	899	}
729	}	900	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.2 by root, Tue Aug 29 08:01:36 2006 UTC vs. Revision 1.19 by root, Wed Jan 17 12:36:31 2007 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.19 by root, Wed Jan 17 12:36:31 2007 UTC