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

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.41 by root, Thu Jul 24 20:35:37 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.41 by root, Thu Jul 24 20:35:37 2008 UTC