ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/random_maps/random_map.C

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.17 by pippijn, Sat Jan 6 14:42:30 2007 UTC

1	/*
2	* static char *rcsid_random_map_c =
3	* "$Id: random_map.C,v 1.2 2006/08/29 08:01:36 root Exp $";
4	*/
5
6	/*	1	/*
7	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
8		3
		4	Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	Copyright (C) 2001 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	6	Copyright (C) 1992 Frank Tore Johansen
11		7
12	This program is free software; you can redistribute it and/or modify	8	This program is free software; you can redistribute it and/or modify
13	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
…		…
21		17
22	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
23	along with this program; if not, write to the Free Software	19	along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		21
26	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	The authors can be reached via e-mail at <crossfire@schmorp.de>
27	*/	23	*/
28		24
29	#include <time.h>	25	#include <time.h>
30	#include <stdio.h>	26	#include <stdio.h>
31	#include <global.h>	27	#include <global.h>
…		…
33	#include <room_gen.h>	29	#include <room_gen.h>
34	#include <random_map.h>	30	#include <random_map.h>
35	#include <rproto.h>	31	#include <rproto.h>
36	#include <sproto.h>	32	#include <sproto.h>
37		33
38	void dump_layout(char **layout,RMParms *RP) {	34	void
		35	dump_layout (char **layout, random_map_params *RP)
		36	{
		37	{
39	{ int i,j;	38	int i, j;
		39
40	for(i=0;i<RP->Xsize;i++) {	40	for (i = 0; i < RP->Xsize; i++)
		41	{
41	for(j=0;j<RP->Ysize;j++) {	42	for (j = 0; j < RP->Ysize; j++)
42	if(layout[i][j]==0) layout[i][j]=' ';	43	{
		44	if (layout[i][j] == 0)
		45	layout[i][j] = ' ';
43	printf("%c",layout[i][j]);	46	printf ("%c", layout[i][j]);
44	if(layout[i][j]==' ') layout[i][j]=0;	47	if (layout[i][j] == ' ')
		48	layout[i][j] = 0;
		49	}
		50	printf ("\n");
45	}	51	}
		52	}
46	printf("\n");	53	printf ("\n");
47	}}
48	printf("\n");
49	}	54	}
50	EXTERN FILE *logfile;	55
		56	maptile *
51	mapstruct *generate_random_map(const char *OutFileName, RMParms *RP) {	57	generate_random_map (const char *OutFileName, random_map_params *RP)
		58	{
52	char **layout, buf[HUGE_BUF];	59	char **layout, buf[HUGE_BUF];
53	mapstruct *theMap;	60	maptile *theMap;
54	int i;	61	int i;
55		62
56	/* pick a random seed, or use the one from the input file */	63	/* pick a random seed, or use the one from the input file */
57	if(RP->random_seed == 0)	64	SRANDOM (RP->random_seed ? RP->random_seed + RP->dungeon_level : time (0));
58	RP->random_seed=time(0);
59		65
60	SRANDOM(RP->random_seed);
61
62	write_map_parameters_to_string(buf, RP);	66	write_map_parameters_to_string (buf, RP);
63		67
64	if(RP->difficulty==0) {	68	if (RP->difficulty == 0)
		69	{
65	RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */	70	RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
		71
66	if (RP->difficulty_increase > 0.001) {	72	if (RP->difficulty_increase > 0.001)
67	RP->difficulty = (int)((float)RP->dungeon_level * RP->difficulty_increase);	73	RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
68	if (RP->difficulty < 1) RP->difficulty=1;	74
69	}	75	if (RP->difficulty < 1)
		76	RP->difficulty = 1;
70	}	77	}
71	else	78	else
72	RP->difficulty_given=1;	79	RP->difficulty_given = 1;
73		80
74	if(RP->Xsize<MIN_RANDOM_MAP_SIZE) RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5;	81	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
75	if(RP->Ysize<MIN_RANDOM_MAP_SIZE) RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5;	82	RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
76		83
		84	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
		85	RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
		86
77	if(RP->expand2x > 0) {	87	if (RP->expand2x > 0)
		88	{
78	RP->Xsize /=2;	89	RP->Xsize /= 2;
79	RP->Ysize /=2;	90	RP->Ysize /= 2;
80	}	91	}
81		92
82	layout = layoutgen(RP);	93	layout = layoutgen (RP);
83		94
84	#ifdef RMAP_DEBUG	95	#ifdef RMAP_DEBUG
85	dump_layout(layout,RP);	96	dump_layout (layout, RP);
86	#endif	97	#endif
87		98
88	/* increment these for the current map */	99	/* increment these for the current map */
89	RP->dungeon_level+=1;	100	RP->dungeon_level += 1;
90	/* allow constant-difficulty maps. */	101	/* allow constant-difficulty maps. */
91	/* difficulty+=1; */	102	/* difficulty+=1; */
92		103
93	/* rotate the layout randomly */	104	/* rotate the layout randomly */
94	layout=rotate_layout(layout,RANDOM()%4,RP);	105	layout = rotate_layout (layout, RANDOM () % 4, RP);
95	#ifdef RMAP_DEBUG	106	#ifdef RMAP_DEBUG
96	dump_layout(layout,RP);	107	dump_layout (layout, RP);
97	#endif	108	#endif
98		109
99	/* allocate the map and set the floor */	110	/* allocate the map and set the floor */
100	theMap = make_map_floor(layout,RP->floorstyle,RP);	111	theMap = make_map_floor (layout, RP->floorstyle, RP);
101		112
102	/* set the name of the map. */	113	/* set the name of the map. */
103	strcpy(theMap->path,OutFileName);	114	theMap->path = OutFileName;
104		115
105	/* set region */	116	/* set region */
106	theMap->region=RP->region;	117	theMap->region = RP->region;
107		118
		119	coroapi::cede ();
108	/* create walls unless the wallstyle is "none" */	120	/* create walls unless the wallstyle is "none" */
109	if (strcmp (RP->wallstyle, "none")) {	121	if (strcmp (RP->wallstyle, "none"))
		122	{
110	make_map_walls(theMap,layout,RP->wallstyle,RP);	123	make_map_walls (theMap, layout, RP->wallstyle, RP);
111		124
112	/* place doors unless doorstyle or wallstyle is "none"*/	125	/* place doors unless doorstyle or wallstyle is "none" */
113	if (strcmp (RP->doorstyle, "none"))	126	if (strcmp (RP->doorstyle, "none"))
114	put_doors(theMap,layout,RP->doorstyle,RP);	127	put_doors (theMap, layout, RP->doorstyle, RP);
115
116	}
117		128
		129	}
		130
		131	coroapi::cede ();
118	/* create exits unless the exitstyle is "none" */	132	/* create exits unless the exitstyle is "none" */
119	if (strcmp (RP->exitstyle, "none"))	133	if (strcmp (RP->exitstyle, "none"))
120	place_exits(theMap,layout,RP->exitstyle,RP->orientation,RP);	134	place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
121		135
		136	coroapi::cede ();
122	place_specials_in_map(theMap,layout,RP);	137	place_specials_in_map (theMap, layout, RP);
123		138
		139	coroapi::cede ();
124	/* create monsters unless the monsterstyle is "none" */	140	/* create monsters unless the monsterstyle is "none" */
125	if (strcmp (RP->monsterstyle, "none"))	141	if (strcmp (RP->monsterstyle, "none"))
126	place_monsters(theMap,RP->monsterstyle,RP->difficulty,RP);	142	place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
127		143
		144	coroapi::cede ();
128	/* treasures needs to have a proper difficulty set for the map. */	145	/* treasures needs to have a proper difficulty set for the map. */
129	theMap->difficulty=calculate_difficulty(theMap);	146	theMap->difficulty = theMap->estimate_difficulty ();
130		147
		148	coroapi::cede ();
131	/* create treasure unless the treasurestyle is "none" */	149	/* create treasure unless the treasurestyle is "none" */
132	if (strcmp (RP->treasurestyle, "none"))	150	if (strcmp (RP->treasurestyle, "none"))
133	place_treasure(theMap,layout,RP->treasurestyle,RP->treasureoptions,RP);	151	place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
134		152
		153	coroapi::cede ();
135	/* create decor unless the decorstyle is "none" */	154	/* create decor unless the decorstyle is "none" */
136	if (strcmp (RP->decorstyle, "none"))	155	if (strcmp (RP->decorstyle, "none"))
137	put_decor(theMap,layout,RP->decorstyle,RP->decoroptions,RP);	156	put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
138		157
		158	coroapi::cede ();
139	/* generate treasures, etc. */	159	/* generate treasures, etc. */
140	fix_auto_apply(theMap);	160	theMap->fix_auto_apply ();
141		161
		162	coroapi::cede ();
142	unblock_exits(theMap,layout,RP);	163	unblock_exits (theMap, layout, RP);
143		164
144	/* free the layout */	165	/* free the layout */
145	for(i=0;i<RP->Xsize;i++)	166	for (i = 0; i < RP->Xsize; i++)
146	free(layout[i]);	167	free (layout[i]);
		168
147	free(layout);	169	free (layout);
148		170
149	theMap->msg = strdup_local(buf);	171	theMap->msg = strdup (buf);
150		172	theMap->in_memory = MAP_IN_MEMORY;
		173
151	return theMap;	174	return theMap;
152	}	175	}
153
154		176
155	/* function selects the layout function and gives it whatever	177	/* function selects the layout function and gives it whatever
156	arguments it needs. */	178	arguments it needs. */
157	char **layoutgen(RMParms *RP) {	179	char **
		180	layoutgen (random_map_params *RP)
		181	{
158	char **maze=0;	182	char **maze = 0;
159	int oxsize= RP->Xsize, oysize=RP->Ysize;	183	int oxsize = RP->Xsize, oysize = RP->Ysize;
160		184
161	if(RP->symmetry == RANDOM_SYM)	185	if (RP->symmetry == SYMMETRY_RANDOM)
162	RP->symmetry_used = (RANDOM() % ( XY_SYM))+1;	186	RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
		187	else
163	else RP->symmetry_used = RP->symmetry;	188	RP->symmetry_used = RP->symmetry;
164		189
165	if(RP->symmetry_used==Y_SYM||RP->symmetry_used==XY_SYM) RP->Ysize = RP->Ysize/2+1;	190	if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
166	if(RP->symmetry_used==X_SYM||RP->symmetry_used==XY_SYM) RP->Xsize = RP->Xsize/2+1;	191	RP->Ysize = RP->Ysize / 2 + 1;
		192	if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
		193	RP->Xsize = RP->Xsize / 2 + 1;
167		194
168	if(RP->Xsize<MIN_RANDOM_MAP_SIZE) RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM()%5;	195	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
169	if(RP->Ysize<MIN_RANDOM_MAP_SIZE) RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM()%5;	196	RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
		197	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
		198	RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
170	RP->map_layout_style = 0;	199	RP->map_layout_style = 0;
171		200
172	/* Redo this - there was a lot of redundant code of checking for preset	201	/* Redo this - there was a lot of redundant code of checking for preset
173	* layout style and then random layout style. Instead, figure out	202	* layout style and then random layout style. Instead, figure out
174	* the numeric layoutstyle, so there is only one area that actually	203	* the numeric layoutstyle, so there is only one area that actually
175	* calls the code to make the maps.	204	* calls the code to make the maps.
176	*/	205	*/
177	if(strstr(RP->layoutstyle,"onion")) {	206	if (strstr (RP->layoutstyle, "onion"))
178	RP->map_layout_style = ONION_LAYOUT;	207	RP->map_layout_style = LAYOUT_ONION;
179	}
180		208
181	if(strstr(RP->layoutstyle,"maze")) {	209	if (strstr (RP->layoutstyle, "maze"))
182	RP->map_layout_style = MAZE_LAYOUT;	210	RP->map_layout_style = LAYOUT_MAZE;
183	}
184		211
185	if(strstr(RP->layoutstyle,"spiral")) {	212	if (strstr (RP->layoutstyle, "spiral"))
186	RP->map_layout_style = SPIRAL_LAYOUT;	213	RP->map_layout_style = LAYOUT_SPIRAL;
187	}
188		214
189	if(strstr(RP->layoutstyle,"rogue")) {	215	if (strstr (RP->layoutstyle, "rogue"))
190	RP->map_layout_style = ROGUELIKE_LAYOUT;	216	RP->map_layout_style = LAYOUT_ROGUELIKE;
191	}
192		217
193	if(strstr(RP->layoutstyle,"snake")) {	218	if (strstr (RP->layoutstyle, "snake"))
194	RP->map_layout_style = SNAKE_LAYOUT;	219	RP->map_layout_style = LAYOUT_SNAKE;
195	}
196		220
197	if(strstr(RP->layoutstyle,"squarespiral")) {	221	if (strstr (RP->layoutstyle, "squarespiral"))
198	RP->map_layout_style = SQUARE_SPIRAL_LAYOUT;	222	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
199	}	223
200	/* No style found - choose one ranomdly */	224	/* No style found - choose one ranomdly */
201	if (RP->map_layout_style == 0) {	225	if (RP->map_layout_style == LAYOUT_NONE)
202	RP->map_layout_style = (RANDOM() % NROFLAYOUTS) + 1;	226	RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
203	}
204		227
205	switch(RP->map_layout_style) {	228	switch (RP->map_layout_style)
206		229	{
207	case ONION_LAYOUT:	230	case LAYOUT_ONION:
208	maze = map_gen_onion(RP->Xsize,RP->Ysize,RP->layoutoptions1,RP->layoutoptions2);	231	maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
209	if(!(RANDOM()%3)&& !(RP->layoutoptions1 & OPT_WALLS_ONLY)) roomify_layout(maze,RP);	232	if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
		233	roomify_layout (maze, RP);
210	break;	234	break;
211		235
212	case MAZE_LAYOUT:	236	case LAYOUT_MAZE:
213	maze = maze_gen(RP->Xsize,RP->Ysize,RANDOM()%2);	237	maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
214	if(!(RANDOM()%2)) doorify_layout(maze,RP);	238	if (!(RANDOM () % 2))
		239	doorify_layout (maze, RP);
215	break;	240	break;
216		241
217	case SPIRAL_LAYOUT:	242	case LAYOUT_SPIRAL:
218	maze = map_gen_spiral(RP->Xsize,RP->Ysize,RP->layoutoptions1);	243	maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
219	if(!(RANDOM()%2)) doorify_layout(maze,RP);	244	if (!(RANDOM () % 2))
		245	doorify_layout (maze, RP);
220	break;	246	break;
221		247
222	case ROGUELIKE_LAYOUT:	248	case LAYOUT_ROGUELIKE:
223	/* Don't put symmetry in rogue maps. There isn't much reason to	249	/* Don't put symmetry in rogue maps. There isn't much reason to
224	* do so in the first place (doesn't make it any more interesting),	250	* do so in the first place (doesn't make it any more interesting),
225	* but more importantly, the symmetry code presumes we are symmetrizing	251	* but more importantly, the symmetry code presumes we are symmetrizing
226	* spirals, or maps with lots of passages - making a symmetric rogue	252	* spirals, or maps with lots of passages - making a symmetric rogue
227	* map fails because its likely that the passages the symmetry process	253	* map fails because its likely that the passages the symmetry process
228	* creates may not connect the rooms.	254	* creates may not connect the rooms.
229	*/	255	*/
230	RP->symmetry_used = NO_SYM;	256	RP->symmetry_used = SYMMETRY_NONE;
231	RP->Ysize = oysize;	257	RP->Ysize = oysize;
232	RP->Xsize = oxsize;	258	RP->Xsize = oxsize;
233	maze = roguelike_layout_gen(RP->Xsize,RP->Ysize,RP->layoutoptions1);	259	maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
234	/* no doorifying... done already */	260	/* no doorifying... done already */
235	break;	261	break;
236		262
237	case SNAKE_LAYOUT:	263	case LAYOUT_SNAKE:
238	maze = make_snake_layout(RP->Xsize,RP->Ysize,RP->layoutoptions1);	264	maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
239	if(RANDOM()%2) roomify_layout(maze,RP);	265	if (RANDOM () % 2)
		266	roomify_layout (maze, RP);
240	break;	267	break;
241		268
242	case SQUARE_SPIRAL_LAYOUT:	269	case LAYOUT_SQUARE_SPIRAL:
243	maze = make_square_spiral_layout(RP->Xsize,RP->Ysize,RP->layoutoptions1);	270	maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
244	if(RANDOM()%2) roomify_layout(maze,RP);	271	if (RANDOM () % 2)
		272	roomify_layout (maze, RP);
245	break;	273	break;
246	}	274	}
247		275
248	maze = symmetrize_layout(maze, RP->symmetry_used,RP);	276	maze = symmetrize_layout (maze, RP->symmetry_used, RP);
		277
249	#ifdef RMAP_DEBUG	278	#ifdef RMAP_DEBUG
250	dump_layout(maze,RP);	279	dump_layout (maze, RP);
251	#endif	280	#endif
		281
252	if(RP->expand2x) {	282	if (RP->expand2x)
		283	{
253	maze = expand2x(maze,RP->Xsize,RP->Ysize);	284	maze = expand2x (maze, RP->Xsize, RP->Ysize);
254	RP->Xsize = RP->Xsize * 2 -1;	285	RP->Xsize = RP->Xsize * 2 - 1;
255	RP->Ysize = RP->Ysize * 2 -1;	286	RP->Ysize = RP->Ysize * 2 - 1;
256	}	287	}
		288
257	return maze;	289	return maze;
258	}	290	}
259
260		291
261	/* takes a map and makes it symmetric: adjusts Xsize and	292	/* takes a map and makes it symmetric: adjusts Xsize and
262	Ysize to produce a symmetric map. */	293	Ysize to produce a symmetric map. */
263		294	char **
264	char **symmetrize_layout(char **maze, int sym,RMParms *RP) {	295	symmetrize_layout (char **maze, int sym, random_map_params *RP)
		296	{
265	int i,j;	297	int i, j;
266	char **sym_maze;	298	char **sym_maze;
267	int Xsize_orig,Ysize_orig;	299	int Xsize_orig, Ysize_orig;
		300
268	Xsize_orig = RP->Xsize;	301	Xsize_orig = RP->Xsize;
269	Ysize_orig = RP->Ysize;	302	Ysize_orig = RP->Ysize;
270	RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used.*/	303	RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
271	if(sym == NO_SYM) {	304	if (sym == SYMMETRY_NONE)
		305	{
272	RP->Xsize = Xsize_orig;	306	RP->Xsize = Xsize_orig;
273	RP->Ysize = Ysize_orig;	307	RP->Ysize = Ysize_orig;
274	return maze;	308	return maze;
275	}	309	}
276	/* pick new sizes */	310	/* pick new sizes */
277	RP->Xsize = ((sym==X_SYM||sym==XY_SYM)?RP->Xsize*2-3:RP->Xsize);	311	RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
278	RP->Ysize = ((sym==Y_SYM||sym==XY_SYM)?RP->Ysize*2-3:RP->Ysize);	312	RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
279		313
280	sym_maze = (char **)calloc(sizeof(char*),RP->Xsize);	314	sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
281	for(i=0;i<RP->Xsize;i++)	315	for (i = 0; i < RP->Xsize; i++)
282	sym_maze[i] = (char *)calloc(sizeof(char),RP->Ysize);	316	sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
283		317
284	if(sym==X_SYM)	318	if (sym == SYMMETRY_X)
285	for(i=0;i<RP->Xsize/2+1;i++)	319	for (i = 0; i < RP->Xsize / 2 + 1; i++)
286	for(j=0;j<RP->Ysize;j++) {	320	for (j = 0; j < RP->Ysize; j++)
		321	{
287	sym_maze[i][j] = maze[i][j];	322	sym_maze[i][j] = maze[i][j];
288	sym_maze[RP->Xsize - i-1][j] = maze[i][j];	323	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
289	};	324	};
290	if(sym==Y_SYM)	325	if (sym == SYMMETRY_Y)
291	for(i=0;i<RP->Xsize;i++)	326	for (i = 0; i < RP->Xsize; i++)
292	for(j=0;j<RP->Ysize/2+1;j++) {	327	for (j = 0; j < RP->Ysize / 2 + 1; j++)
		328	{
293	sym_maze[i][j] = maze[i][j];	329	sym_maze[i][j] = maze[i][j];
294	sym_maze[i][RP->Ysize-j-1] = maze[i][j];	330	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
295	}	331	}
296	if(sym==XY_SYM)	332	if (sym == SYMMETRY_XY)
297	for(i=0;i<RP->Xsize/2+1;i++)	333	for (i = 0; i < RP->Xsize / 2 + 1; i++)
298	for(j=0;j<RP->Ysize/2+1;j++) {	334	for (j = 0; j < RP->Ysize / 2 + 1; j++)
		335	{
299	sym_maze[i][j] = maze[i][j];	336	sym_maze[i][j] = maze[i][j];
300	sym_maze[i][RP->Ysize-j-1] = maze[i][j];	337	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
301	sym_maze[RP->Xsize - i-1][j] = maze[i][j];	338	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
302	sym_maze[RP->Xsize - i-1][RP->Ysize-j-1] = maze[i][j];	339	sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];
303	}	340	}
304	/* delete the old maze */	341	/* delete the old maze */
305	for(i=0;i<Xsize_orig;i++)	342	for (i = 0; i < Xsize_orig; i++)
306	free(maze[i]);	343	free (maze[i]);
307	free(maze);	344	free (maze);
308	/* reconnect disjointed spirals */	345	/* reconnect disjointed spirals */
309	if(RP->map_layout_style==SPIRAL_LAYOUT)	346	if (RP->map_layout_style == LAYOUT_SPIRAL)
310	connect_spirals(RP->Xsize,RP->Ysize,sym,sym_maze);	347	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
311	/* reconnect disjointed nethackmazes: the routine for	348	/* reconnect disjointed nethackmazes: the routine for
312	spirals will do the trick?*/	349	spirals will do the trick? */
313	if(RP->map_layout_style==ROGUELIKE_LAYOUT)	350	if (RP->map_layout_style == LAYOUT_ROGUELIKE)
314	connect_spirals(RP->Xsize,RP->Ysize,sym,sym_maze);	351	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
315		352
316	return sym_maze;	353	return sym_maze;
317	}	354	}
318		355
319		356
320	/* takes a map and rotates it. This completes the	357	/* takes a map and rotates it. This completes the
321	onion layouts, making them possibly centered on any wall.	358	onion layouts, making them possibly centered on any wall.
322	It'll modify Xsize and Ysize if they're swapped.	359	It'll modify Xsize and Ysize if they're swapped.
323	*/	360	*/
324		361
		362	char **
325	char ** rotate_layout(char **maze,int rotation,RMParms *RP) {	363	rotate_layout (char **maze, int rotation, random_map_params *RP)
		364	{
326	char **new_maze;	365	char **new_maze;
327	int i,j;	366	int i, j;
328		367
329	switch(rotation) {	368	switch (rotation)
		369	{
330	case 0:	370	case 0:
331	return maze;
332	break;
333	case 2: /* a reflection */
334	{
335	char *newmaze= (char *) malloc(sizeof(char) * RP->Xsize*RP->Ysize);
336	for(i=0;i<RP->Xsize;i++) { /* make a copy */
337	for(j=0;j<RP->Ysize;j++) {
338	newmaze[i * RP->Ysize + j] = maze[i][j];
339	}
340	}
341	for(i=0;i<RP->Xsize;i++) { /* copy a reflection back */
342	for(j=0;j<RP->Ysize;j++) {
343	maze[i][j]= newmaze[(RP->Xsize-i-1)*RP->Ysize + RP->Ysize-j-1];
344	}
345	}
346	free(newmaze);
347	return maze;	371	return maze;
348	break;	372	break;
349	}	373	case 2: /* a reflection */
		374	{
		375	char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
		376
		377	for (i = 0; i < RP->Xsize; i++)
		378	{ /* make a copy */
		379	for (j = 0; j < RP->Ysize; j++)
		380	{
		381	newmaze[i * RP->Ysize + j] = maze[i][j];
		382	}
		383	}
		384	for (i = 0; i < RP->Xsize; i++)
		385	{ /* copy a reflection back */
		386	for (j = 0; j < RP->Ysize; j++)
		387	{
		388	maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
		389	}
		390	}
		391	free (newmaze);
		392	return maze;
		393	break;
		394	}
350	case 1:	395	case 1:
351	case 3:	396	case 3:
		397	{
352	{ int swap;	398	int swap;
353	new_maze = (char **) calloc(sizeof(char *),RP->Ysize);	399	new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
354	for(i=0;i<RP->Ysize;i++) {	400	for (i = 0; i < RP->Ysize; i++)
		401	{
355	new_maze[i] = (char *) calloc(sizeof(char),RP->Xsize);	402	new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
356	}	403	}
357	if(rotation == 1) /* swap x and y */	404	if (rotation == 1) /* swap x and y */
358	for(i=0;i<RP->Xsize;i++)	405	for (i = 0; i < RP->Xsize; i++)
359	for(j=0;j<RP->Ysize;j++)	406	for (j = 0; j < RP->Ysize; j++)
360	new_maze[j][i] = maze[i][j];	407	new_maze[j][i] = maze[i][j];
361		408
362	if(rotation == 3) { /* swap x and y */	409	if (rotation == 3)
		410	{ /* swap x and y */
363	for(i=0;i<RP->Xsize;i++)	411	for (i = 0; i < RP->Xsize; i++)
364	for(j=0;j<RP->Ysize;j++)	412	for (j = 0; j < RP->Ysize; j++)
365	new_maze[j][i] = maze[RP->Xsize -i-1][RP->Ysize - j-1];	413	new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
366	}	414	}
367		415
368	/* delete the old layout */	416	/* delete the old layout */
369	for(i=0;i<RP->Xsize;i++)	417	for (i = 0; i < RP->Xsize; i++)
370	free(maze[i]);	418	free (maze[i]);
371	free(maze);	419	free (maze);
372		420
373	swap = RP->Ysize;	421	swap = RP->Ysize;
374	RP->Ysize = RP->Xsize;	422	RP->Ysize = RP->Xsize;
375	RP->Xsize = swap;	423	RP->Xsize = swap;
376	return new_maze;	424	return new_maze;
377	break;	425	break;
378	}	426	}
379	}	427	}
380	return NULL;	428	return NULL;
381	}	429	}
382		430
383	/* take a layout and make some rooms in it.	431	/* take a layout and make some rooms in it.
384	--works best on onions.*/	432	--works best on onions.*/
385	void roomify_layout(char **maze,RMParms *RP) {	433	void
		434	roomify_layout (char **maze, random_map_params *RP)
		435	{
386	int tries = RP->Xsize*RP->Ysize/30;	436	int tries = RP->Xsize * RP->Ysize / 30;
387	int ti;	437	int ti;
388		438
389	for(ti=0;ti<tries;ti++) {	439	for (ti = 0; ti < tries; ti++)
		440	{
390	int dx,dy; /* starting location for looking at creating a door */	441	int dx, dy; /* starting location for looking at creating a door */
391	int cx,cy; /* results of checking on creating walls. */	442	int cx, cy; /* results of checking on creating walls. */
		443
392	dx = RANDOM() % RP->Xsize;	444	dx = RANDOM () % RP->Xsize;
393	dy = RANDOM() % RP->Ysize;	445	dy = RANDOM () % RP->Ysize;
394	cx = can_make_wall(maze,dx,dy,0,RP); /* horizontal */	446	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
395	cy = can_make_wall(maze,dx,dy,1,RP); /* vertical */	447	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
396	if(cx == -1) {	448	if (cx == -1)
		449	{
		450	if (cy != -1)
		451	make_wall (maze, dx, dy, 1);
		452	continue;
		453	}
397	if(cy != -1)	454	if (cy == -1)
		455	{
		456	make_wall (maze, dx, dy, 0);
		457	continue;
		458	}
		459	if (cx < cy)
		460	make_wall (maze, dx, dy, 0);
		461	else
398	make_wall(maze,dx,dy,1);	462	make_wall (maze, dx, dy, 1);
399	continue;
400	}
401	if(cy == -1) {
402	make_wall(maze,dx,dy,0);
403	continue;
404	}
405	if(cx < cy) make_wall(maze,dx,dy,0);
406	else make_wall(maze,dx,dy,1);
407	}	463	}
408	}	464	}
409		465
410	/* checks the layout to see if I can stick a horizontal(dir = 0) wall	466	/* checks the layout to see if I can stick a horizontal(dir = 0) wall
411	(or vertical, dir == 1)	467	(or vertical, dir == 1)
412	here which ends up on other walls sensibly. */	468	here which ends up on other walls sensibly. */
413		469
		470	int
414	int can_make_wall(char **maze,int dx,int dy,int dir,RMParms *RP) {	471	can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
		472	{
415	int i1;	473	int i1;
416	int length=0;	474	int length = 0;
417		475
418	/* dont make walls if we're on the edge. */	476	/* dont make walls if we're on the edge. */
419	if(dx == 0 || dx == (RP->Xsize -1) || dy == 0 || dy == (RP->Ysize-1)) return -1;	477	if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
		478	return -1;
420		479
421	/* don't make walls if we're ON a wall. */	480	/* don't make walls if we're ON a wall. */
422	if(maze[dx][dy]!=0) return -1;	481	if (maze[dx][dy] != 0)
		482	return -1;
423		483
424	if(dir==0) /* horizontal */	484	if (dir == 0) /* horizontal */
425	{	485	{
426	int y = dy;	486	int y = dy;
		487
427	for(i1=dx-1;i1>0;i1--) {	488	for (i1 = dx - 1; i1 > 0; i1--)
		489	{
428	int sindex=surround_flag2(maze,i1,y,RP);	490	int sindex = surround_flag2 (maze, i1, y, RP);
		491
429	if(sindex == 1) break;	492	if (sindex == 1)
		493	break;
		494	if (sindex != 0)
430	if(sindex != 0) return -1; /* can't make horiz. wall here */	495	return -1; /* can't make horiz. wall here */
		496	if (maze[i1][y] != 0)
431	if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */	497	return -1; /* can't make horiz. wall here */
432	length++;	498	length++;
433	}
434		499	}
		500
435	for(i1=dx+1;i1<RP->Xsize-1;i1++) {	501	for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
		502	{
436	int sindex=surround_flag2(maze,i1,y,RP);	503	int sindex = surround_flag2 (maze, i1, y, RP);
		504
437	if(sindex == 2) break;	505	if (sindex == 2)
		506	break;
		507	if (sindex != 0)
438	if(sindex != 0) return -1; /* can't make horiz. wall here */	508	return -1; /* can't make horiz. wall here */
		509	if (maze[i1][y] != 0)
439	if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */	510	return -1; /* can't make horiz. wall here */
440	length++;	511	length++;
441	}	512	}
442	return length;	513	return length;
443	}	514	}
444	else { /* vertical */	515	else
		516	{ /* vertical */
445	int x = dx;	517	int x = dx;
		518
446	for(i1=dy-1;i1>0;i1--) {	519	for (i1 = dy - 1; i1 > 0; i1--)
447	int sindex=surround_flag2(maze,x,i1,RP);
448	if(sindex == 4) break;
449	if(sindex != 0) return -1; /* can't make vert. wall here */
450	if(maze[x][i1]!=0) return -1; /* can't make horiz. wall here */
451	length++;
452	}
453		520	{
454	for(i1=dy+1;i1<RP->Ysize-1;i1++) {
455	int sindex=surround_flag2(maze,x,i1,RP);	521	int sindex = surround_flag2 (maze, x, i1, RP);
456	if(sindex == 8) break;	522
		523	if (sindex == 4)
		524	break;
		525	if (sindex != 0)
457	if(sindex != 0) return -1; /* can't make verti. wall here */	526	return -1; /* can't make vert. wall here */
		527	if (maze[x][i1] != 0)
458	if(maze[x][i1]!=0) return -1; /* can't make horiz. wall here */	528	return -1; /* can't make horiz. wall here */
459	length++;	529	length++;
460	}	530	}
		531
		532	for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
		533	{
		534	int sindex = surround_flag2 (maze, x, i1, RP);
		535
		536	if (sindex == 8)
		537	break;
		538	if (sindex != 0)
		539	return -1; /* can't make verti. wall here */
		540	if (maze[x][i1] != 0)
		541	return -1; /* can't make horiz. wall here */
		542	length++;
		543	}
461	return length;	544	return length;
462	}	545	}
463	return -1;	546	return -1;
464	}	547	}
465		548
466		549
		550	int
467	int make_wall(char **maze,int x, int y, int dir){	551	make_wall (char **maze, int x, int y, int dir)
		552	{
468	maze[x][y] = 'D'; /* mark a door */	553	maze[x][y] = 'D'; /* mark a door */
469	switch(dir) {	554	switch (dir)
470	case 0: /* horizontal */
471	{	555	{
		556	case 0: /* horizontal */
		557	{
472	int i1;	558	int i1;
		559
473	for(i1 = x-1;maze[i1][y]==0;i1--)	560	for (i1 = x - 1; maze[i1][y] == 0; i1--)
474	maze[i1][y]='#';	561	maze[i1][y] = '#';
475	for(i1 = x+1;maze[i1][y]==0;i1++)	562	for (i1 = x + 1; maze[i1][y] == 0; i1++)
476	maze[i1][y]='#';	563	maze[i1][y] = '#';
477	break;	564	break;
478	}	565	}
479	case 1: /* vertical */	566	case 1: /* vertical */
480	{	567	{
481	int i1;	568	int i1;
		569
482	for(i1 = y-1;maze[x][i1]==0;i1--)	570	for (i1 = y - 1; maze[x][i1] == 0; i1--)
483	maze[x][i1]='#';	571	maze[x][i1] = '#';
484	for(i1 = y+1;maze[x][i1]==0;i1++)	572	for (i1 = y + 1; maze[x][i1] == 0; i1++)
485	maze[x][i1]='#';	573	maze[x][i1] = '#';
486	break;	574	break;
		575	}
487	}	576	}
488	}
489		577
490	return 0;	578	return 0;
491	}	579	}
492		580
493	/* puts doors at appropriate locations in a layout. */	581	/* puts doors at appropriate locations in a layout. */
494		582	void
495	void doorify_layout(char **maze,RMParms *RP) {	583	doorify_layout (char **maze, random_map_params *RP)
		584	{
496	int ndoors = RP->Xsize*RP->Ysize/60; /* reasonable number of doors. */	585	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
497	char *doorlist_x;	586	char *doorlist_x;
498	char *doorlist_y;	587	char *doorlist_y;
499	int doorlocs = 0; /* # of available doorlocations */	588	int doorlocs = 0; /* # of available doorlocations */
500	int i,j;	589	int i, j;
501		590
502	doorlist_x = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize);	591	doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
503	doorlist_y = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize);	592	doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
504		593
505		594
506	/* make a list of possible door locations */	595	/* make a list of possible door locations */
507	for(i=1;i<RP->Xsize-1;i++)	596	for (i = 1; i < RP->Xsize - 1; i++)
508	for(j=1;j<RP->Ysize-1;j++) {	597	for (j = 1; j < RP->Ysize - 1; j++)
509	int sindex = surround_flag(maze,i,j,RP);
510	if(sindex == 3 || sindex == 12) /* these are possible door sindex*/
511	{
512	doorlist_x[doorlocs]=i;
513	doorlist_y[doorlocs]=j;
514	doorlocs++;
515	}
516	}
517	while(ndoors > 0 && doorlocs > 0) {
518	int di;
519	int sindex;
520	di = RANDOM() % doorlocs;
521	i=doorlist_x[di];
522	j=doorlist_y[di];
523	sindex= surround_flag(maze,i,j,RP);
524	if(sindex == 3 || sindex == 12) /* these are possible door sindex*/
525	{	598	{
526	maze[i][j] = 'D';	599	int sindex = surround_flag (maze, i, j, RP);
527	ndoors--;	600
		601	if (sindex == 3 || sindex == 12) /* these are possible door sindex */
		602	{
		603	doorlist_x[doorlocs] = i;
		604	doorlist_y[doorlocs] = j;
		605	doorlocs++;
		606	}
528	}	607	}
		608
		609	while (ndoors > 0 && doorlocs > 0)
		610	{
		611	int di;
		612	int sindex;
		613
		614	di = RANDOM () % doorlocs;
		615	i = doorlist_x[di];
		616	j = doorlist_y[di];
		617	sindex = surround_flag (maze, i, j, RP);
		618	if (sindex == 3 || sindex == 12) /* these are possible door sindex */
		619	{
		620	maze[i][j] = 'D';
		621	ndoors--;
		622	}
529	/* reduce the size of the list */	623	/* reduce the size of the list */
530	doorlocs--;	624	doorlocs--;
531	doorlist_x[di]=doorlist_x[doorlocs];	625	doorlist_x[di] = doorlist_x[doorlocs];
532	doorlist_y[di]=doorlist_y[doorlocs];	626	doorlist_y[di] = doorlist_y[doorlocs];
533	}	627	}
		628
534	free(doorlist_x);	629	free (doorlist_x);
535	free(doorlist_y);	630	free (doorlist_y);
536	}	631	}
537		632
538		633	void
539	void write_map_parameters_to_string(char *buf,RMParms *RP) {	634	write_map_parameters_to_string (char *buf, random_map_params *RP)
540		635	{
541	char small_buf[256];	636	char small_buf[2048];
		637
542	sprintf(buf,"xsize %d\nysize %d\n",RP->Xsize,RP->Ysize);	638	sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
543		639
544	if(RP->wallstyle[0]) {	640	if (RP->wallstyle[0])
		641	{
545	sprintf(small_buf,"wallstyle %s\n",RP->wallstyle);	642	sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
546	strcat(buf,small_buf);	643	strcat (buf, small_buf);
547	}	644	}
548		645
549	if(RP->floorstyle[0]) {	646	if (RP->floorstyle[0])
		647	{
550	sprintf(small_buf,"floorstyle %s\n",RP->floorstyle);	648	sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
551	strcat(buf,small_buf);	649	strcat (buf, small_buf);
552	}	650	}
553		651
554	if(RP->monsterstyle[0]) {	652	if (RP->monsterstyle[0])
		653	{
555	sprintf(small_buf,"monsterstyle %s\n",RP->monsterstyle);	654	sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
556	strcat(buf,small_buf);	655	strcat (buf, small_buf);
557	}	656	}
558		657
559	if(RP->treasurestyle[0]) {	658	if (RP->treasurestyle[0])
		659	{
560	sprintf(small_buf,"treasurestyle %s\n",RP->treasurestyle);	660	sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
561	strcat(buf,small_buf);	661	strcat (buf, small_buf);
562	}	662	}
563		663
564	if(RP->layoutstyle[0]) {	664	if (RP->layoutstyle[0])
		665	{
565	sprintf(small_buf,"layoutstyle %s\n",RP->layoutstyle);	666	sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
566	strcat(buf,small_buf);	667	strcat (buf, small_buf);
567	}	668	}
568		669
569	if(RP->decorstyle[0]) {	670	if (RP->decorstyle[0])
		671	{
570	sprintf(small_buf,"decorstyle %s\n",RP->decorstyle);	672	sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
571	strcat(buf,small_buf);	673	strcat (buf, small_buf);
572	}	674	}
573		675
574	if(RP->doorstyle[0]) {	676	if (RP->doorstyle[0])
		677	{
575	sprintf(small_buf,"doorstyle %s\n",RP->doorstyle);	678	sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
576	strcat(buf,small_buf);	679	strcat (buf, small_buf);
577	}	680	}
578		681
579	if(RP->exitstyle[0]) {	682	if (RP->exitstyle[0])
		683	{
580	sprintf(small_buf,"exitstyle %s\n",RP->exitstyle);	684	sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
581	strcat(buf,small_buf);	685	strcat (buf, small_buf);
582	}	686	}
583		687
584	if(RP->final_map[0]) {	688	if (RP->final_map.length ())
		689	{
585	sprintf(small_buf,"final_map %s\n",RP->final_map);	690	sprintf (small_buf, "final_map %s\n", &RP->final_map);
586	strcat(buf,small_buf);	691	strcat (buf, small_buf);
587	}	692	}
588		693
589	if(RP->exit_on_final_map[0]) {	694	if (RP->exit_on_final_map[0])
		695	{
590	sprintf(small_buf,"exit_on_final_map %s\n",RP->exit_on_final_map);	696	sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
591	strcat(buf,small_buf);	697	strcat (buf, small_buf);
592	}	698	}
593		699
594	if(RP->this_map[0]) {	700	if (RP->this_map.length ())
		701	{
595	sprintf(small_buf,"origin_map %s\n",RP->this_map);	702	sprintf (small_buf, "origin_map %s\n", &RP->this_map);
596	strcat(buf,small_buf);	703	strcat (buf, small_buf);
597	}	704	}
598		705
599	if(RP->expand2x) {	706	if (RP->expand2x)
		707	{
600	sprintf(small_buf,"expand2x %d\n",RP->expand2x);	708	sprintf (small_buf, "expand2x %d\n", RP->expand2x);
601	strcat(buf,small_buf);	709	strcat (buf, small_buf);
602	}	710	}
603		711
604	if(RP->layoutoptions1) {	712	if (RP->layoutoptions1)
		713	{
605	sprintf(small_buf,"layoutoptions1 %d\n",RP->layoutoptions1);	714	sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
606	strcat(buf,small_buf);	715	strcat (buf, small_buf);
607	}	716	}
608		717
609
610	if(RP->layoutoptions2) {	718	if (RP->layoutoptions2)
		719	{
611	sprintf(small_buf,"layoutoptions2 %d\n",RP->layoutoptions2);	720	sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
612	strcat(buf,small_buf);	721	strcat (buf, small_buf);
613	}	722	}
614		723
615
616	if(RP->layoutoptions3) {	724	if (RP->layoutoptions3)
		725	{
617	sprintf(small_buf,"layoutoptions3 %d\n",RP->layoutoptions3);	726	sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
618	strcat(buf,small_buf);	727	strcat (buf, small_buf);
619	}	728	}
620		729
621	if(RP->symmetry) {	730	if (RP->symmetry)
		731	{
622	sprintf(small_buf,"symmetry %d\n",RP->symmetry);	732	sprintf (small_buf, "symmetry %d\n", RP->symmetry);
623	strcat(buf,small_buf);	733	strcat (buf, small_buf);
624	}	734	}
625		735
626
627	if(RP->difficulty && RP->difficulty_given ) {	736	if (RP->difficulty && RP->difficulty_given)
		737	{
628	sprintf(small_buf,"difficulty %d\n",RP->difficulty);	738	sprintf (small_buf, "difficulty %d\n", RP->difficulty);
629	strcat(buf,small_buf);	739	strcat (buf, small_buf);
630	}	740	}
631		741
632	if(RP->difficulty_increase != 1.0 ) {	742	if (RP->difficulty_increase != 1.0)
		743	{
633	sprintf(small_buf,"difficulty_increase %f\n",RP->difficulty_increase);	744	sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
634	strcat(buf,small_buf);	745	strcat (buf, small_buf);
635	}	746	}
636		747
637	sprintf(small_buf,"dungeon_level %d\n",RP->dungeon_level);	748	sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
638	strcat(buf,small_buf);	749	strcat (buf, small_buf);
639		750
640	if(RP->dungeon_depth) {	751	if (RP->dungeon_depth)
		752	{
641	sprintf(small_buf,"dungeon_depth %d\n",RP->dungeon_depth);	753	sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
642	strcat(buf,small_buf);	754	strcat (buf, small_buf);
643	}	755	}
644		756
645	if(RP->decoroptions) {	757	if (RP->decoroptions)
		758	{
646	sprintf(small_buf,"decoroptions %d\n",RP->decoroptions);	759	sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
647	strcat(buf,small_buf);	760	strcat (buf, small_buf);
648	}	761	}
649		762
650	if(RP->orientation) {	763	if (RP->orientation)
		764	{
651	sprintf(small_buf,"orientation %d\n",RP->orientation);	765	sprintf (small_buf, "orientation %d\n", RP->orientation);
652	strcat(buf,small_buf);	766	strcat (buf, small_buf);
653	}	767	}
654		768
655	if(RP->origin_x) {	769	if (RP->origin_x)
		770	{
656	sprintf(small_buf,"origin_x %d\n",RP->origin_x);	771	sprintf (small_buf, "origin_x %d\n", RP->origin_x);
657	strcat(buf,small_buf);	772	strcat (buf, small_buf);
658	}	773	}
659		774
660	if(RP->origin_y) {	775	if (RP->origin_y)
		776	{
661	sprintf(small_buf,"origin_y %d\n",RP->origin_y);	777	sprintf (small_buf, "origin_y %d\n", RP->origin_y);
662	strcat(buf,small_buf);	778	strcat (buf, small_buf);
663	}	779	}
		780
		781	if (RP->treasureoptions)
		782	{
		783	sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
		784	strcat (buf, small_buf);
		785	}
		786
664	if(RP->random_seed) {	787	if (RP->random_seed)
		788	{
		789	sprintf (small_buf, "random_seed %d\n", RP->random_seed);
		790	strcat (buf, small_buf);
		791	}
		792	}
		793
		794	void
		795	write_parameters_to_string (char *buf,
		796	int xsize_n,
		797	int ysize_n,
		798	char *wallstyle_n,
		799	char *floorstyle_n,
		800	char *monsterstyle_n,
		801	char *treasurestyle_n,
		802	char *layoutstyle_n,
		803	char *decorstyle_n,
		804	char *doorstyle_n,
		805	char *exitstyle_n,
		806	char *final_map_n,
		807	char *exit_on_final_map_n,
		808	char *this_map_n,
		809	int layoutoptions1_n,
		810	int layoutoptions2_n,
		811	int layoutoptions3_n,
		812	int symmetry_n,
		813	int dungeon_depth_n,
		814	int dungeon_level_n,
		815	int difficulty_n,
		816	int difficulty_given_n,
		817	int decoroptions_n,
		818	int orientation_n,
		819	int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
		820	{
		821	char small_buf[2048];
		822
		823	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
		824
		825	if (wallstyle_n && wallstyle_n[0])
		826	{
		827	sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
		828	strcat (buf, small_buf);
		829	}
		830
		831	if (floorstyle_n && floorstyle_n[0])
		832	{
		833	sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
		834	strcat (buf, small_buf);
		835	}
		836
		837	if (monsterstyle_n && monsterstyle_n[0])
		838	{
		839	sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
		840	strcat (buf, small_buf);
		841	}
		842
		843	if (treasurestyle_n && treasurestyle_n[0])
		844	{
		845	sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
		846	strcat (buf, small_buf);
		847	}
		848
		849	if (layoutstyle_n && layoutstyle_n[0])
		850	{
		851	sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
		852	strcat (buf, small_buf);
		853	}
		854
		855	if (decorstyle_n && decorstyle_n[0])
		856	{
		857	sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
		858	strcat (buf, small_buf);
		859	}
		860
		861	if (doorstyle_n && doorstyle_n[0])
		862	{
		863	sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
		864	strcat (buf, small_buf);
		865	}
		866
		867	if (exitstyle_n && exitstyle_n[0])
		868	{
		869	sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
		870	strcat (buf, small_buf);
		871	}
		872
		873	if (final_map_n && final_map_n[0])
		874	{
		875	sprintf (small_buf, "final_map %s\n", final_map_n);
		876	strcat (buf, small_buf);
		877	}
		878
		879	if (exit_on_final_map_n && exit_on_final_map_n[0])
		880	{
		881	sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
		882	strcat (buf, small_buf);
		883	}
		884
		885	if (this_map_n && this_map_n[0])
		886	{
		887	sprintf (small_buf, "origin_map %s\n", this_map_n);
		888	strcat (buf, small_buf);
		889	}
		890
		891	if (layoutoptions1_n)
		892	{
		893	sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
		894	strcat (buf, small_buf);
		895	}
		896
		897	if (layoutoptions2_n)
		898	{
		899	sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
		900	strcat (buf, small_buf);
		901	}
		902
		903
		904	if (layoutoptions3_n)
		905	{
		906	sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
		907	strcat (buf, small_buf);
		908	}
		909
		910	if (symmetry_n)
		911	{
		912	sprintf (small_buf, "symmetry %d\n", symmetry_n);
		913	strcat (buf, small_buf);
		914	}
		915
		916
		917	if (difficulty_n && difficulty_given_n)
		918	{
		919	sprintf (small_buf, "difficulty %d\n", difficulty_n);
		920	strcat (buf, small_buf);
		921	}
		922
		923	if (difficulty_increase > 0.001)
		924	{
		925	sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
		926	strcat (buf, small_buf);
		927	}
		928
		929	sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
		930	strcat (buf, small_buf);
		931
		932	if (dungeon_depth_n)
		933	{
		934	sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
		935	strcat (buf, small_buf);
		936	}
		937
		938	if (decoroptions_n)
		939	{
		940	sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
		941	strcat (buf, small_buf);
		942	}
		943
		944	if (orientation_n)
		945	{
		946	sprintf (small_buf, "orientation %d\n", orientation_n);
		947	strcat (buf, small_buf);
		948	}
		949
		950	if (origin_x_n)
		951	{
		952	sprintf (small_buf, "origin_x %d\n", origin_x_n);
		953	strcat (buf, small_buf);
		954	}
		955
		956	if (origin_y_n)
		957	{
		958	sprintf (small_buf, "origin_y %d\n", origin_y_n);
		959	strcat (buf, small_buf);
		960	}
		961
		962	if (random_seed_n)
		963	{
665	/* Add one so that the next map is a bit different */	964	/* Add one so that the next map is a bit different */
666	sprintf(small_buf,"random_seed %d\n",RP->random_seed + 1);
667	strcat(buf,small_buf);
668	}
669
670	if(RP->treasureoptions) {
671	sprintf(small_buf,"treasureoptions %d\n",RP->treasureoptions);
672	strcat(buf,small_buf);
673	}
674
675
676	}
677
678	void write_parameters_to_string(char *buf,
679	int xsize_n,
680	int ysize_n,
681	char *wallstyle_n,
682	char *floorstyle_n,
683	char *monsterstyle_n,
684	char *treasurestyle_n,
685	char *layoutstyle_n,
686	char *decorstyle_n,
687	char *doorstyle_n,
688	char *exitstyle_n,
689	char *final_map_n,
690	char *exit_on_final_map_n,
691	char *this_map_n,
692	int layoutoptions1_n,
693	int layoutoptions2_n,
694	int layoutoptions3_n,
695	int symmetry_n,
696	int dungeon_depth_n,
697	int dungeon_level_n,
698	int difficulty_n,
699	int difficulty_given_n,
700	int decoroptions_n,
701	int orientation_n,
702	int origin_x_n,
703	int origin_y_n,
704	int random_seed_n,
705	int treasureoptions_n,
706	float difficulty_increase)
707	{
708
709	char small_buf[256];
710	sprintf(buf,"xsize %d\nysize %d\n",xsize_n,ysize_n);
711
712	if(wallstyle_n && wallstyle_n[0]) {
713	sprintf(small_buf,"wallstyle %s\n",wallstyle_n);
714	strcat(buf,small_buf);
715	}
716
717	if(floorstyle_n && floorstyle_n[0]) {
718	sprintf(small_buf,"floorstyle %s\n",floorstyle_n);
719	strcat(buf,small_buf);
720	}
721
722	if(monsterstyle_n && monsterstyle_n[0]) {
723	sprintf(small_buf,"monsterstyle %s\n",monsterstyle_n);
724	strcat(buf,small_buf);
725	}
726
727	if(treasurestyle_n && treasurestyle_n[0]) {
728	sprintf(small_buf,"treasurestyle %s\n",treasurestyle_n);
729	strcat(buf,small_buf);
730	}
731
732	if(layoutstyle_n &&layoutstyle_n[0]) {
733	sprintf(small_buf,"layoutstyle %s\n",layoutstyle_n);
734	strcat(buf,small_buf);
735	}
736
737	if(decorstyle_n && decorstyle_n[0]) {
738	sprintf(small_buf,"decorstyle %s\n",decorstyle_n);
739	strcat(buf,small_buf);
740	}
741
742	if(doorstyle_n && doorstyle_n[0]) {
743	sprintf(small_buf,"doorstyle %s\n",doorstyle_n);
744	strcat(buf,small_buf);
745	}
746
747	if(exitstyle_n && exitstyle_n[0]) {
748	sprintf(small_buf,"exitstyle %s\n",exitstyle_n);
749	strcat(buf,small_buf);
750	}
751
752	if(final_map_n && final_map_n[0]) {
753	sprintf(small_buf,"final_map %s\n",final_map_n);
754	strcat(buf,small_buf);
755	}
756
757	if(exit_on_final_map_n && exit_on_final_map_n[0]) {
758	sprintf(small_buf,"exit_on_final_map %s\n",exit_on_final_map_n);
759	strcat(buf,small_buf);
760	}
761
762	if(this_map_n && this_map_n[0]) {
763	sprintf(small_buf,"origin_map %s\n",this_map_n);
764	strcat(buf,small_buf);
765	}
766
767	if(layoutoptions1_n) {
768	sprintf(small_buf,"layoutoptions1 %d\n",layoutoptions1_n);
769	strcat(buf,small_buf);
770	}
771
772
773	if(layoutoptions2_n) {
774	sprintf(small_buf,"layoutoptions2 %d\n",layoutoptions2_n);
775	strcat(buf,small_buf);
776	}
777
778
779	if(layoutoptions3_n) {
780	sprintf(small_buf,"layoutoptions3 %d\n",layoutoptions3_n);
781	strcat(buf,small_buf);
782	}
783
784	if(symmetry_n) {
785	sprintf(small_buf,"symmetry %d\n",symmetry_n);
786	strcat(buf,small_buf);
787	}
788
789
790	if(difficulty_n && difficulty_given_n ) {
791	sprintf(small_buf,"difficulty %d\n",difficulty_n);
792	strcat(buf,small_buf);
793	}
794
795	if(difficulty_increase > 0.001 ) {
796	sprintf(small_buf,"difficulty_increase %f\n",difficulty_increase);
797	strcat(buf,small_buf);
798	}
799
800	sprintf(small_buf,"dungeon_level %d\n",dungeon_level_n);
801	strcat(buf,small_buf);
802
803	if(dungeon_depth_n) {
804	sprintf(small_buf,"dungeon_depth %d\n",dungeon_depth_n);
805	strcat(buf,small_buf);
806	}
807
808	if(decoroptions_n) {
809	sprintf(small_buf,"decoroptions %d\n",decoroptions_n);
810	strcat(buf,small_buf);
811	}
812
813	if(orientation_n) {
814	sprintf(small_buf,"orientation %d\n",orientation_n);
815	strcat(buf,small_buf);
816	}
817
818	if(origin_x_n) {
819	sprintf(small_buf,"origin_x %d\n",origin_x_n);
820	strcat(buf,small_buf);
821	}
822
823	if(origin_y_n) {
824	sprintf(small_buf,"origin_y %d\n",origin_y_n);
825	strcat(buf,small_buf);
826	}
827	if(random_seed_n) {
828	/* Add one so that the next map is a bit different */
829	sprintf(small_buf,"random_seed %d\n",random_seed_n + 1);	965	sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
830	strcat(buf,small_buf);	966	strcat (buf, small_buf);
831	}	967	}
832		968
833	if(treasureoptions_n) {	969	if (treasureoptions_n)
		970	{
834	sprintf(small_buf,"treasureoptions %d\n",treasureoptions_n);	971	sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
835	strcat(buf,small_buf);	972	strcat (buf, small_buf);
836	}	973	}
837
838
839	}	974	}
840		975
841	/* copy an object with an inventory... i.e., duplicate the inv too. */	976	/* copy an object with an inventory... i.e., duplicate the inv too. */
		977	void
842	void copy_object_with_inv(object *src_ob, object *dest_ob) {	978	copy_object_with_inv (object *src_ob, object *dest_ob)
		979	{
843	object *walk,*tmp;	980	object *walk, *tmp;
844		981
845	copy_object(src_ob,dest_ob);	982	src_ob->copy_to (dest_ob);
846		983
847	for(walk=src_ob->inv;walk!=NULL;walk=walk->below) {	984	for (walk = src_ob->inv; walk; walk = walk->below)
848	tmp=get_object();	985	{
849	copy_object(walk,tmp);	986	tmp = object::create ();
		987
		988	walk->copy_to (tmp);
850	insert_ob_in_ob(tmp,dest_ob);	989	insert_ob_in_ob (tmp, dest_ob);
851	}	990	}
852	}	991	}

Diff Legend

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