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

Diff Legend

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