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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.18 by pippijn, Mon Jan 15 21:06:19 2007 UTC vs.
Revision 1.54 by root, Sat Jun 26 22:10:18 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.18 by pippijn, Mon Jan 15 21:06:19 2007 UTC vs. Revision 1.54 by root, Sat Jun 26 22:10:18 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.18 by pippijn, Mon Jan 15 21:06:19 2007 UTC vs.
Revision 1.54 by root, Sat Jun 26 22:10:18 2010 UTC