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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs.
Revision 1.55 by root, Thu Jul 1 01:22:44 2010 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* placing treasure in maps, where appropriate. */	25	/* placing treasure in maps, where appropriate. */
40	#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 */
41		42
42	#define NO_PASS_DOORS 0	43	#define NO_PASS_DOORS 0
43	#define PASS_DOORS 1	44	#define PASS_DOORS 1
44		45
		46	static object find_closest_monster (maptile map, int x, int y, random_map_params *RP);
		47	static object find_monster_in_room (maptile map, int x, int y, random_map_params *RP);
		48	static void find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP);
		49	static void find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP);
		50	static object place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params RP);
		51	static object *find_doors_in_room (maptile map, int x, int y, random_map_params *RP);
		52	static void lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP);
		53	static void find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP);
		54	static object *surround_by_doors (maptile map, char **layout, int x, int y, int opts);
		55
45	/* a macro to get a strongly centered random distribution,	56	/* a macro to get a strongly centered random distribution,
46	from 0 to x, centered at x/2 */	57	from 0 to x, centered at x/2 */
47	static int	58	static int
48	bc_random (int x)	59	bc_random (int x)
49	{	60	{
50	return (rndm (x) + rndm (x) + rndm (x)) / 3;	61	return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
		62	}
		63
		64	static object *
		65	gen_key (const shstr &keycode)
		66	{
		67	/* get a key and set its keycode */
		68	object *key = archetype::get (shstr_key_random_map);
		69	key->slaying = keycode;
		70	return key;
		71	}
		72
		73	/* places keys in the map, preferably in something alive.
		74	keycode is the key's code,
		75	door_flag is either PASS_DOORS or NO_PASS_DOORS.
		76	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
		77	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
		78	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
		79
		80	The idea is that you call keyplace on x,y where a door is, and it'll make
		81	sure a key is placed on both sides of the door.
		82	*/
		83	static int
		84	keyplace (maptile map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params RP)
		85	{
		86	int i, j;
		87	int kx = 0, ky = 0;
		88	object the_keymaster; / the monster that gets the key. */
		89	object *the_key = gen_key (keycode);
		90
		91	if (door_flag == PASS_DOORS)
		92	{
		93	int tries = 0;
		94
		95	the_keymaster = 0;
		96	while (tries < 15 && !the_keymaster)
		97	{
		98	i = rmg_rndm (RP->Xsize - 2) + 1;
		99	j = rmg_rndm (RP->Ysize - 2) + 1;
		100	tries++;
		101	the_keymaster = find_closest_monster (map, i, j, RP);
		102	}
		103
		104	/* if we don't find a good keymaster, drop the key on the ground. */
		105	if (!the_keymaster)
		106	{
		107	int freeindex;
		108
		109	freeindex = -1;
		110	for (tries = 0; tries < 15 && freeindex == -1; tries++)
		111	{
		112	kx = rmg_rndm (RP->Xsize - 2) + 1;
		113	ky = rmg_rndm (RP->Ysize - 2) + 1;
		114	freeindex = rmg_find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
		115	}
		116
		117	// can freeindex ever be < 0?
		118	if (freeindex >= 0)
		119	{
		120	kx += freearr_x [freeindex];
		121	ky += freearr_y [freeindex];
		122	}
		123	}
		124	}
		125	else
		126	{ /* NO_PASS_DOORS --we have to work harder. */
		127	/* don't try to keyplace if we're sitting on a blocked square and
		128	NO_PASS_DOORS is set. */
		129	if (n_keys == 1)
		130	{
		131	if (wall_blocked (map, x, y))
		132	{
		133	the_key->destroy ();
		134	return 0;
		135	}
		136
		137	the_keymaster = find_monster_in_room (map, x, y, RP);
		138	if (!the_keymaster) /* if fail, find a spot to drop the key. */
		139	find_spot_in_room (map, x, y, &kx, &ky, RP);
		140	}
		141	else
		142	{
		143	int sum = 0; /* count how many keys we actually place */
		144
		145	/* I'm lazy, so just try to place in all 4 directions. */
		146	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
		147	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		148	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
		149	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		150
		151	if (sum < 2) /* we might have made a disconnected map-place more keys. */
		152	{ /* diagonally this time. */
		153	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		154	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		155	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		156	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		157	}
		158
		159	the_key->destroy ();
		160	return 1;
		161	}
		162	}
		163
		164	if (the_keymaster)
		165	the_keymaster->head_ ()->insert (the_key);
		166	else
		167	{
		168	the_key->x = kx;
		169	the_key->y = ky;
		170	insert_ob_in_map (the_key, map, NULL, 0);
		171	}
		172
		173	return 1;
51	}	174	}
52		175
53	/* returns true if square x,y has P_NO_PASS set, which is true for walls	176	/* returns true if square x,y has P_NO_PASS set, which is true for walls
54	* and doors but not monsters.	177	* and doors but not monsters.
55	* This function is not map tile aware.	178	* This function is not map tile aware.
…		…
69	layout, (required)	192	layout, (required)
70	treasure style (may be empty or NULL, or "none" to cause no treasure.)	193	treasure style (may be empty or NULL, or "none" to cause no treasure.)
71	treasureoptions (may be 0 for random choices or positive)	194	treasureoptions (may be 0 for random choices or positive)
72	*/	195	*/
73	void	196	void
74	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)	197	place_treasure (maptile map, char layout, const char treasure_style, int treasureoptions, random_map_params *RP)
75	{	198	{
76	char styledirname[1024];
77	char stylefilepath[1024];
78	maptile *style_map = 0;
79	int num_treasures;	199	int num_treasures;
80		200
81	/* bail out if treasure isn't wanted. */	201	/* bail out if treasure isn't wanted. */
82	if (treasure_style)	202	if (treasure_style)
83	if (!strcmp (treasure_style, "none"))	203	if (!strcmp (treasure_style, "none"))
84	return;	204	return;
85		205
86	if (treasureoptions <= 0)	206	if (treasureoptions <= 0)
87	treasureoptions = rndm (2 * LAST_OPTION);	207	treasureoptions = rmg_rndm (2 * LAST_OPTION);
88		208
89	/* filter out the mutually exclusive options */	209	/* filter out the mutually exclusive options */
90	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))	210	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
91	{	211	{
92	if (rndm (2))	212	if (rmg_rndm (2))
93	treasureoptions -= 1;	213	treasureoptions -= 1;
94	else	214	else
95	treasureoptions -= 2;	215	treasureoptions -= 2;
96	}	216	}
97		217
…		…
105		225
106	if (num_treasures <= 0)	226	if (num_treasures <= 0)
107	return;	227	return;
108		228
109	/* get the style map */	229	/* get the style map */
110	sprintf (styledirname, "%s", "/styles/treasurestyles");	230	maptile *style_map = find_style ("/styles/treasurestyles", treasure_style, RP->difficulty);
111	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
112	style_map = find_style (styledirname, treasure_style, -1);
113		231
114	if (!style_map)	232	if (!style_map)
115	{	233	{
116	LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);	234	LOG (llevError, "unable to load style map %s %s.\n", "/styles/treasurestyles", treasure_style);
117	return;	235	return;
118	}	236	}
119		237
120	/* all the treasure at one spot in the map. */	238	/* all the treasure at one spot in the map. */
121	if (treasureoptions & CONCENTRATED)	239	if (treasureoptions & CONCENTRATED)
…		…
168		286
169	i = j = -1;	287	i = j = -1;
170	tries = 0;	288	tries = 0;
171	while (i == -1 && tries < 100)	289	while (i == -1 && tries < 100)
172	{	290	{
173	i = rndm (RP->Xsize - 2) + 1;	291	i = rmg_rndm (RP->Xsize - 2) + 1;
174	j = rndm (RP->Ysize - 2) + 1;	292	j = rmg_rndm (RP->Ysize - 2) + 1;
175	find_enclosed_spot (map, &i, &j, RP);	293	find_enclosed_spot (map, &i, &j, RP);
176		294
177	if (wall_blocked (map, i, j))	295	if (wall_blocked (map, i, j))
178	i = -1;	296	i = -1;
179		297
…		…
200	{ /* DIFFUSE treasure layout */	318	{ /* DIFFUSE treasure layout */
201	int ti, i, j;	319	int ti, i, j;
202		320
203	for (ti = 0; ti < num_treasures; ti++)	321	for (ti = 0; ti < num_treasures; ti++)
204	{	322	{
205	i = rndm (RP->Xsize - 2) + 1;	323	i = rmg_rndm (RP->Xsize - 2) + 1;
206	j = rndm (RP->Ysize - 2) + 1;	324	j = rmg_rndm (RP->Ysize - 2) + 1;
207	place_chest (treasureoptions, i, j, map, style_map, 1, RP);	325	place_chest (treasureoptions, i, j, map, style_map, 1, RP);
208	}	326	}
209	}	327	}
210	}	328	}
211		329
212	/* put a chest into the map, near x and y, with the treasure style	330	/* put a chest into the map, near x and y, with the treasure style
213	determined (may be null, or may be a treasure list from lib/treasures,	331	determined (may be null, or may be a treasure list from lib/treasures,
214	if the global variable "treasurestyle" is set to that treasure list's name */	332	if the global variable "treasurestyle" is set to that treasure list's name */
215	object *	333	static object *
216	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)	334	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
217	{	335	{
218	object *the_chest;
219	int i, xl, yl;
220
221	the_chest = get_archetype ("chest"); /* was "chest_2" */	336	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
222		337
223	/* first, find a place to put the chest. */	338	/* first, find a place to put the chest. */
224	i = find_first_free_spot (the_chest, map, x, y);	339	int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
225	if (i == -1)	340	if (i == -1)
226	{	341	{
227	the_chest->destroy ();	342	the_chest->destroy ();
228	return NULL;	343	return NULL;
229	}	344	}
230		345
231	xl = x + freearr_x[i];	346	int xl = x + freearr_x[i];
232	yl = y + freearr_y[i];	347	int yl = y + freearr_y[i];
233		348
234	/* if the placement is blocked, return a fail. */	349	/* if the placement is blocked, return a fail. */
235	if (wall_blocked (map, xl, yl))	350	if (wall_blocked (map, xl, yl))
236	return 0;	351	return 0;
237		352
…		…
244	treasurelist *tlist = find_treasurelist (RP->treasurestyle);	359	treasurelist *tlist = find_treasurelist (RP->treasurestyle);
245		360
246	if (tlist != NULL)	361	if (tlist != NULL)
247	for (ti = 0; ti < n_treasures; ti++)	362	for (ti = 0; ti < n_treasures; ti++)
248	{ /* use the treasure list */	363	{ /* use the treasure list */
249	object *new_treasure = style_map->pick_random_object ();	364	object *new_treasure = style_map->pick_random_object (rmg_rndm);
250		365
251	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	366	insert_ob_in_ob (new_treasure->arch->instance (), the_chest);
252	}	367	}
253	else	368	else
254	{ /* use the style map */	369	{ /* use the style map */
255	the_chest->randomitems = tlist;	370	the_chest->randomitems = tlist;
256	the_chest->stats.hp = n_treasures;	371	the_chest->stats.hp = n_treasures;
…		…
264	}	379	}
265		380
266	/* stick a trap in the chest if required */	381	/* stick a trap in the chest if required */
267	if (treasureoptions & TRAPPED)	382	if (treasureoptions & TRAPPED)
268	{	383	{
269	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);	384	maptile *trap_map = find_style ("/styles/trapstyles", "traps", RP->difficulty);
270		385
271	if (trap_map)	386	if (trap_map)
272	{	387	{
273	object *the_trap = trap_map->pick_random_object ();	388	object *the_trap = trap_map->pick_random_object (rmg_rndm);
274		389
275	the_trap->stats.Cha = 10 + RP->difficulty;	390	the_trap->stats.Cha = 10 + RP->difficulty;
276	the_trap->level = bc_random ((3 * RP->difficulty) / 2);	391	the_trap->level = bc_random ((3 * RP->difficulty) / 2);
277		392
278	if (the_trap)	393	if (the_trap)
…		…
289	/* set the chest lock code, and call the keyplacer routine with	404	/* set the chest lock code, and call the keyplacer routine with
290	the lockcode. It's not worth bothering to lock the chest if	405	the lockcode. It's not worth bothering to lock the chest if
291	there's only 1 treasure.... */	406	there's only 1 treasure.... */
292	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	407	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
293	{	408	{
294	char keybuf[1024];	409	the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
295
296	sprintf (keybuf, "%d", rndm (1000000000));
297	the_chest->slaying = keybuf;
298	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);	410	keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
299	}	411	}
300		412
301	/* actually place the chest. */	413	/* actually place the chest. */
302	the_chest->x = xl;	414	the_chest->x = xl;
303	the_chest->y = yl;	415	the_chest->y = yl;
304	insert_ob_in_map (the_chest, map, NULL, 0);	416	insert_ob_in_map (the_chest, map, NULL, 0);
305	return the_chest;	417	return the_chest;
306	}	418	}
307		419
308
309	/* finds the closest monster and returns him, regardless of doors	420	/* finds the closest monster and returns him, regardless of doors or walls */
310	or walls */	421	static object *
311	object *
312	find_closest_monster (maptile map, int x, int y, random_map_params RP)	422	find_closest_monster (maptile map, int x, int y, random_map_params RP)
313	{	423	{
314	int i;	424	int i;
315		425
316	for (i = 0; i < SIZEOFFREE; i++)	426	for (i = 0; i < SIZEOFFREE; i++)
…		…
324	/* don't bother searching this square unless the map says life exists. */	434	/* don't bother searching this square unless the map says life exists. */
325	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)	435	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
326	{	436	{
327	object *the_monster = GET_MAP_OB (map, lx, ly);	437	object *the_monster = GET_MAP_OB (map, lx, ly);
328		438
329	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);	439	for (; the_monster != NULL && (!the_monster->flag [FLAG_MONSTER]); the_monster = the_monster->above);
330	if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))	440	if (the_monster && the_monster->flag [FLAG_MONSTER])
331	return the_monster;	441	return the_monster;
332	}	442	}
333	}	443	}
334	return NULL;	444	return NULL;
335	}	445	}
336		446
337
338
339	/* places keys in the map, preferably in something alive.
340	keycode is the key's code,
341	door_flag is either PASS_DOORS or NO_PASS_DOORS.
342	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
343	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
344	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
345
346	The idea is that you call keyplace on x,y where a door is, and it'll make
347	sure a key is placed on both sides of the door.
348	*/
349	int
350	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
351	{
352	int i, j;
353	int kx = 0, ky = 0;
354	object the_keymaster; / the monster that gets the key. */
355	object *the_key;
356
357	/* get a key and set its keycode */
358	the_key = get_archetype ("key2");
359	the_key->slaying = keycode;
360
361	if (door_flag == PASS_DOORS)
362	{
363	int tries = 0;
364
365	the_keymaster = 0;
366	while (tries < 15 && !the_keymaster)
367	{
368	i = rndm (RP->Xsize - 2) + 1;
369	j = rndm (RP->Ysize - 2) + 1;
370	tries++;
371	the_keymaster = find_closest_monster (map, i, j, RP);
372	}
373
374	/* if we don't find a good keymaster, drop the key on the ground. */
375	if (!the_keymaster)
376	{
377	int freeindex;
378
379	freeindex = -1;
380	for (tries = 0; tries < 15 && freeindex == -1; tries++)
381	{
382	kx = rndm (RP->Xsize - 2) + 1;
383	ky = rndm (RP->Ysize - 2) + 1;
384	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
385	}
386
387	// can freeindex ever be < 0?
388	if (freeindex >= 0)
389	{
390	kx += freearr_x [freeindex];
391	ky += freearr_y [freeindex];
392	}
393	}
394	}
395	else
396	{ /* NO_PASS_DOORS --we have to work harder. */
397	/* don't try to keyplace if we're sitting on a blocked square and
398	NO_PASS_DOORS is set. */
399	if (n_keys == 1)
400	{
401	if (wall_blocked (map, x, y))
402	return 0;
403
404	the_keymaster = find_monster_in_room (map, x, y, RP);
405	if (!the_keymaster) /* if fail, find a spot to drop the key. */
406	find_spot_in_room (map, x, y, &kx, &ky, RP);
407	}
408	else
409	{
410	int sum = 0; /* count how many keys we actually place */
411
412	/* I'm lazy, so just try to place in all 4 directions. */
413	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
414	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
415	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
416	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
417
418	if (sum < 2) /* we might have made a disconnected map-place more keys. */
419	{ /* diagonally this time. */
420	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
421	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
422	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
423	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
424	}
425
426	return 1;
427	}
428	}
429
430	if (!the_keymaster)
431	{
432	the_key->x = kx;
433	the_key->y = ky;
434	insert_ob_in_map (the_key, map, NULL, 0);
435	return 1;
436	}
437
438	insert_ob_in_ob (the_key, the_keymaster->head_ ());
439	return 1;
440	}
441
442
443
444	/* both find_monster_in_room routines need to have access to this. */	447	/* both find_monster_in_room routines need to have access to this. */
445		448
446	object *theMonsterToFind;	449	static object *theMonsterToFind;
447		450
448	/* a recursive routine which will return a monster, eventually,if there is one.	451	/* a recursive routine which will return a monster, eventually,if there is one.
449	it does a check-off on the layout, converting 0's to 1's */	452	it does a check-off on the layout, converting 0's to 1's */
450		453	static object *
451	object *
452	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)	454	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)
453	{	455	{
454	int i, j;	456	int i, j;
455		457
456	/* if we've found a monster already, leave */	458	/* if we've found a monster already, leave */
…		…
471	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)	473	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
472	{	474	{
473	object *the_monster = GET_MAP_OB (map, x, y);	475	object *the_monster = GET_MAP_OB (map, x, y);
474		476
475	/* check off this point */	477	/* check off this point */
476	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);	478	for (; the_monster != NULL && (!the_monster->flag [FLAG_ALIVE]); the_monster = the_monster->above);
477	if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))	479	if (the_monster && the_monster->flag [FLAG_ALIVE])
478	{	480	{
479	theMonsterToFind = the_monster;	481	theMonsterToFind = the_monster;
480	return theMonsterToFind;	482	return theMonsterToFind;
481	}	483	}
482	}	484	}
483		485
484	/* 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 */
485	for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	487	for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
486	{	488	{
487	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);
488	if (theMonsterToFind != NULL)	490	if (theMonsterToFind != NULL)
489	return theMonsterToFind;	491	return theMonsterToFind;
490	}	492	}
…		…
492	return theMonsterToFind;	494	return theMonsterToFind;
493	}	495	}
494		496
495	/* sets up some data structures: the _recursive form does the	497	/* sets up some data structures: the _recursive form does the
496	real work. */	498	real work. */
497	object *	499	static object *
498	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)
499	{	501	{
500	Layout layout2 (RP);	502	Layout layout2 (map->width, map->height);
501		503
502	layout2->clear ();	504	// find walls
503
504	/* allocate and copy the layout, converting C to 0. */
505	for (int i = 0; i < layout2->w; i++)	505	for (int i = 0; i < layout2.w; i++)
506	for (int j = 0; j < layout2->h; j++)	506	for (int j = 0; j < layout2.h; j++)
507	if (wall_blocked (map, i, j))	507	layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
508	layout2[i][j] = '#';
509		508
510	theMonsterToFind = 0;	509	theMonsterToFind = 0;
511	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);	510	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
512		511
513	layout2.free ();
514
515	return theMonsterToFind;	512	return theMonsterToFind;
516	}	513	}
517		514
518	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	515	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
519	int *room_free_spots_x;	516	static int *room_free_spots_x;
520	int *room_free_spots_y;	517	static int *room_free_spots_y;
521	int number_of_free_spots_in_room;	518	static int number_of_free_spots_in_room;
522		519
523	/* the workhorse routine, which finds the free spots in a room:	520	/* the workhorse routine, which finds the free spots in a room:
524	a datastructure of free points is set up, and a position chosen from	521	a datastructure of free points is set up, and a position chosen from
525	that datastructure. */	522	that datastructure. */
526	void	523	static void
527	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)	524	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)
528	{	525	{
529	int i, j;	526	int i, j;
530		527
531	/* bounds check x and y */	528	/* bounds check x and y */
…		…
543	room_free_spots_x[number_of_free_spots_in_room] = x;	540	room_free_spots_x[number_of_free_spots_in_room] = x;
544	room_free_spots_y[number_of_free_spots_in_room] = y;	541	room_free_spots_y[number_of_free_spots_in_room] = y;
545	number_of_free_spots_in_room++;	542	number_of_free_spots_in_room++;
546		543
547	/* now search all the 8 squares around recursively for free spots,in random order */	544	/* now search all the 8 squares around recursively for free spots,in random order */
548	for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	545	for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
549	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);	546	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
550		547
551	}	548	}
552		549
553	/* find a random non-blocked spot in this room to drop a key. */	550	/* find a random non-blocked spot in this room to drop a key. */
554	void	551	static void
555	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)	552	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)
556	{	553	{
557	char **layout2;	554	char **layout2;
558	int i, j;	555	int i, j;
559		556
…		…
574	/* setup num_free_spots and room_free_spots */	571	/* setup num_free_spots and room_free_spots */
575	find_spot_in_room_recursive (layout2, x, y, RP);	572	find_spot_in_room_recursive (layout2, x, y, RP);
576		573
577	if (number_of_free_spots_in_room > 0)	574	if (number_of_free_spots_in_room > 0)
578	{	575	{
579	i = rndm (number_of_free_spots_in_room);	576	i = rmg_rndm (number_of_free_spots_in_room);
580	*kx = room_free_spots_x[i];	577	*kx = room_free_spots_x[i];
581	*ky = room_free_spots_y[i];	578	*ky = room_free_spots_y[i];
582	}	579	}
583		580
584	/* deallocate the temp. layout */	581	/* deallocate the temp. layout */
…		…
592		589
593		590
594	/* searches the map for a spot with walls around it. The more	591	/* 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	592	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.*/	593	it'll return 0 if no FREE spots are found.*/
597	void	594	static void
598	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)	595	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)
599	{	596	{
600	int x, y;	597	int x, y;
601	int i;	598	int i;
602		599
…		…
652	*cy = ly;	649	*cy = ly;
653	return;	650	return;
654	}	651	}
655	}	652	}
656	/* give up and return the closest free spot. */	653	/* give up and return the closest free spot. */
657	i = find_free_spot (archetype::find ("chest"), map, x, y, 1, SIZEOFFREE1 + 1);	654	i = rmg_find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
658		655
659	if (i != -1)	656	if (i != -1)
660	{	657	{
661	*cx = x + freearr_x[i];	658	*cx = x + freearr_x[i];
662	*cy = y + freearr_y[i];	659	*cy = y + freearr_y[i];
…		…
667	*cx = -1;	664	*cx = -1;
668	*cy = -1;	665	*cy = -1;
669	}	666	}
670	}	667	}
671		668
672	void	669	static void
673	remove_monsters (int x, int y, maptile *map)	670	remove_monsters (int x, int y, maptile *map)
674	{	671	{
675	object *tmp;
676
677	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	672	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
678	if (QUERY_FLAG (tmp, FLAG_ALIVE))
679	{	673	{
680	if (tmp->head)	674	object *next = tmp->above;
681	tmp = tmp->head;	675
682	tmp->remove ();	676	if (tmp->flag [FLAG_ALIVE])
683	tmp->destroy ();	677	tmp->head_ ()->destroy ();
684	tmp = GET_MAP_OB (map, x, y);	678
685	if (tmp == NULL)	679	tmp = next;
686	break;
687	};	680	}
688	}	681	}
689		682
690	/* surrounds the point x,y by doors, so as to enclose something, like	683	/* 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	684	a chest. It only goes as far as the 8 squares surrounding, and
692	it'll remove any monsters it finds.*/	685	it'll remove any monsters it finds.*/
693	object **	686	static object **
694	surround_by_doors (maptile map, char *layout, int x, int y, int opts)	687	surround_by_doors (maptile map, char *layout, int x, int y, int opts)
695	{	688	{
696	int i;	689	int i;
697	const char *doors[2];	690	const char *doors[2];
698	object **doorlist;	691	object **doorlist;
…		…
728	}	721	}
729		722
730	return doorlist;	723	return doorlist;
731	}	724	}
732		725
733
734	/* returns the first door in this square, or NULL if there isn't a door. */	726	/* returns the first door in this square, or NULL if there isn't a door. */
735	object *	727	static object *
736	door_in_square (maptile *map, int x, int y)	728	door_in_square (maptile *map, int x, int y)
737	{	729	{
738	object *tmp;
739
740	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)	730	for (object *tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
741	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	731	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
742	return tmp;	732	return tmp;
		733
743	return NULL;	734	return NULL;
744	}	735	}
745		736
746	/* the workhorse routine, which finds the doors in a room */	737	/* the workhorse routine, which finds the doors in a room */
747	void	738	static void
748	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)	739	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)
749	{	740	{
750	int i, j;	741	int i, j;
751	object *door;	742	object *door;
752		743
…		…
779	else	770	else
780	{	771	{
781	layout[x][y] = 1;	772	layout[x][y] = 1;
782		773
783	/* now search all the 8 squares around recursively for free spots,in random order */	774	/* now search all the 8 squares around recursively for free spots,in random order */
784	for (i = rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)	775	for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
785	find_doors_in_room_recursive (layout, map,	776	find_doors_in_room_recursive (layout, map,
786	x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],	777	x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
787	doorlist, ndoors, RP);	778	doorlist, ndoors, RP);
788	}	779	}
789	}	780	}
790		781
791	/* find a random non-blocked spot in this room to drop a key. */	782	/* find a random non-blocked spot in this room to drop a key. */
792	object **	783	static object **
793	find_doors_in_room (maptile map, int x, int y, random_map_params RP)	784	find_doors_in_room (maptile map, int x, int y, random_map_params RP)
794	{	785	{
795	int i, j;	786	int i, j;
796	int ndoors = 0;	787	int ndoors = 0;
797		788
798	object doorlist = (object )calloc (sizeof (int), 1024);	789	object doorlist = (object )calloc (sizeof (int), 1024);
799		790
800	LayoutData layout2 (RP->Xsize, RP->Ysize);	791	Layout layout2 (RP->Xsize, RP->Ysize);
801	layout2.clear ();	792	layout2.clear ();
802		793
803	/* allocate and copy the layout, converting C to 0. */	794	/* allocate and copy the layout, converting C to 0. */
804	for (i = 0; i < RP->Xsize; i++)	795	for (i = 0; i < RP->Xsize; i++)
805	for (j = 0; j < RP->Ysize; j++)	796	for (j = 0; j < RP->Ysize; j++)
…		…
811	return doorlist;	802	return doorlist;
812	}	803	}
813		804
814	/* locks and/or hides all the doors in doorlist, or does nothing if	805	/* locks and/or hides all the doors in doorlist, or does nothing if
815	opts doesn't say to lock/hide doors. */	806	opts doesn't say to lock/hide doors. */
816	void	807	static void
817	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)	808	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)
818	{	809	{
819	object *door;	810	object *door;
820	int i;	811	int i;
821		812
822	/* lock the doors and hide the keys. */	813	/* lock the doors and hide the keys. */
823		814
824	if (opts & DOORED)	815	if (opts & DOORED)
825	{	816	{
826	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	817	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
827	{	818	{
828	object *new_door = get_archetype ("locked_door1");	819	object *new_door = get_archetype (shstr_locked_door1);
829	char keybuf[1024];
830		820
831	door = doorlist[i];	821	door = doorlist[i];
832	new_door->face = door->face;	822	new_door->face = door->face;
833	new_door->x = door->x;	823	new_door->x = door->x;
834	new_door->y = door->y;	824	new_door->y = door->y;
835	door->remove ();
836	door->destroy ();	825	door->destroy ();
837	doorlist[i] = new_door;	826	doorlist[i] = new_door;
838	insert_ob_in_map (new_door, map, NULL, 0);	827	insert_ob_in_map (new_door, map, NULL, 0);
839	sprintf (keybuf, "%d", rndm (1000000000));	828	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
840	new_door->slaying = keybuf;
841	keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);	829	keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
842	}	830	}
843	}	831	}
844		832
845	/* change the faces of the doors and surrounding walls to hide them. */	833	/* change the faces of the doors and surrounding walls to hide them. */
846	if (opts & HIDDEN)	834	if (opts & HIDDEN)
…		…
858	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	846	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
859	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	847	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
860		848
861	door->face = wallface->face;	849	door->face = wallface->face;
862		850
863	if (!QUERY_FLAG (wallface, FLAG_REMOVED))
864	wallface->remove ();
865
866	wallface->destroy ();	851	wallface->destroy ();
867	}	852	}
868	}	853	}
869	}	854	}
870	}	855	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs. Revision 1.55 by root, Thu Jul 1 01:22:44 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs.
Revision 1.55 by root, Thu Jul 1 01:22:44 2010 UTC