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.28 by root, Sun Mar 18 03:05:40 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 = rndm (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 = rndm (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. */
392	dx = RANDOM() % RP->Xsize;	454
393	dy = RANDOM() % RP->Ysize;	455	dx = rndm (RP->Xsize);
		456	dy = rndm (RP->Ysize);
		457
394	cx = can_make_wall(maze,dx,dy,0,RP); /* horizontal */	458	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
395	cy = can_make_wall(maze,dx,dy,1,RP); /* vertical */	459	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
396	if(cx == -1) {	460	if (cx == -1)
		461	{
		462	if (cy != -1)
		463	make_wall (maze, dx, dy, 1);
		464
		465	continue;
		466	}
		467
397	if(cy != -1)	468	if (cy == -1)
		469	{
		470	make_wall (maze, dx, dy, 0);
		471	continue;
		472	}
		473
		474	if (cx < cy)
		475	make_wall (maze, dx, dy, 0);
		476	else
398	make_wall(maze,dx,dy,1);	477	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	}	478	}
408	}	479	}
409		480
410	/* checks the layout to see if I can stick a horizontal(dir = 0) wall	481	/* checks the layout to see if I can stick a horizontal(dir = 0) wall
411	(or vertical, dir == 1)	482	(or vertical, dir == 1)
412	here which ends up on other walls sensibly. */	483	here which ends up on other walls sensibly. */
413		484
		485	int
414	int can_make_wall(char **maze,int dx,int dy,int dir,RMParms *RP) {	486	can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
		487	{
415	int i1;	488	int i1;
416	int length=0;	489	int length = 0;
417		490
418	/* dont make walls if we're on the edge. */	491	/* 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;	492	if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
		493	return -1;
420		494
421	/* don't make walls if we're ON a wall. */	495	/* don't make walls if we're ON a wall. */
422	if(maze[dx][dy]!=0) return -1;	496	if (maze[dx][dy] != 0)
		497	return -1;
423		498
424	if(dir==0) /* horizontal */	499	if (dir == 0) /* horizontal */
425	{	500	{
426	int y = dy;	501	int y = dy;
		502
427	for(i1=dx-1;i1>0;i1--) {	503	for (i1 = dx - 1; i1 > 0; i1--)
		504	{
428	int sindex=surround_flag2(maze,i1,y,RP);	505	int sindex = surround_flag2 (maze, i1, y, RP);
		506
429	if(sindex == 1) break;	507	if (sindex == 1)
		508	break;
		509	if (sindex != 0)
430	if(sindex != 0) return -1; /* can't make horiz. wall here */	510	return -1; /* can't make horiz. wall here */
		511	if (maze[i1][y] != 0)
431	if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */	512	return -1; /* can't make horiz. wall here */
432	length++;	513	length++;
433	}
434		514	}
		515
435	for(i1=dx+1;i1<RP->Xsize-1;i1++) {	516	for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
		517	{
436	int sindex=surround_flag2(maze,i1,y,RP);	518	int sindex = surround_flag2 (maze, i1, y, RP);
		519
437	if(sindex == 2) break;	520	if (sindex == 2)
		521	break;
		522	if (sindex != 0)
438	if(sindex != 0) return -1; /* can't make horiz. wall here */	523	return -1; /* can't make horiz. wall here */
		524	if (maze[i1][y] != 0)
439	if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */	525	return -1; /* can't make horiz. wall here */
440	length++;	526	length++;
441	}	527	}
442	return length;	528	return length;
443	}	529	}
444	else { /* vertical */	530	else
		531	{ /* vertical */
445	int x = dx;	532	int x = dx;
		533
446	for(i1=dy-1;i1>0;i1--) {	534	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		535	{
454	for(i1=dy+1;i1<RP->Ysize-1;i1++) {
455	int sindex=surround_flag2(maze,x,i1,RP);	536	int sindex = surround_flag2 (maze, x, i1, RP);
456	if(sindex == 8) break;	537
		538	if (sindex == 4)
		539	break;
		540	if (sindex != 0)
457	if(sindex != 0) return -1; /* can't make verti. wall here */	541	return -1; /* can't make vert. wall here */
		542	if (maze[x][i1] != 0)
458	if(maze[x][i1]!=0) return -1; /* can't make horiz. wall here */	543	return -1; /* can't make horiz. wall here */
459	length++;	544	length++;
460	}	545	}
		546
		547	for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
		548	{
		549	int sindex = surround_flag2 (maze, x, i1, RP);
		550
		551	if (sindex == 8)
		552	break;
		553	if (sindex != 0)
		554	return -1; /* can't make verti. wall here */
		555	if (maze[x][i1] != 0)
		556	return -1; /* can't make horiz. wall here */
		557	length++;
		558	}
461	return length;	559	return length;
462	}	560	}
463	return -1;	561	return -1;
464	}	562	}
465		563
466		564
		565	int
467	int make_wall(char **maze,int x, int y, int dir){	566	make_wall (char **maze, int x, int y, int dir)
		567	{
468	maze[x][y] = 'D'; /* mark a door */	568	maze[x][y] = 'D'; /* mark a door */
469	switch(dir) {	569	switch (dir)
470	case 0: /* horizontal */
471	{	570	{
		571	case 0: /* horizontal */
		572	{
472	int i1;	573	int i1;
		574
473	for(i1 = x-1;maze[i1][y]==0;i1--)	575	for (i1 = x - 1; maze[i1][y] == 0; i1--)
474	maze[i1][y]='#';	576	maze[i1][y] = '#';
475	for(i1 = x+1;maze[i1][y]==0;i1++)	577	for (i1 = x + 1; maze[i1][y] == 0; i1++)
476	maze[i1][y]='#';	578	maze[i1][y] = '#';
477	break;	579	break;
478	}	580	}
479	case 1: /* vertical */	581	case 1: /* vertical */
480	{	582	{
481	int i1;	583	int i1;
		584
482	for(i1 = y-1;maze[x][i1]==0;i1--)	585	for (i1 = y - 1; maze[x][i1] == 0; i1--)
483	maze[x][i1]='#';	586	maze[x][i1] = '#';
484	for(i1 = y+1;maze[x][i1]==0;i1++)	587	for (i1 = y + 1; maze[x][i1] == 0; i1++)
485	maze[x][i1]='#';	588	maze[x][i1] = '#';
486	break;	589	break;
		590	}
487	}	591	}
488	}
489		592
490	return 0;	593	return 0;
491	}	594	}
492		595
493	/* puts doors at appropriate locations in a layout. */	596	/* puts doors at appropriate locations in a layout. */
494		597	void
495	void doorify_layout(char **maze,RMParms *RP) {	598	doorify_layout (char **maze, random_map_params *RP)
		599	{
496	int ndoors = RP->Xsize*RP->Ysize/60; /* reasonable number of doors. */	600	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
497	char *doorlist_x;	601	char *doorlist_x;
498	char *doorlist_y;	602	char *doorlist_y;
499	int doorlocs = 0; /* # of available doorlocations */	603	int doorlocs = 0; /* # of available doorlocations */
500	int i,j;	604	int i, j;
501		605
502	doorlist_x = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize);	606	doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
503	doorlist_y = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize);	607	doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
504		608
505		609
506	/* make a list of possible door locations */	610	/* make a list of possible door locations */
507	for(i=1;i<RP->Xsize-1;i++)	611	for (i = 1; i < RP->Xsize - 1; i++)
508	for(j=1;j<RP->Ysize-1;j++) {	612	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	{	613	{
526	maze[i][j] = 'D';	614	int sindex = surround_flag (maze, i, j, RP);
527	ndoors--;	615
		616	if (sindex == 3 || sindex == 12) /* these are possible door sindex */
		617	{
		618	doorlist_x[doorlocs] = i;
		619	doorlist_y[doorlocs] = j;
		620	doorlocs++;
		621	}
528	}	622	}
		623
		624	while (ndoors > 0 && doorlocs > 0)
		625	{
		626	int di;
		627	int sindex;
		628
		629	di = rndm (doorlocs);
		630	i = doorlist_x[di];
		631	j = doorlist_y[di];
		632	sindex = surround_flag (maze, i, j, RP);
		633
		634	if (sindex == 3 || sindex == 12) /* these are possible door sindex */
		635	{
		636	maze[i][j] = 'D';
		637	ndoors--;
		638	}
		639
529	/* reduce the size of the list */	640	/* reduce the size of the list */
530	doorlocs--;	641	doorlocs--;
531	doorlist_x[di]=doorlist_x[doorlocs];	642	doorlist_x[di] = doorlist_x[doorlocs];
532	doorlist_y[di]=doorlist_y[doorlocs];	643	doorlist_y[di] = doorlist_y[doorlocs];
533	}	644	}
		645
534	free(doorlist_x);	646	free (doorlist_x);
535	free(doorlist_y);	647	free (doorlist_y);
536	}	648	}
537		649
538		650	void
539	void write_map_parameters_to_string(char *buf,RMParms *RP) {	651	write_map_parameters_to_string (char *buf, random_map_params *RP)
540		652	{
541	char small_buf[256];	653	char small_buf[16384];
		654
542	sprintf(buf,"xsize %d\nysize %d\n",RP->Xsize,RP->Ysize);	655	sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
543		656
544	if(RP->wallstyle[0]) {	657	if (RP->wallstyle[0])
		658	{
545	sprintf(small_buf,"wallstyle %s\n",RP->wallstyle);	659	sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
546	strcat(buf,small_buf);	660	strcat (buf, small_buf);
547	}	661	}
548		662
549	if(RP->floorstyle[0]) {	663	if (RP->floorstyle[0])
		664	{
550	sprintf(small_buf,"floorstyle %s\n",RP->floorstyle);	665	sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
551	strcat(buf,small_buf);	666	strcat (buf, small_buf);
552	}	667	}
553		668
554	if(RP->monsterstyle[0]) {	669	if (RP->monsterstyle[0])
		670	{
555	sprintf(small_buf,"monsterstyle %s\n",RP->monsterstyle);	671	sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
556	strcat(buf,small_buf);	672	strcat (buf, small_buf);
557	}	673	}
558		674
559	if(RP->treasurestyle[0]) {	675	if (RP->treasurestyle[0])
		676	{
560	sprintf(small_buf,"treasurestyle %s\n",RP->treasurestyle);	677	sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
561	strcat(buf,small_buf);	678	strcat (buf, small_buf);
562	}	679	}
563		680
564	if(RP->layoutstyle[0]) {	681	if (RP->layoutstyle[0])
		682	{
565	sprintf(small_buf,"layoutstyle %s\n",RP->layoutstyle);	683	sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
566	strcat(buf,small_buf);	684	strcat (buf, small_buf);
567	}	685	}
568		686
569	if(RP->decorstyle[0]) {	687	if (RP->decorstyle[0])
		688	{
570	sprintf(small_buf,"decorstyle %s\n",RP->decorstyle);	689	sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
571	strcat(buf,small_buf);	690	strcat (buf, small_buf);
572	}	691	}
573		692
574	if(RP->doorstyle[0]) {	693	if (RP->doorstyle[0])
		694	{
575	sprintf(small_buf,"doorstyle %s\n",RP->doorstyle);	695	sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
576	strcat(buf,small_buf);	696	strcat (buf, small_buf);
577	}	697	}
578		698
579	if(RP->exitstyle[0]) {	699	if (RP->exitstyle[0])
		700	{
580	sprintf(small_buf,"exitstyle %s\n",RP->exitstyle);	701	sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
581	strcat(buf,small_buf);	702	strcat (buf, small_buf);
582	}	703	}
583		704
584	if(RP->final_map[0]) {	705	if (RP->final_map.length ())
		706	{
585	sprintf(small_buf,"final_map %s\n",RP->final_map);	707	sprintf (small_buf, "final_map %s\n", &RP->final_map);
586	strcat(buf,small_buf);	708	strcat (buf, small_buf);
587	}	709	}
588		710
589	if(RP->exit_on_final_map[0]) {	711	if (RP->exit_on_final_map[0])
		712	{
590	sprintf(small_buf,"exit_on_final_map %s\n",RP->exit_on_final_map);	713	sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
591	strcat(buf,small_buf);	714	strcat (buf, small_buf);
592	}	715	}
593		716
594	if(RP->this_map[0]) {	717	if (RP->this_map.length ())
		718	{
595	sprintf(small_buf,"origin_map %s\n",RP->this_map);	719	sprintf (small_buf, "origin_map %s\n", &RP->this_map);
596	strcat(buf,small_buf);	720	strcat (buf, small_buf);
597	}	721	}
598		722
599	if(RP->expand2x) {	723	if (RP->expand2x)
		724	{
600	sprintf(small_buf,"expand2x %d\n",RP->expand2x);	725	sprintf (small_buf, "expand2x %d\n", RP->expand2x);
601	strcat(buf,small_buf);	726	strcat (buf, small_buf);
602	}	727	}
603		728
604	if(RP->layoutoptions1) {	729	if (RP->layoutoptions1)
		730	{
605	sprintf(small_buf,"layoutoptions1 %d\n",RP->layoutoptions1);	731	sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
606	strcat(buf,small_buf);	732	strcat (buf, small_buf);
607	}	733	}
608		734
609
610	if(RP->layoutoptions2) {	735	if (RP->layoutoptions2)
		736	{
611	sprintf(small_buf,"layoutoptions2 %d\n",RP->layoutoptions2);	737	sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
612	strcat(buf,small_buf);	738	strcat (buf, small_buf);
613	}	739	}
614		740
615
616	if(RP->layoutoptions3) {	741	if (RP->layoutoptions3)
		742	{
617	sprintf(small_buf,"layoutoptions3 %d\n",RP->layoutoptions3);	743	sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
618	strcat(buf,small_buf);	744	strcat (buf, small_buf);
619	}	745	}
620		746
621	if(RP->symmetry) {	747	if (RP->symmetry)
		748	{
622	sprintf(small_buf,"symmetry %d\n",RP->symmetry);	749	sprintf (small_buf, "symmetry %d\n", RP->symmetry);
623	strcat(buf,small_buf);	750	strcat (buf, small_buf);
624	}	751	}
625		752
626
627	if(RP->difficulty && RP->difficulty_given ) {	753	if (RP->difficulty && RP->difficulty_given)
		754	{
628	sprintf(small_buf,"difficulty %d\n",RP->difficulty);	755	sprintf (small_buf, "difficulty %d\n", RP->difficulty);
629	strcat(buf,small_buf);	756	strcat (buf, small_buf);
630	}	757	}
631		758
632	if(RP->difficulty_increase != 1.0 ) {	759	if (RP->difficulty_increase != 1.0)
		760	{
633	sprintf(small_buf,"difficulty_increase %f\n",RP->difficulty_increase);	761	sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
634	strcat(buf,small_buf);	762	strcat (buf, small_buf);
635	}	763	}
636		764
637	sprintf(small_buf,"dungeon_level %d\n",RP->dungeon_level);	765	sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
638	strcat(buf,small_buf);	766	strcat (buf, small_buf);
639		767
640	if(RP->dungeon_depth) {	768	if (RP->dungeon_depth)
		769	{
641	sprintf(small_buf,"dungeon_depth %d\n",RP->dungeon_depth);	770	sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
642	strcat(buf,small_buf);	771	strcat (buf, small_buf);
643	}	772	}
644		773
645	if(RP->decoroptions) {	774	if (RP->decoroptions)
		775	{
646	sprintf(small_buf,"decoroptions %d\n",RP->decoroptions);	776	sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
647	strcat(buf,small_buf);	777	strcat (buf, small_buf);
648	}	778	}
649		779
650	if(RP->orientation) {	780	if (RP->orientation)
		781	{
651	sprintf(small_buf,"orientation %d\n",RP->orientation);	782	sprintf (small_buf, "orientation %d\n", RP->orientation);
652	strcat(buf,small_buf);	783	strcat (buf, small_buf);
653	}	784	}
654		785
655	if(RP->origin_x) {	786	if (RP->origin_x)
		787	{
656	sprintf(small_buf,"origin_x %d\n",RP->origin_x);	788	sprintf (small_buf, "origin_x %d\n", RP->origin_x);
657	strcat(buf,small_buf);	789	strcat (buf, small_buf);
658	}	790	}
659		791
660	if(RP->origin_y) {	792	if (RP->origin_y)
		793	{
661	sprintf(small_buf,"origin_y %d\n",RP->origin_y);	794	sprintf (small_buf, "origin_y %d\n", RP->origin_y);
662	strcat(buf,small_buf);	795	strcat (buf, small_buf);
663	}	796	}
		797
		798	if (RP->treasureoptions)
		799	{
		800	sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
		801	strcat (buf, small_buf);
		802	}
		803
664	if(RP->random_seed) {	804	if (RP->random_seed)
		805	{
		806	sprintf (small_buf, "random_seed %u\n", RP->random_seed);
		807	strcat (buf, small_buf);
		808	}
		809
		810	if (RP->custom)
		811	{
		812	sprintf (small_buf, "custom %s\n", RP->custom);
		813	strcat (buf, small_buf);
		814	}
		815	}
		816
		817	void
		818	write_parameters_to_string (char *buf,
		819	int xsize_n,
		820	int ysize_n,
		821	const char *wallstyle_n,
		822	const char *floorstyle_n,
		823	const char *monsterstyle_n,
		824	const char *treasurestyle_n,
		825	const char *layoutstyle_n,
		826	const char *decorstyle_n,
		827	const char *doorstyle_n,
		828	const char *exitstyle_n,
		829	const char *final_map_n,
		830	const char *exit_on_final_map_n,
		831	const char *this_map_n,
		832	int layoutoptions1_n,
		833	int layoutoptions2_n,
		834	int layoutoptions3_n,
		835	int symmetry_n,
		836	int dungeon_depth_n,
		837	int dungeon_level_n,
		838	int difficulty_n,
		839	int difficulty_given_n,
		840	int decoroptions_n,
		841	int orientation_n,
		842	int origin_x_n,
		843	int origin_y_n,
		844	uint32_t random_seed_n,
		845	int treasureoptions_n,
		846	float difficulty_increase)
		847	{
		848	char small_buf[16384];
		849
		850	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
		851
		852	if (wallstyle_n && wallstyle_n[0])
		853	{
		854	sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
		855	strcat (buf, small_buf);
		856	}
		857
		858	if (floorstyle_n && floorstyle_n[0])
		859	{
		860	sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
		861	strcat (buf, small_buf);
		862	}
		863
		864	if (monsterstyle_n && monsterstyle_n[0])
		865	{
		866	sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
		867	strcat (buf, small_buf);
		868	}
		869
		870	if (treasurestyle_n && treasurestyle_n[0])
		871	{
		872	sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
		873	strcat (buf, small_buf);
		874	}
		875
		876	if (layoutstyle_n && layoutstyle_n[0])
		877	{
		878	sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
		879	strcat (buf, small_buf);
		880	}
		881
		882	if (decorstyle_n && decorstyle_n[0])
		883	{
		884	sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
		885	strcat (buf, small_buf);
		886	}
		887
		888	if (doorstyle_n && doorstyle_n[0])
		889	{
		890	sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
		891	strcat (buf, small_buf);
		892	}
		893
		894	if (exitstyle_n && exitstyle_n[0])
		895	{
		896	sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
		897	strcat (buf, small_buf);
		898	}
		899
		900	if (final_map_n && final_map_n[0])
		901	{
		902	sprintf (small_buf, "final_map %s\n", final_map_n);
		903	strcat (buf, small_buf);
		904	}
		905
		906	if (exit_on_final_map_n && exit_on_final_map_n[0])
		907	{
		908	sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
		909	strcat (buf, small_buf);
		910	}
		911
		912	if (this_map_n && this_map_n[0])
		913	{
		914	sprintf (small_buf, "origin_map %s\n", this_map_n);
		915	strcat (buf, small_buf);
		916	}
		917
		918	if (layoutoptions1_n)
		919	{
		920	sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
		921	strcat (buf, small_buf);
		922	}
		923
		924	if (layoutoptions2_n)
		925	{
		926	sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
		927	strcat (buf, small_buf);
		928	}
		929
		930
		931	if (layoutoptions3_n)
		932	{
		933	sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
		934	strcat (buf, small_buf);
		935	}
		936
		937	if (symmetry_n)
		938	{
		939	sprintf (small_buf, "symmetry %d\n", symmetry_n);
		940	strcat (buf, small_buf);
		941	}
		942
		943
		944	if (difficulty_n && difficulty_given_n)
		945	{
		946	sprintf (small_buf, "difficulty %d\n", difficulty_n);
		947	strcat (buf, small_buf);
		948	}
		949
		950	if (difficulty_increase > 0.001)
		951	{
		952	sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
		953	strcat (buf, small_buf);
		954	}
		955
		956	sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
		957	strcat (buf, small_buf);
		958
		959	if (dungeon_depth_n)
		960	{
		961	sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
		962	strcat (buf, small_buf);
		963	}
		964
		965	if (decoroptions_n)
		966	{
		967	sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
		968	strcat (buf, small_buf);
		969	}
		970
		971	if (orientation_n)
		972	{
		973	sprintf (small_buf, "orientation %d\n", orientation_n);
		974	strcat (buf, small_buf);
		975	}
		976
		977	if (origin_x_n)
		978	{
		979	sprintf (small_buf, "origin_x %d\n", origin_x_n);
		980	strcat (buf, small_buf);
		981	}
		982
		983	if (origin_y_n)
		984	{
		985	sprintf (small_buf, "origin_y %d\n", origin_y_n);
		986	strcat (buf, small_buf);
		987	}
		988
		989	if (random_seed_n)
		990	{
665	/* Add one so that the next map is a bit different */	991	/* 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);	992	sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
830	strcat(buf,small_buf);	993	strcat (buf, small_buf);
831	}	994	}
832		995
833	if(treasureoptions_n) {	996	if (treasureoptions_n)
		997	{
834	sprintf(small_buf,"treasureoptions %d\n",treasureoptions_n);	998	sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
835	strcat(buf,small_buf);	999	strcat (buf, small_buf);
836	}	1000	}
837
838
839	}	1001	}
840		1002
841	/* copy an object with an inventory... i.e., duplicate the inv too. */	1003	/* copy an object with an inventory... i.e., duplicate the inv too. */
		1004	void
842	void copy_object_with_inv(object *src_ob, object *dest_ob) {	1005	copy_object_with_inv (object *src_ob, object *dest_ob)
		1006	{
843	object *walk,*tmp;	1007	object *walk, *tmp;
844		1008
845	copy_object(src_ob,dest_ob);	1009	src_ob->copy_to (dest_ob);
846		1010
847	for(walk=src_ob->inv;walk!=NULL;walk=walk->below) {	1011	for (walk = src_ob->inv; walk; walk = walk->below)
848	tmp=get_object();	1012	{
849	copy_object(walk,tmp);	1013	tmp = object::create ();
		1014
		1015	walk->copy_to (tmp);
850	insert_ob_in_ob(tmp,dest_ob);	1016	insert_ob_in_ob (tmp, dest_ob);
851	}	1017	}
852	}	1018	}

Diff Legend

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