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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC vs.
Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC vs. Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC vs.
Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC