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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.22 by root, Fri Jan 19 21:49:58 2007 UTC vs.
Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.22 by root, Fri Jan 19 21:49:58 2007 UTC vs. Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.22 by root, Fri Jan 19 21:49:58 2007 UTC vs.
Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC