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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.8 by root, Tue Dec 12 20:53:03 2006 UTC vs.
Revision 1.61 by root, Sun May 1 16:58:16 2011 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.8 by root, Tue Dec 12 20:53:03 2006 UTC vs. Revision 1.61 by root, Sun May 1 16:58:16 2011 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.8 by root, Tue Dec 12 20:53:03 2006 UTC vs.
Revision 1.61 by root, Sun May 1 16:58:16 2011 UTC