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.20 by pippijn, Mon Jan 15 21:06:19 2007 UTC

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

Diff Legend

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