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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.23 by root, Sat Jan 27 00:56:48 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);
106	style_map = find_style (styledirname, treasure_style, -1);
107		231
108	if (!style_map)	232	if (!style_map)
109	{	233	{
110	LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);	234	LOG (llevError, "unable to load style map %s %s.\n", "/styles/treasurestyles", treasure_style);
111	return;	235	return;
112	}	236	}
113		237
114	/* all the treasure at one spot in the map. */	238	/* all the treasure at one spot in the map. */
115	if (treasureoptions & CONCENTRATED)	239	if (treasureoptions & CONCENTRATED)
116	{	240	{
117
118	/* map_layout_style global, and is previously set */	241	/* map_layout_style global, and is previously set */
119	switch (RP->map_layout_style)	242	switch (RP->map_layout_style)
120	{	243	{
121	case LAYOUT_ONION:	244	case LAYOUT_ONION:
122	case LAYOUT_SPIRAL:	245	case LAYOUT_SPIRAL:
…		…
130	for (j = 0; j < RP->Ysize; j++)	253	for (j = 0; j < RP->Ysize; j++)
131	{	254	{
132	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')	255	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')
133	{	256	{
134	int tdiv = RP->symmetry_used;	257	int tdiv = RP->symmetry_used;
135	object **doorlist;
136	object *chest;	258	object *chest;
137		259
138	if (tdiv == 3)	260	if (tdiv == 3)
139	tdiv = 2; /* this symmetry uses a divisor of 2 */	261	tdiv = 2; /* this symmetry uses a divisor of 2 */
		262
140	/* don't put a chest on an exit. */	263	/* don't put a chest on an exit. */
141	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
142	if (!chest)	266	if (!chest)
143	continue; /* if no chest was placed NEXT */	267	continue; /* if no chest was placed NEXT */
		268
144	if (treasureoptions & (DOORED \| HIDDEN))	269	if (treasureoptions & (DOORED \| HIDDEN))
145	{	270	{
146	doorlist = find_doors_in_room (map, i, j, RP);	271	object **doorlist = find_doors_in_room (map, i, j, RP);
147	lock_and_hide_doors (doorlist, map, treasureoptions, RP);	272	lock_and_hide_doors (doorlist, map, treasureoptions, RP);
148	free (doorlist);	273	free (doorlist);
149	}	274	}
150	}	275	}
151	}	276	}
152	}	277	}
153	break;	278	break;
154	}	279	}
		280
155	default:	281	default:
156	{	282	{
157	int i, j, tries;	283	int i, j, tries;
158	object *chest;	284	object *chest;
159	object **doorlist;	285	object **doorlist;
160		286
161	i = j = -1;	287	i = j = -1;
162	tries = 0;	288	tries = 0;
163	while (i == -1 && tries < 100)	289	while (i == -1 && tries < 100)
164	{	290	{
165	i = RANDOM () % (RP->Xsize - 2) + 1;	291	i = rmg_rndm (RP->Xsize - 2) + 1;
166	j = RANDOM () % (RP->Ysize - 2) + 1;	292	j = rmg_rndm (RP->Ysize - 2) + 1;
167	find_enclosed_spot (map, &i, &j, RP);	293	find_enclosed_spot (map, &i, &j, RP);
		294
168	if (wall_blocked (map, i, j))	295	if (wall_blocked (map, i, j))
169	i = -1;	296	i = -1;
		297
170	tries++;	298	tries++;
171	}	299	}
		300
172	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
173	if (!chest)	303	if (!chest)
174	return;	304	return;
		305
175	i = chest->x;	306	i = chest->x;
176	j = chest->y;	307	j = chest->y;
177	if (treasureoptions & (DOORED \| HIDDEN))	308	if (treasureoptions & (DOORED \| HIDDEN))
178	{	309	{
179	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);	310	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
…		…
187	{ /* DIFFUSE treasure layout */	318	{ /* DIFFUSE treasure layout */
188	int ti, i, j;	319	int ti, i, j;
189		320
190	for (ti = 0; ti < num_treasures; ti++)	321	for (ti = 0; ti < num_treasures; ti++)
191	{	322	{
192	i = RANDOM () % (RP->Xsize - 2) + 1;	323	i = rmg_rndm (RP->Xsize - 2) + 1;
193	j = RANDOM () % (RP->Ysize - 2) + 1;	324	j = rmg_rndm (RP->Ysize - 2) + 1;
194	place_chest (treasureoptions, i, j, map, style_map, 1, RP);	325	place_chest (treasureoptions, i, j, map, style_map, 1, RP);
195	}	326	}
196	}	327	}
197	}	328	}
198		329
199	/* 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
200	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,
201	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 */
202		333	static object *
203	object *
204	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)
205	{	335	{
206	object *the_chest;
207	int i, xl, yl;
208
209	the_chest = get_archetype ("chest"); /* was "chest_2" */	336	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
210		337
211	/* first, find a place to put the chest. */	338	/* first, find a place to put the chest. */
212	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
213	if (i == -1)	340	if (i == -1)
214	{	341	{
215	the_chest->destroy ();	342	the_chest->destroy ();
216	return NULL;	343	return NULL;
217	}	344	}
218		345
219	xl = x + freearr_x[i];	346	int xl = x + freearr_x[i];
220	yl = y + freearr_y[i];	347	int yl = y + freearr_y[i];
221		348
222	/* if the placement is blocked, return a fail. */	349	/* if the placement is blocked, return a fail. */
223	if (wall_blocked (map, xl, yl))	350	if (wall_blocked (map, xl, yl))
224	return 0;	351	return 0;
225		352
…		…
232	treasurelist *tlist = find_treasurelist (RP->treasurestyle);	359	treasurelist *tlist = find_treasurelist (RP->treasurestyle);
233		360
234	if (tlist != NULL)	361	if (tlist != NULL)
235	for (ti = 0; ti < n_treasures; ti++)	362	for (ti = 0; ti < n_treasures; ti++)
236	{ /* use the treasure list */	363	{ /* use the treasure list */
237	object *new_treasure = pick_random_object (style_map);	364	object *new_treasure = style_map->pick_random_object (rmg_rndm);
238		365
239	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	366	insert_ob_in_ob (new_treasure->arch->instance (), the_chest);
240	}	367	}
241	else	368	else
242	{ /* use the style map */	369	{ /* use the style map */
243	the_chest->randomitems = tlist;	370	the_chest->randomitems = tlist;
244	the_chest->stats.hp = n_treasures;	371	the_chest->stats.hp = n_treasures;
245	}	372	}
246	#endif	373	#endif
247	{ /* neither style_map no treasure list given */	374	{ /* neither style_map no treasure list given */
248	treasurelist *tlist = find_treasurelist ("chest");	375	treasurelist *tlist = treasurelist::find ("chest");
249		376
250	the_chest->randomitems = tlist;	377	the_chest->randomitems = tlist;
251	the_chest->stats.hp = n_treasures;	378	the_chest->stats.hp = n_treasures;
252	}	379	}
253		380
254	/* stick a trap in the chest if required */	381	/* stick a trap in the chest if required */
255	if (treasureoptions & TRAPPED)	382	if (treasureoptions & TRAPPED)
256	{	383	{
257	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);	384	maptile *trap_map = find_style ("/styles/trapstyles", "traps", RP->difficulty);
258	object *the_trap;
259		385
260	if (trap_map)	386	if (trap_map)
261	{	387	{
262	the_trap = pick_random_object (trap_map);	388	object *the_trap = trap_map->pick_random_object (rmg_rndm);
		389
263	the_trap->stats.Cha = 10 + RP->difficulty;	390	the_trap->stats.Cha = 10 + RP->difficulty;
264	the_trap->level = BC_RANDOM ((3 * RP->difficulty) / 2);	391	the_trap->level = bc_random ((3 * RP->difficulty) / 2);
		392
265	if (the_trap)	393	if (the_trap)
266	{	394	{
267	object *new_trap;	395	object *new_trap = the_trap->arch->instance ();//TODO: why not clone?
268		396
269	new_trap = arch_to_object (the_trap->arch);
270	new_trap->copy_to (the_trap);
271	new_trap->x = x;	397	new_trap->x = x;
272	new_trap->y = y;	398	new_trap->y = y;
273	insert_ob_in_ob (new_trap, the_chest);	399	insert_ob_in_ob (new_trap, the_chest);
274	}	400	}
275	}	401	}
276	}	402	}
277		403
278	/* set the chest lock code, and call the keyplacer routine with	404	/* set the chest lock code, and call the keyplacer routine with
279	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
280	there's only 1 treasure.... */	406	there's only 1 treasure.... */
281
282	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	407	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
283	{	408	{
284	char keybuf[1024];	409	the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
285
286	sprintf (keybuf, "%d", (int) RANDOM ());
287	the_chest->slaying = keybuf;
288	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);	410	keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
289	}	411	}
290		412
291	/* actually place the chest. */	413	/* actually place the chest. */
292	the_chest->x = xl;	414	the_chest->x = xl;
293	the_chest->y = yl;	415	the_chest->y = yl;
294	insert_ob_in_map (the_chest, map, NULL, 0);	416	insert_ob_in_map (the_chest, map, NULL, 0);
295	return the_chest;	417	return the_chest;
296	}	418	}
297		419
298
299	/* finds the closest monster and returns him, regardless of doors	420	/* finds the closest monster and returns him, regardless of doors or walls */
300	or walls */	421	static object *
301	object *
302	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)
303	{	423	{
304	int i;	424	int i;
305		425
306	for (i = 0; i < SIZEOFFREE; i++)	426	for (i = 0; i < SIZEOFFREE; i++)
…		…
314	/* 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. */
315	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)	435	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
316	{	436	{
317	object *the_monster = GET_MAP_OB (map, lx, ly);	437	object *the_monster = GET_MAP_OB (map, lx, ly);
318		438
319	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);
320	if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))	440	if (the_monster && the_monster->flag [FLAG_MONSTER])
321	return the_monster;	441	return the_monster;
322	}	442	}
323	}	443	}
324	return NULL;	444	return NULL;
325	}	445	}
326		446
327
328
329	/* places keys in the map, preferably in something alive.
330	keycode is the key's code,
331	door_flag is either PASS_DOORS or NO_PASS_DOORS.
332	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
333	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
334	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
335
336	The idea is that you call keyplace on x,y where a door is, and it'll make
337	sure a key is placed on both sides of the door.
338	*/
339	int
340	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
341	{
342	int i, j;
343	int kx = 0, ky = 0;
344	object the_keymaster; / the monster that gets the key. */
345	object *the_key;
346
347	/* get a key and set its keycode */
348	the_key = get_archetype ("key2");
349	the_key->slaying = keycode;
350
351	if (door_flag == PASS_DOORS)
352	{
353	int tries = 0;
354
355	the_keymaster = 0;
356	while (tries < 15 && !the_keymaster)
357	{
358	i = (RANDOM () % (RP->Xsize - 2)) + 1;
359	j = (RANDOM () % (RP->Ysize - 2)) + 1;
360	tries++;
361	the_keymaster = find_closest_monster (map, i, j, RP);
362	}
363
364	/* if we don't find a good keymaster, drop the key on the ground. */
365	if (!the_keymaster)
366	{
367	int freeindex;
368
369	freeindex = -1;
370	for (tries = 0; tries < 15 && freeindex == -1; tries++)
371	{
372	kx = (RANDOM () % (RP->Xsize - 2)) + 1;
373	ky = (RANDOM () % (RP->Ysize - 2)) + 1;
374	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
375	}
376
377	// can freeindex ever be < 0?
378	if (freeindex >= 0)
379	{
380	kx += freearr_x [freeindex];
381	ky += freearr_y [freeindex];
382	}
383	}
384	}
385	else
386	{ /* NO_PASS_DOORS --we have to work harder. */
387	/* don't try to keyplace if we're sitting on a blocked square and
388	NO_PASS_DOORS is set. */
389	if (n_keys == 1)
390	{
391	if (wall_blocked (map, x, y))
392	return 0;
393
394	the_keymaster = find_monster_in_room (map, x, y, RP);
395	if (!the_keymaster) /* if fail, find a spot to drop the key. */
396	find_spot_in_room (map, x, y, &kx, &ky, RP);
397	}
398	else
399	{
400	int sum = 0; /* count how many keys we actually place */
401
402	/* I'm lazy, so just try to place in all 4 directions. */
403	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
404	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
405	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
406	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
407
408	if (sum < 2) /* we might have made a disconnected map-place more keys. */
409	{ /* diagonally this time. */
410	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
411	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
412	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
413	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
414	}
415
416	return 1;
417	}
418	}
419
420	if (!the_keymaster)
421	{
422	the_key->x = kx;
423	the_key->y = ky;
424	insert_ob_in_map (the_key, map, NULL, 0);
425	return 1;
426	}
427
428	insert_ob_in_ob (the_key, the_keymaster);
429	return 1;
430	}
431
432
433
434	/* 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. */
435		448
436	object *theMonsterToFind;	449	static object *theMonsterToFind;
437		450
438	/* 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.
439	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 */
440		453	static object *
441	object *
442	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)
443	{	455	{
444	int i, j;	456	int i, j;
445		457
446	/* if we've found a monster already, leave */	458	/* if we've found a monster already, leave */
…		…
461	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)	473	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
462	{	474	{
463	object *the_monster = GET_MAP_OB (map, x, y);	475	object *the_monster = GET_MAP_OB (map, x, y);
464		476
465	/* check off this point */	477	/* check off this point */
466	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);
467	if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))	479	if (the_monster && the_monster->flag [FLAG_ALIVE])
468	{	480	{
469	theMonsterToFind = the_monster;	481	theMonsterToFind = the_monster;
470	return theMonsterToFind;	482	return theMonsterToFind;
471	}	483	}
472	}	484	}
473		485
474	/* 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 */
475	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++)
476	{	488	{
477	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);
478	if (theMonsterToFind != NULL)	490	if (theMonsterToFind != NULL)
479	return theMonsterToFind;	491	return theMonsterToFind;
480	}	492	}
		493
481	return theMonsterToFind;	494	return theMonsterToFind;
482	}	495	}
483
484		496
485	/* sets up some data structures: the _recursive form does the	497	/* sets up some data structures: the _recursive form does the
486	real work. */	498	real work. */
487		499	static object *
488	object *
489	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)
490	{	501	{
491	char **layout2;	502	Layout layout2 (map->width, map->height);
492	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;
493		508
494	theMonsterToFind = 0;	509	theMonsterToFind = 0;
495	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);
496	/* allocate and copy the layout, converting C to 0. */
497	for (i = 0; i < RP->Xsize; i++)
498	{
499	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
500	for (j = 0; j < RP->Ysize; j++)
501	{
502	if (wall_blocked (map, i, j))
503	layout2[i][j] = '#';
504	}
505	}
506	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);	510	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
507		511
508	/* deallocate the temp. layout */
509	for (i = 0; i < RP->Xsize; i++)
510	{
511	free (layout2[i]);
512	}
513	free (layout2);
514
515	return theMonsterToFind;	512	return theMonsterToFind;
516	}	513	}
517		514
518	/* 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 */
519	int *room_free_spots_x;	516	static int *room_free_spots_x;
520	int *room_free_spots_y;	517	static int *room_free_spots_y;
521	int number_of_free_spots_in_room;	518	static int number_of_free_spots_in_room;
522		519
523	/* the workhorse routine, which finds the free spots in a room:	520	/* the workhorse routine, which finds the free spots in a room:
524	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
525	that datastructure. */	522	that datastructure. */
526	void	523	static void
527	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)
528	{	525	{
529	int i, j;	526	int i, j;
530		527
531	/* bounds check x and y */	528	/* bounds check x and y */
…		…
543	room_free_spots_x[number_of_free_spots_in_room] = x;	540	room_free_spots_x[number_of_free_spots_in_room] = x;
544	room_free_spots_y[number_of_free_spots_in_room] = y;	541	room_free_spots_y[number_of_free_spots_in_room] = y;
545	number_of_free_spots_in_room++;	542	number_of_free_spots_in_room++;
546		543
547	/* 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 */
548	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++)
549	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);
550		547
551	}	548	}
552		549
553	/* 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. */
554	void	551	static void
555	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)
556	{	553	{
557	char **layout2;	554	char **layout2;
558	int i, j;	555	int i, j;
559		556
…		…
574	/* setup num_free_spots and room_free_spots */	571	/* setup num_free_spots and room_free_spots */
575	find_spot_in_room_recursive (layout2, x, y, RP);	572	find_spot_in_room_recursive (layout2, x, y, RP);
576		573
577	if (number_of_free_spots_in_room > 0)	574	if (number_of_free_spots_in_room > 0)
578	{	575	{
579	i = RANDOM () % number_of_free_spots_in_room;	576	i = rmg_rndm (number_of_free_spots_in_room);
580	*kx = room_free_spots_x[i];	577	*kx = room_free_spots_x[i];
581	*ky = room_free_spots_y[i];	578	*ky = room_free_spots_y[i];
582	}	579	}
583		580
584	/* deallocate the temp. layout */	581	/* deallocate the temp. layout */
…		…
592		589
593		590
594	/* 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
595	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
596	it'll return 0 if no FREE spots are found.*/	593	it'll return 0 if no FREE spots are found.*/
597	void	594	static void
598	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)
599	{	596	{
600	int x, y;	597	int x, y;
601	int i;	598	int i;
602		599
…		…
607	{	604	{
608	int lx, ly, sindex;	605	int lx, ly, sindex;
609		606
610	lx = x + freearr_x[i];	607	lx = x + freearr_x[i];
611	ly = y + freearr_y[i];	608	ly = y + freearr_y[i];
612	sindex = surround_flag3 (map, lx, ly, RP);	609	sindex = surround_flag3 (map, lx, ly);
613	/* if it's blocked on 3 sides, it's enclosed */	610	/* if it's blocked on 3 sides, it's enclosed */
614	if (sindex == 7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14)	611	if (sindex == 7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14)
615	{	612	{
616	*cx = lx;	613	*cx = lx;
617	*cy = ly;	614	*cy = ly;
…		…
625	{	622	{
626	int lx, ly, sindex;	623	int lx, ly, sindex;
627		624
628	lx = x + freearr_x[i];	625	lx = x + freearr_x[i];
629	ly = y + freearr_y[i];	626	ly = y + freearr_y[i];
630	sindex = surround_flag3 (map, lx, ly, RP);	627	sindex = surround_flag3 (map, lx, ly);
631	/* if it's blocked on 3 sides, it's enclosed */	628	/* if it's blocked on 3 sides, it's enclosed */
632	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)
633	{	630	{
634	*cx = lx;	631	*cx = lx;
635	*cy = ly;	632	*cy = ly;
…		…
642	{	639	{
643	int lx, ly, sindex;	640	int lx, ly, sindex;
644		641
645	lx = x + freearr_x[i];	642	lx = x + freearr_x[i];
646	ly = y + freearr_y[i];	643	ly = y + freearr_y[i];
647	sindex = surround_flag3 (map, lx, ly, RP);	644	sindex = surround_flag3 (map, lx, ly);
648	/* if it's blocked on 3 sides, it's enclosed */	645	/* if it's blocked on 3 sides, it's enclosed */
649	if (sindex)	646	if (sindex)
650	{	647	{
651	*cx = lx;	648	*cx = lx;
652	*cy = ly;	649	*cy = ly;
653	return;	650	return;
654	}	651	}
655	}	652	}
656	/* give up and return the closest free spot. */	653	/* give up and return the closest free spot. */
657	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);
658		655
659	if (i != -1)	656	if (i != -1)
660	{	657	{
661	*cx = x + freearr_x[i];	658	*cx = x + freearr_x[i];
662	*cy = y + freearr_y[i];	659	*cy = y + freearr_y[i];
…		…
667	*cx = -1;	664	*cx = -1;
668	*cy = -1;	665	*cy = -1;
669	}	666	}
670	}	667	}
671		668
672	void	669	static void
673	remove_monsters (int x, int y, maptile *map)	670	remove_monsters (int x, int y, maptile *map)
674	{	671	{
675	object *tmp;
676
677	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	672	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
678	if (QUERY_FLAG (tmp, FLAG_ALIVE))
679	{	673	{
680	if (tmp->head)	674	object *next = tmp->above;
681	tmp = tmp->head;	675
682	tmp->remove ();	676	if (tmp->flag [FLAG_ALIVE])
683	tmp->destroy ();	677	tmp->head_ ()->destroy ();
684	tmp = GET_MAP_OB (map, x, y);	678
685	if (tmp == NULL)	679	tmp = next;
686	break;
687	};	680	}
688	}	681	}
689		682
690	/* 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
691	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
692	it'll remove any monsters it finds.*/	685	it'll remove any monsters it finds.*/
693	object **	686	static object **
694	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)
695	{	688	{
696	int i;	689	int i;
697	char *doors[2];	690	const char *doors[2];
698	object **doorlist;	691	object **doorlist;
699	int ndoors_made = 0;	692	int ndoors_made = 0;
700	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 */
701		694
702	/* 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 */
…		…
728	}	721	}
729		722
730	return doorlist;	723	return doorlist;
731	}	724	}
732		725
733
734	/* 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. */
735	object *	727	static object *
736	door_in_square (maptile *map, int x, int y)	728	door_in_square (maptile *map, int x, int y)
737	{	729	{
738	object *tmp;
739
740	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)
741	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	731	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
742	return tmp;	732	return tmp;
		733
743	return NULL;	734	return NULL;
744	}	735	}
745		736
746
747	/* the workhorse routine, which finds the doors in a room */	737	/* the workhorse routine, which finds the doors in a room */
748	void	738	static void
749	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)
750	{	740	{
751	int i, j;	741	int i, j;
752	object *door;	742	object *door;
753		743
…		…
765	layout[x][y] = 1;	755	layout[x][y] = 1;
766	door = door_in_square (map, x, y);	756	door = door_in_square (map, x, y);
767	if (door)	757	if (door)
768	{	758	{
769	doorlist[*ndoors] = door;	759	doorlist[*ndoors] = door;
		760
770	if (ndoors > 1022) / eek! out of memory */	761	if (ndoors > 1022) / eek! out of memory */
771	{	762	{
772	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");
773	return;	764	return;
774	}	765	}
…		…
777	}	768	}
778	}	769	}
779	else	770	else
780	{	771	{
781	layout[x][y] = 1;	772	layout[x][y] = 1;
		773
782	/* 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 */
783	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++)
784	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);
785	}	779	}
786	}	780	}
787		781
788	/* 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. */
789	object **	783	static object **
790	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)
791	{	785	{
792	char **layout2;
793	object **doorlist;
794	int i, j;	786	int i, j;
795	int ndoors = 0;	787	int ndoors = 0;
796		788
797	doorlist = (object **) calloc (sizeof (int), 1024);	789	object doorlist = (object )calloc (sizeof (int), 1024);
798		790
799	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);	791	Layout layout2 (RP->Xsize, RP->Ysize);
		792	layout2.clear ();
		793
800	/* allocate and copy the layout, converting C to 0. */	794	/* allocate and copy the layout, converting C to 0. */
801	for (i = 0; i < RP->Xsize; i++)	795	for (i = 0; i < RP->Xsize; i++)
802	{
803	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
804	for (j = 0; j < RP->Ysize; j++)	796	for (j = 0; j < RP->Ysize; j++)
805	{	797	layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
806	if (wall_blocked (map, i, j))
807	layout2[i][j] = '#';
808	}
809	}
810		798
811	/* setup num_free_spots and room_free_spots */	799	/* setup num_free_spots and room_free_spots */
812	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);
813		801
814	/* deallocate the temp. layout */
815	for (i = 0; i < RP->Xsize; i++)
816	free (layout2[i]);
817
818	free (layout2);
819	return doorlist;	802	return doorlist;
820	}	803	}
821
822
823		804
824	/* 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
825	opts doesn't say to lock/hide doors. */	806	opts doesn't say to lock/hide doors. */
826		807	static void
827	void
828	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)
829	{	809	{
830	object *door;	810	object *door;
831	int i;	811	int i;
832		812
833	/* lock the doors and hide the keys. */	813	/* lock the doors and hide the keys. */
834		814
835	if (opts & DOORED)	815	if (opts & DOORED)
836	{	816	{
837	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	817	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
838	{	818	{
839	object *new_door = get_archetype ("locked_door1");	819	object *new_door = get_archetype (shstr_locked_door1);
840	char keybuf[1024];
841		820
842	door = doorlist[i];	821	door = doorlist[i];
843	new_door->face = door->face;	822	new_door->face = door->face;
844	new_door->x = door->x;	823	new_door->x = door->x;
845	new_door->y = door->y;	824	new_door->y = door->y;
846	door->remove ();
847	door->destroy ();	825	door->destroy ();
848	doorlist[i] = new_door;	826	doorlist[i] = new_door;
849	insert_ob_in_map (new_door, map, NULL, 0);	827	insert_ob_in_map (new_door, map, NULL, 0);
850	sprintf (keybuf, "%d", (int) RANDOM ());	828	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
851	new_door->slaying = keybuf;
852	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);
853	}	830	}
854	}	831	}
855		832
856	/* 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. */
857	if (opts & HIDDEN)	834	if (opts & HIDDEN)
…		…
866	{	843	{
867	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);	844	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
868	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);	845	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
869	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	846	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
870	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	847	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
		848
871	door->face = wallface->face;	849	door->face = wallface->face;
872	if (!QUERY_FLAG (wallface, FLAG_REMOVED))	850
873	wallface->remove ();
874	wallface->destroy ();	851	wallface->destroy ();
875	}	852	}
876	}	853	}
877	}	854	}
878	}	855	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.23 by root, Sat Jan 27 00:56:48 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.23 by root, Sat Jan 27 00:56:48 2007 UTC vs.
Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC