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

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.8 by root, Tue Dec 12 20:53:03 2006 UTC vs. Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.8 by root, Tue Dec 12 20:53:03 2006 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC