[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.21 by root, Thu Jan 18 19:42:10 2007 UTC

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

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.21 by root, Thu Jan 18 19:42:10 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.21 by root, Thu Jan 18 19:42:10 2007 UTC