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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.12 by root, Sun Dec 31 19:02:24 2006 UTC vs.
Revision 1.41 by root, Thu Jul 24 20:35:37 2008 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.12 by root, Sun Dec 31 19:02:24 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.12 by root, Sun Dec 31 19:02:24 2006 UTC vs.
Revision 1.41 by root, Thu Jul 24 20:35:37 2008 UTC