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

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.5 by root, Thu Sep 14 21:16:12 2006 UTC vs. Revision 1.43 by root, Mon Sep 29 09:04:51 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.5 by root, Thu Sep 14 21:16:12 2006 UTC vs.
Revision 1.43 by root, Mon Sep 29 09:04:51 2008 UTC