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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC vs.
Revision 1.56 by root, Fri Jul 2 03:40:14 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	{
…		…
52		63
53	static object *	64	static object *
54	gen_key (const shstr &keycode)	65	gen_key (const shstr &keycode)
55	{	66	{
56	/* get a key and set its keycode */	67	/* get a key and set its keycode */
57	object *key = archetype::get (shstr_key2);	68	object *key = archetype::get (shstr_key_random_map);
58
59	key->slaying = keycode;	69	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;	70	return key;
66	}	71	}
67		72
68	/* places keys in the map, preferably in something alive.	73	/* places keys in the map, preferably in something alive.
69	keycode is the key's code,	74	keycode is the key's code,
…		…
79	keyplace (maptile map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params RP)	84	keyplace (maptile map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params RP)
80	{	85	{
81	int i, j;	86	int i, j;
82	int kx = 0, ky = 0;	87	int kx = 0, ky = 0;
83	object the_keymaster; / the monster that gets the key. */	88	object the_keymaster; / the monster that gets the key. */
		89	object *the_key = gen_key (keycode);
84		90
85	if (door_flag == PASS_DOORS)	91	if (door_flag == PASS_DOORS)
86	{	92	{
87	int tries = 0;	93	int tries = 0;
88		94
…		…
103	freeindex = -1;	109	freeindex = -1;
104	for (tries = 0; tries < 15 && freeindex == -1; tries++)	110	for (tries = 0; tries < 15 && freeindex == -1; tries++)
105	{	111	{
106	kx = rmg_rndm (RP->Xsize - 2) + 1;	112	kx = rmg_rndm (RP->Xsize - 2) + 1;
107	ky = rmg_rndm (RP->Ysize - 2) + 1;	113	ky = rmg_rndm (RP->Ysize - 2) + 1;
108	freeindex = find_free_spot (gen_key (keycode), map, kx, ky, 1, SIZEOFFREE1 + 1);	114	freeindex = rmg_find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
109	}	115	}
110		116
111	// can freeindex ever be < 0?	117	// can freeindex ever be < 0?
112	if (freeindex >= 0)	118	if (freeindex >= 0)
113	{	119	{
…		…
121	/* don't try to keyplace if we're sitting on a blocked square and	127	/* don't try to keyplace if we're sitting on a blocked square and
122	NO_PASS_DOORS is set. */	128	NO_PASS_DOORS is set. */
123	if (n_keys == 1)	129	if (n_keys == 1)
124	{	130	{
125	if (wall_blocked (map, x, y))	131	if (wall_blocked (map, x, y))
		132	{
		133	the_key->destroy ();
126	return 0;	134	return 0;
		135	}
127		136
128	the_keymaster = find_monster_in_room (map, x, y, RP);	137	the_keymaster = find_monster_in_room (map, x, y, RP);
129	if (!the_keymaster) /* if fail, find a spot to drop the key. */	138	if (!the_keymaster) /* if fail, find a spot to drop the key. */
130	find_spot_in_room (map, x, y, &kx, &ky, RP);	139	find_spot_in_room (map, x, y, &kx, &ky, RP);
131	}	140	}
…		…
145	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);
146	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);
147	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);
148	}	157	}
149		158
		159	the_key->destroy ();
150	return 1;	160	return 1;
151	}	161	}
152	}	162	}
153
154	object *the_key = gen_key (keycode);
155		163
156	if (the_keymaster)	164	if (the_keymaster)
157	the_keymaster->head_ ()->insert (the_key);	165	the_keymaster->head_ ()->insert (the_key);
158	else	166	else
159	{	167	{
…		…
184	layout, (required)	192	layout, (required)
185	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.)
186	treasureoptions (may be 0 for random choices or positive)	194	treasureoptions (may be 0 for random choices or positive)
187	*/	195	*/
188	void	196	void
189	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)
190	{	198	{
191	char styledirname[1024];
192	char stylefilepath[1024];
193	maptile *style_map = 0;
194	int num_treasures;	199	int num_treasures;
195		200
196	/* bail out if treasure isn't wanted. */	201	/* bail out if treasure isn't wanted. */
197	if (treasure_style)	202	if (treasure_style)
198	if (!strcmp (treasure_style, "none"))	203	if (!strcmp (treasure_style, "none"))
…		…
220		225
221	if (num_treasures <= 0)	226	if (num_treasures <= 0)
222	return;	227	return;
223		228
224	/* get the style map */	229	/* get the style map */
225	sprintf (styledirname, "%s", "/styles/treasurestyles");	230	maptile *style_map = find_style ("/styles/treasurestyles", treasure_style, RP->difficulty);
226	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
227	style_map = find_style (styledirname, treasure_style, -1);
228		231
229	if (!style_map)	232	if (!style_map)
230	{	233	{
231	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);
232	return;	235	return;
233	}	236	}
234		237
235	/* all the treasure at one spot in the map. */	238	/* all the treasure at one spot in the map. */
236	if (treasureoptions & CONCENTRATED)	239	if (treasureoptions & CONCENTRATED)
…		…
325	}	328	}
326		329
327	/* 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
328	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,
329	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 */
330	object *	333	static object *
331	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)
332	{	335	{
333	object the_chest = archetype::get (shstr_chest); / was "chest_2" */	336	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
334		337
335	/* first, find a place to put the chest. */	338	/* first, find a place to put the chest. */
…		…
358	if (tlist != NULL)	361	if (tlist != NULL)
359	for (ti = 0; ti < n_treasures; ti++)	362	for (ti = 0; ti < n_treasures; ti++)
360	{ /* use the treasure list */	363	{ /* use the treasure list */
361	object *new_treasure = style_map->pick_random_object (rmg_rndm);	364	object *new_treasure = style_map->pick_random_object (rmg_rndm);
362		365
363	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	366	insert_ob_in_ob (new_treasure->arch->instance (), the_chest);
364	}	367	}
365	else	368	else
366	{ /* use the style map */	369	{ /* use the style map */
367	the_chest->randomitems = tlist;	370	the_chest->randomitems = tlist;
368	the_chest->stats.hp = n_treasures;	371	the_chest->stats.hp = n_treasures;
…		…
376	}	379	}
377		380
378	/* stick a trap in the chest if required */	381	/* stick a trap in the chest if required */
379	if (treasureoptions & TRAPPED)	382	if (treasureoptions & TRAPPED)
380	{	383	{
381	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);	384	maptile *trap_map = find_style ("/styles/trapstyles", "traps", RP->difficulty);
382		385
383	if (trap_map)	386	if (trap_map)
384	{	387	{
385	object *the_trap = trap_map->pick_random_object (rmg_rndm);	388	object *the_trap = trap_map->pick_random_object (rmg_rndm);
386		389
…		…
412	the_chest->y = yl;	415	the_chest->y = yl;
413	insert_ob_in_map (the_chest, map, NULL, 0);	416	insert_ob_in_map (the_chest, map, NULL, 0);
414	return the_chest;	417	return the_chest;
415	}	418	}
416		419
417
418	/* finds the closest monster and returns him, regardless of doors	420	/* finds the closest monster and returns him, regardless of doors or walls */
419	or walls */	421	static object *
420	object *
421	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)
422	{	423	{
423	int i;	424	int i;
424		425
425	for (i = 0; i < SIZEOFFREE; i++)	426	for (i = 0; i < SIZEOFFREE; i++)
…		…
433	/* 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. */
434	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)	435	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
435	{	436	{
436	object *the_monster = GET_MAP_OB (map, lx, ly);	437	object *the_monster = GET_MAP_OB (map, lx, ly);
437		438
438	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);
439	if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))	440	if (the_monster && the_monster->flag [FLAG_MONSTER])
440	return the_monster;	441	return the_monster;
441	}	442	}
442	}	443	}
443	return NULL;	444	return NULL;
444	}	445	}
445		446
446	/* 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. */
447		448
448	object *theMonsterToFind;	449	static object *theMonsterToFind;
449		450
450	/* 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.
451	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 */
452		453	static object *
453	object *
454	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)
455	{	455	{
456	int i, j;	456	int i, j;
457		457
458	/* if we've found a monster already, leave */	458	/* if we've found a monster already, leave */
…		…
473	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)	473	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
474	{	474	{
475	object *the_monster = GET_MAP_OB (map, x, y);	475	object *the_monster = GET_MAP_OB (map, x, y);
476		476
477	/* check off this point */	477	/* check off this point */
478	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);
479	if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))	479	if (the_monster && the_monster->flag [FLAG_ALIVE])
480	{	480	{
481	theMonsterToFind = the_monster;	481	theMonsterToFind = the_monster;
482	return theMonsterToFind;	482	return theMonsterToFind;
483	}	483	}
484	}	484	}
…		…
494	return theMonsterToFind;	494	return theMonsterToFind;
495	}	495	}
496		496
497	/* sets up some data structures: the _recursive form does the	497	/* sets up some data structures: the _recursive form does the
498	real work. */	498	real work. */
499	object *	499	static object *
500	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)
501	{	501	{
502	Layout layout2 (RP);	502	Layout layout2 (map->width, map->height);
503		503
504	layout2->clear ();	504	// find walls
505
506	/* allocate and copy the layout, converting C to 0. */
507	for (int i = 0; i < layout2->w; i++)	505	for (int i = 0; i < layout2.w; i++)
508	for (int j = 0; j < layout2->h; j++)	506	for (int j = 0; j < layout2.h; j++)
509	if (wall_blocked (map, i, j))	507	layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
510	layout2[i][j] = '#';
511		508
512	theMonsterToFind = 0;	509	theMonsterToFind = 0;
513	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);	510	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
514		511
515	layout2.free ();
516
517	return theMonsterToFind;	512	return theMonsterToFind;
518	}	513	}
519		514
520	/* 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 */
521	int *room_free_spots_x;	516	static int *room_free_spots_x;
522	int *room_free_spots_y;	517	static int *room_free_spots_y;
523	int number_of_free_spots_in_room;	518	static int number_of_free_spots_in_room;
524		519
525	/* the workhorse routine, which finds the free spots in a room:	520	/* the workhorse routine, which finds the free spots in a room:
526	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
527	that datastructure. */	522	that datastructure. */
528	void	523	static void
529	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)
530	{	525	{
531	int i, j;	526	int i, j;
532		527
533	/* bounds check x and y */	528	/* bounds check x and y */
…		…
551	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);
552		547
553	}	548	}
554		549
555	/* 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. */
556	void	551	static void
557	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)
558	{	553	{
559	char **layout2;	554	char **layout2;
560	int i, j;	555	int i, j;
561		556
…		…
594		589
595		590
596	/* 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
597	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
598	it'll return 0 if no FREE spots are found.*/	593	it'll return 0 if no FREE spots are found.*/
599	void	594	static void
600	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)
601	{	596	{
602	int x, y;	597	int x, y;
603	int i;	598	int i;
604		599
…		…
609	{	604	{
610	int lx, ly, sindex;	605	int lx, ly, sindex;
611		606
612	lx = x + freearr_x[i];	607	lx = x + freearr_x[i];
613	ly = y + freearr_y[i];	608	ly = y + freearr_y[i];
614	sindex = surround_flag3 (map, lx, ly, RP);	609	sindex = surround_flag3 (map, lx, ly);
615	/* if it's blocked on 3 sides, it's enclosed */	610	/* if it's blocked on 3 sides, it's enclosed */
616	if (sindex == 7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14)	611	if (sindex == 7 \|\| sindex == 11 \|\| sindex == 13 \|\| sindex == 14)
617	{	612	{
618	*cx = lx;	613	*cx = lx;
619	*cy = ly;	614	*cy = ly;
…		…
627	{	622	{
628	int lx, ly, sindex;	623	int lx, ly, sindex;
629		624
630	lx = x + freearr_x[i];	625	lx = x + freearr_x[i];
631	ly = y + freearr_y[i];	626	ly = y + freearr_y[i];
632	sindex = surround_flag3 (map, lx, ly, RP);	627	sindex = surround_flag3 (map, lx, ly);
633	/* if it's blocked on 3 sides, it's enclosed */	628	/* if it's blocked on 3 sides, it's enclosed */
634	if (sindex == 3 \|\| sindex == 5 \|\| sindex == 9 \|\| sindex == 6 \|\| sindex == 10 \|\| sindex == 12)	629	if (sindex == 3 \|\| sindex == 5 \|\| sindex == 9 \|\| sindex == 6 \|\| sindex == 10 \|\| sindex == 12)
635	{	630	{
636	*cx = lx;	631	*cx = lx;
637	*cy = ly;	632	*cy = ly;
…		…
644	{	639	{
645	int lx, ly, sindex;	640	int lx, ly, sindex;
646		641
647	lx = x + freearr_x[i];	642	lx = x + freearr_x[i];
648	ly = y + freearr_y[i];	643	ly = y + freearr_y[i];
649	sindex = surround_flag3 (map, lx, ly, RP);	644	sindex = surround_flag3 (map, lx, ly);
650	/* if it's blocked on 3 sides, it's enclosed */	645	/* if it's blocked on 3 sides, it's enclosed */
651	if (sindex)	646	if (sindex)
652	{	647	{
653	*cx = lx;	648	*cx = lx;
654	*cy = ly;	649	*cy = ly;
655	return;	650	return;
656	}	651	}
657	}	652	}
658	/* give up and return the closest free spot. */	653	/* give up and return the closest free spot. */
659	i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);	654	i = rmg_find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
660		655
661	if (i != -1)	656	if (i != -1)
662	{	657	{
663	*cx = x + freearr_x[i];	658	*cx = x + freearr_x[i];
664	*cy = y + freearr_y[i];	659	*cy = y + freearr_y[i];
…		…
669	*cx = -1;	664	*cx = -1;
670	*cy = -1;	665	*cy = -1;
671	}	666	}
672	}	667	}
673		668
674	void	669	static void
675	remove_monsters (int x, int y, maptile *map)	670	remove_monsters (int x, int y, maptile *map)
676	{	671	{
677	object *tmp;
678
679	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	672	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
680	if (QUERY_FLAG (tmp, FLAG_ALIVE))
681	{	673	{
682	if (tmp->head)	674	object *next = tmp->above;
683	tmp = tmp->head;	675
684	tmp->remove ();	676	if (tmp->flag [FLAG_ALIVE])
685	tmp->destroy ();	677	tmp->head_ ()->destroy ();
686	tmp = GET_MAP_OB (map, x, y);	678
687	if (tmp == NULL)	679	tmp = next;
688	break;
689	};	680	}
690	}	681	}
691		682
692	/* 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
693	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
694	it'll remove any monsters it finds.*/	685	it'll remove any monsters it finds.*/
695	object **	686	static object **
696	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)
697	{	688	{
698	int i;	689	int i;
699	const char *doors[2];	690	const char *doors[2];
700	object **doorlist;	691	object **doorlist;
…		…
730	}	721	}
731		722
732	return doorlist;	723	return doorlist;
733	}	724	}
734		725
735
736	/* 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. */
737	object *	727	static object *
738	door_in_square (maptile *map, int x, int y)	728	door_in_square (maptile *map, int x, int y)
739	{	729	{
740	object *tmp;
741
742	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)
743	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	731	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
744	return tmp;	732	return tmp;
		733
745	return NULL;	734	return NULL;
746	}	735	}
747		736
748	/* the workhorse routine, which finds the doors in a room */	737	/* the workhorse routine, which finds the doors in a room */
749	void	738	static void
750	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)
751	{	740	{
752	int i, j;	741	int i, j;
753	object *door;	742	object *door;
754		743
…		…
789	doorlist, ndoors, RP);	778	doorlist, ndoors, RP);
790	}	779	}
791	}	780	}
792		781
793	/* 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. */
794	object **	783	static object **
795	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)
796	{	785	{
797	int i, j;	786	int i, j;
798	int ndoors = 0;	787	int ndoors = 0;
799		788
800	object doorlist = (object )calloc (sizeof (int), 1024);	789	object doorlist = (object )calloc (sizeof (int), 1024);
801		790
802	LayoutData layout2 (RP->Xsize, RP->Ysize);	791	Layout layout2 (RP->Xsize, RP->Ysize);
803	layout2.clear ();	792	layout2.clear ();
804		793
805	/* allocate and copy the layout, converting C to 0. */	794	/* allocate and copy the layout, converting C to 0. */
806	for (i = 0; i < RP->Xsize; i++)	795	for (i = 0; i < RP->Xsize; i++)
807	for (j = 0; j < RP->Ysize; j++)	796	for (j = 0; j < RP->Ysize; j++)
…		…
813	return doorlist;	802	return doorlist;
814	}	803	}
815		804
816	/* 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
817	opts doesn't say to lock/hide doors. */	806	opts doesn't say to lock/hide doors. */
818	void	807	static void
819	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)
820	{	809	{
821	object *door;	810	object *door;
822	int i;	811	int i;
823		812
824	/* lock the doors and hide the keys. */	813	/* lock the doors and hide the keys. */
825		814
826	if (opts & DOORED)	815	if (opts & DOORED)
827	{	816	{
828	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	817	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
829	{	818	{
830	object *new_door = get_archetype ("locked_door1");	819	object *new_door = get_archetype (shstr_locked_door1);
831		820
832	door = doorlist[i];	821	door = doorlist[i];
833	new_door->face = door->face;	822	new_door->face = door->face;
834	new_door->x = door->x;	823	new_door->x = door->x;
835	new_door->y = door->y;	824	new_door->y = door->y;
836	door->remove ();
837	door->destroy ();	825	door->destroy ();
838	doorlist[i] = new_door;	826	doorlist[i] = new_door;
839	insert_ob_in_map (new_door, map, NULL, 0);	827	insert_ob_in_map (new_door, map, NULL, 0);
840	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));	828	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
841	keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);	829	keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
…		…
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.39 by root, Thu May 8 11:39:24 2008 UTC vs. Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC vs.
Revision 1.56 by root, Fri Jul 2 03:40:14 2010 UTC