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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.13 by root, Sun Dec 31 20:46:17 2006 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 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 it under
9	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
10	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	(at your option) any later version.	11	* 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 Affero GNU General Public License
19	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
20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
21		21	*
22	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>
23	*/	23	*/
24		24
25	/* placing treasure in maps, where appropriate. */	25	/* placing treasure in maps, where appropriate. */
26
27
28		26
29	#include <global.h>	27	#include <global.h>
30	#include <random_map.h>	28	#include <random_map.h>
31	#include <rproto.h>	29	#include <rproto.h>
32		30
43	#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 */
44		42
45	#define NO_PASS_DOORS 0	43	#define NO_PASS_DOORS 0
46	#define PASS_DOORS 1	44	#define PASS_DOORS 1
47		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	}
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[1024];	189	char styledirname[1024];
76	char stylefilepath[1024];	190	char stylefilepath[1024];
…		…
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[1024];	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	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
674
675	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
676	if (QUERY_FLAG (tmp, FLAG_ALIVE))
677	{	676	{
678	if (tmp->head)	677	object *next = tmp->above;
679	tmp = tmp->head;	678
680	tmp->remove ();	679	if (tmp->flag [FLAG_ALIVE])
681	tmp->destroy ();	680	tmp->head_ ()->destroy ();
682	tmp = GET_MAP_OB (map, x, y);	681
683	if (tmp == NULL)	682	tmp = next;
684	break;
685	};	683	}
686	}	684	}
687
688		685
689	/* 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
690	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
691	it'll remove any monsters it finds.*/	688	it'll remove any monsters it finds.*/
692
693	object **	689	object **
694	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)
695	{	691	{
696	int i;	692	int i;
697	char *doors[2];	693	const char *doors[2];
698	object **doorlist;	694	object **doorlist;
699	int ndoors_made = 0;	695	int ndoors_made = 0;
700	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 */
701		697
702	/* 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 */
…		…
714	/* place doors in all the 8 adjacent unblocked squares. */	710	/* place doors in all the 8 adjacent unblocked squares. */
715	for (i = 1; i < 9; i++)	711	for (i = 1; i < 9; i++)
716	{	712	{
717	int x1 = x + freearr_x[i], y1 = y + freearr_y[i];	713	int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
718		714
719	if (!wall_blocked (map, x1, y1) \|\| layout[x1][y1] == '>')	715	if (!wall_blocked (map, x1, y1) && layout[x1][y1] == '>')
720	{ /* place a door */	716	{ /* place a door */
		717	remove_monsters (x1, y1, map);
		718
721	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]);
722		720	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;	721	doorlist[ndoors_made] = new_door;
728	ndoors_made++;	722	ndoors_made++;
729	}	723	}
730	}	724	}
		725
731	return doorlist;	726	return doorlist;
732	}	727	}
733		728
734		729
735	/* 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. */
…		…
741	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)
742	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	737	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
743	return tmp;	738	return tmp;
744	return NULL;	739	return NULL;
745	}	740	}
746
747		741
748	/* the workhorse routine, which finds the doors in a room */	742	/* the workhorse routine, which finds the doors in a room */
749	void	743	void
750	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)	744	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)
751	{	745	{
…		…
766	layout[x][y] = 1;	760	layout[x][y] = 1;
767	door = door_in_square (map, x, y);	761	door = door_in_square (map, x, y);
768	if (door)	762	if (door)
769	{	763	{
770	doorlist[*ndoors] = door;	764	doorlist[*ndoors] = door;
		765
771	if (ndoors > 1022) / eek! out of memory */	766	if (ndoors > 1022) / eek! out of memory */
772	{	767	{
773	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");
774	return;	769	return;
775	}	770	}
…		…
778	}	773	}
779	}	774	}
780	else	775	else
781	{	776	{
782	layout[x][y] = 1;	777	layout[x][y] = 1;
		778
783	/* 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 */
784	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++)
785	find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);	781	find_doors_in_room_recursive (layout, map,
		782	x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
		783	doorlist, ndoors, RP);
786	}	784	}
787	}	785	}
788		786
789	/* 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. */
790	object **	788	object **
791	find_doors_in_room (maptile map, int x, int y, random_map_params RP)	789	find_doors_in_room (maptile map, int x, int y, random_map_params RP)
792	{	790	{
793	char **layout2;
794	object **doorlist;
795	int i, j;	791	int i, j;
796	int ndoors = 0;	792	int ndoors = 0;
797		793
798	doorlist = (object **) calloc (sizeof (int), 1024);	794	object doorlist = (object )calloc (sizeof (int), 1024);
799		795
800	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);	796	LayoutData layout2 (RP->Xsize, RP->Ysize);
		797	layout2.clear ();
		798
801	/* allocate and copy the layout, converting C to 0. */	799	/* allocate and copy the layout, converting C to 0. */
802	for (i = 0; i < RP->Xsize; i++)	800	for (i = 0; i < RP->Xsize; i++)
803	{
804	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
805	for (j = 0; j < RP->Ysize; j++)	801	for (j = 0; j < RP->Ysize; j++)
806	{	802	layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
807	if (wall_blocked (map, i, j))
808	layout2[i][j] = '#';
809	}
810	}
811		803
812	/* setup num_free_spots and room_free_spots */	804	/* setup num_free_spots and room_free_spots */
813	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);
814		806
815	/* deallocate the temp. layout */
816	for (i = 0; i < RP->Xsize; i++)
817	free (layout2[i]);
818
819	free (layout2);
820	return doorlist;	807	return doorlist;
821	}	808	}
822
823
824		809
825	/* 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
826	opts doesn't say to lock/hide doors. */	811	opts doesn't say to lock/hide doors. */
827
828	void	812	void
829	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)	813	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)
830	{	814	{
831	object *door;	815	object *door;
832	int i;	816	int i;
833		817
834	/* lock the doors and hide the keys. */	818	/* lock the doors and hide the keys. */
835		819
836	if (opts & DOORED)	820	if (opts & DOORED)
837	{	821	{
838	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	822	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
839	{	823	{
840	object *new_door = get_archetype ("locked_door1");	824	object *new_door = get_archetype (shstr_locked_door1);
841	char keybuf[1024];
842		825
843	door = doorlist[i];	826	door = doorlist[i];
844	new_door->face = door->face;	827	new_door->face = door->face;
845	new_door->x = door->x;	828	new_door->x = door->x;
846	new_door->y = door->y;	829	new_door->y = door->y;
847	door->remove ();
848	door->destroy ();	830	door->destroy ();
849	doorlist[i] = new_door;	831	doorlist[i] = new_door;
850	insert_ob_in_map (new_door, map, NULL, 0);	832	insert_ob_in_map (new_door, map, NULL, 0);
851	sprintf (keybuf, "%d", (int) RANDOM ());	833	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
852	new_door->slaying = keybuf;
853	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);
854	}	835	}
855	}	836	}
856		837
857	/* 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. */
858	if (opts & HIDDEN)	839	if (opts & HIDDEN)
…		…
867	{	848	{
868	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);	849	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
869	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);	850	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
870	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	851	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
871	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	852	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
		853
872	door->face = wallface->face;	854	door->face = wallface->face;
873	if (!QUERY_FLAG (wallface, FLAG_REMOVED))	855
874	wallface->remove ();
875	wallface->destroy ();	856	wallface->destroy ();
876	}	857	}
877	}	858	}
878	}	859	}
879	}	860	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.13 by root, Sun Dec 31 20:46:17 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.13 by root, Sun Dec 31 20:46:17 2006 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC