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

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.13 by root, Sun Dec 31 19:02:24 2006 UTC vs.
Revision 1.46 by root, Fri Mar 26 00:59:21 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/random_map.C (file contents): Revision 1.13 by root, Sun Dec 31 19:02:24 2006 UTC vs. Revision 1.46 by root, Fri Mar 26 00:59:21 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.13 by root, Sun Dec 31 19:02:24 2006 UTC vs.
Revision 1.46 by root, Fri Mar 26 00:59:21 2010 UTC