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

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.39 by root, Thu May 8 11:39:24 2008 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.39 by root, Thu May 8 11:39:24 2008 UTC