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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs. Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.4 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC