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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.62 by root, Tue Jan 3 11:25:34 2012 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs. Revision 1.62 by root, Tue Jan 3 11:25:34 2012 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.62 by root, Tue Jan 3 11:25:34 2012 UTC