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

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.14 by pippijn, Sat Jan 6 14:42:30 2007 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.14 by pippijn, Sat Jan 6 14:42:30 2007 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC