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

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.26 by root, Thu Jan 25 03:54:45 2007 UTC vs.
Revision 1.33 by root, Mon Apr 14 22:41:17 2008 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	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,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 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
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your 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 GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	#include <time.h>	24	#include <time.h>
26	#include <stdio.h>	25	#include <stdio.h>
27	#include <global.h>	26	#include <global.h>
28	#include <maze_gen.h>
29	#include <room_gen.h>
30	#include <random_map.h>	27	#include <random_map.h>
31	#include <rproto.h>	28	#include <rproto.h>
32	#include <sproto.h>	29	#include <sproto.h>
33		30
34	#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__);	31	#define CEDE coroapi::cede_to_tick (); rndm.seed (RP->random_seed + __LINE__);
		32
		33	static void symmetrize_layout (Maze maze, random_map_params *RP);
		34	static void rotate_layout (Maze maze, int rotation);
35		35
36	void	36	void
37	dump_layout (char *layout, random_map_params RP)	37	dump_layout (char *layout, random_map_params RP)
38	{	38	{
39	{	39	{
56	}	56	}
57		57
58	bool	58	bool
59	maptile::generate_random_map (random_map_params *RP)	59	maptile::generate_random_map (random_map_params *RP)
60	{	60	{
61	char **layout, buf[16384];	61	char buf[16384];
62	int i;	62	int i;
63		63
64	RP->Xsize = RP->xsize;	64	RP->Xsize = RP->xsize;
65	RP->Ysize = RP->ysize;	65	RP->Ysize = RP->ysize;
66		66
…		…
90		90
91	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)	91	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
92	RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;	92	RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
93		93
94	if (RP->symmetry == SYMMETRY_RANDOM)	94	if (RP->symmetry == SYMMETRY_RANDOM)
95	RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;	95	RP->symmetry_used = rndm (SYMMETRY_XY) + 1;
96	else	96	else
97	RP->symmetry_used = RP->symmetry;	97	RP->symmetry_used = RP->symmetry;
98		98
99	if (RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY)	99	if (RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY)
100	RP->Ysize = RP->Ysize / 2 + 1;	100	RP->Ysize = RP->Ysize / 2 + 1;
…		…
133	if (strstr (RP->layoutstyle, "squarespiral"))	133	if (strstr (RP->layoutstyle, "squarespiral"))
134	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;	134	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
135		135
136	/* No style found - choose one randomly */	136	/* No style found - choose one randomly */
137	if (RP->map_layout_style == LAYOUT_NONE)	137	if (RP->map_layout_style == LAYOUT_NONE)
138	RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;	138	RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1;
139		139
140	layout = layoutgen (RP);	140	Maze layout = layoutgen (RP);
141		141
142	#ifdef RMAP_DEBUG	142	#ifdef RMAP_DEBUG
143	dump_layout (layout, RP);	143	dump_layout (layout, RP);
144	#endif	144	#endif
145		145
…		…
147	RP->dungeon_level += 1;	147	RP->dungeon_level += 1;
148	/* allow constant-difficulty maps. */	148	/* allow constant-difficulty maps. */
149	/* difficulty+=1; */	149	/* difficulty+=1; */
150		150
151	/* rotate the layout randomly */	151	/* rotate the layout randomly */
152	layout = rotate_layout (layout, rndm (4), RP);	152	rotate_layout (layout, rndm (4));
153	#ifdef RMAP_DEBUG	153	#ifdef RMAP_DEBUG
154	dump_layout (layout, RP);	154	dump_layout (layout, RP);
155	#endif	155	#endif
156		156
		157	// need to patch RP becasue following code doesn't use the Maze object
		158	RP->Xsize = layout->w;
		159	RP->Ysize = layout->h;
		160
157	/* allocate the map and set the floor */	161	/* allocate the map and set the floor */
158	make_map_floor (layout, RP->floorstyle, RP);	162	make_map_floor (layout, RP->floorstyle, RP);
159		163
160	/* set region */	164	/* set region */
161	default_region = RP->region;	165	default_region = RP->region;
…		…
212		216
213	CEDE;	217	CEDE;
214		218
215	unblock_exits (this, layout, RP);	219	unblock_exits (this, layout, RP);
216		220
217	/* free the layout */	221	layout.free ();
218	for (i = 0; i < RP->Xsize; i++)
219	free (layout[i]);
220
221	free (layout);
222		222
223	msg = strdup (buf);	223	msg = strdup (buf);
224	in_memory = MAP_IN_MEMORY;	224	in_memory = MAP_IN_MEMORY;
225		225
226	CEDE;	226	CEDE;
…		…
228	return 1;	228	return 1;
229	}	229	}
230		230
231	/* function selects the layout function and gives it whatever	231	/* function selects the layout function and gives it whatever
232	arguments it needs. */	232	arguments it needs. */
233	char **	233	Maze
234	layoutgen (random_map_params *RP)	234	layoutgen (random_map_params *RP)
235	{	235	{
236	char **maze = 0;	236	Maze maze (RP);
237	int oxsize = RP->Xsize, oysize = RP->Ysize;
238		237
239	switch (RP->map_layout_style)	238	switch (RP->map_layout_style)
240	{	239	{
241	case LAYOUT_ONION:	240	case LAYOUT_ONION:
242	maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);	241	map_gen_onion (maze, RP->layoutoptions1, RP->layoutoptions2);
		242
243	if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))	243	if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
244	roomify_layout (maze, RP);	244	roomify_layout (maze, RP);
		245
245	break;	246	break;
246		247
247	case LAYOUT_MAZE:	248	case LAYOUT_MAZE:
248	maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));	249	maze_gen (maze, rndm (2));
		250
249	if (!(rndm (2)))	251	if (!(rndm (2)))
250	doorify_layout (maze, RP);	252	doorify_layout (maze, RP);
		253
251	break;	254	break;
252		255
253	case LAYOUT_SPIRAL:	256	case LAYOUT_SPIRAL:
254	maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);	257	map_gen_spiral (maze, RP->layoutoptions1);
		258
255	if (!(rndm (2)))	259	if (!(rndm (2)))
256	doorify_layout (maze, RP);	260	doorify_layout (maze, RP);
		261
257	break;	262	break;
258		263
259	case LAYOUT_ROGUELIKE:	264	case LAYOUT_ROGUELIKE:
260	/* Don't put symmetry in rogue maps. There isn't much reason to	265	/* Don't put symmetry in rogue maps. There isn't much reason to
261	* do so in the first place (doesn't make it any more interesting),	266	* do so in the first place (doesn't make it any more interesting),
…		…
263	* spirals, or maps with lots of passages - making a symmetric rogue	268	* spirals, or maps with lots of passages - making a symmetric rogue
264	* map fails because its likely that the passages the symmetry process	269	* map fails because its likely that the passages the symmetry process
265	* creates may not connect the rooms.	270	* creates may not connect the rooms.
266	*/	271	*/
267	RP->symmetry_used = SYMMETRY_NONE;	272	RP->symmetry_used = SYMMETRY_NONE;
268	RP->Ysize = oysize;
269	RP->Xsize = oxsize;
270	maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);	273	roguelike_layout_gen (maze, RP->layoutoptions1);
271	/* no doorifying... done already */	274	/* no doorifying... done already */
272	break;	275	break;
273		276
274	case LAYOUT_SNAKE:	277	case LAYOUT_SNAKE:
275	maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);	278	make_snake_layout (maze, RP->layoutoptions1);
		279
276	if (rndm (2))	280	if (rndm (2))
277	roomify_layout (maze, RP);	281	roomify_layout (maze, RP);
		282
278	break;	283	break;
279		284
280	case LAYOUT_SQUARE_SPIRAL:	285	case LAYOUT_SQUARE_SPIRAL:
281	maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);	286	make_square_spiral_layout (maze, RP->layoutoptions1);
		287
282	if (rndm (2))	288	if (rndm (2))
283	roomify_layout (maze, RP);	289	roomify_layout (maze, RP);
		290
284	break;	291	break;
285	}
286		292
287	maze = symmetrize_layout (maze, RP->symmetry_used, RP);	293	default:
		294	abort ();
		295	}
		296
		297	symmetrize_layout (maze, RP);
288		298
289	#ifdef RMAP_DEBUG	299	#ifdef RMAP_DEBUG
290	dump_layout (maze, RP);	300	dump_layout (maze, RP);
291	#endif	301	#endif
292		302
293	if (RP->expand2x)	303	if (RP->expand2x)
294	{	304	expand2x (maze);
295	maze = expand2x (maze, RP->Xsize, RP->Ysize);
296	RP->Xsize = RP->Xsize * 2 - 1;
297	RP->Ysize = RP->Ysize * 2 - 1;
298	}
299		305
300	return maze;	306	return maze;
301	}	307	}
302		308
303	/* takes a map and makes it symmetric: adjusts Xsize and	309	/* takes a map and makes it symmetric: adjusts Xsize and
304	Ysize to produce a symmetric map. */	310	Ysize to produce a symmetric map. */
305	char **	311	static void
306	symmetrize_layout (char *maze, int sym, random_map_params RP)	312	symmetrize_layout (Maze maze, random_map_params *RP)
307	{	313	{
308	int i, j;
309	char **sym_maze;
310	int Xsize_orig, Ysize_orig;
311
312	Xsize_orig = RP->Xsize;
313	Ysize_orig = RP->Ysize;
314	RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
315	if (sym == SYMMETRY_NONE)	314	if (RP->symmetry_used == SYMMETRY_NONE)
316	{
317	RP->Xsize = Xsize_orig;
318	RP->Ysize = Ysize_orig;
319	return maze;	315	return;
320	}
321	/* pick new sizes */
322	RP->Xsize = ((sym == SYMMETRY_X \|\| sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
323	RP->Ysize = ((sym == SYMMETRY_Y \|\| sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
324		316
325	sym_maze = (char *) calloc (sizeof (char ), RP->Xsize);	317	Maze sym_maze (
326	for (i = 0; i < RP->Xsize; i++)	318	RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY ? maze->w * 2 - 3 : maze->w,
327	sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);	319	RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY ? maze->h * 2 - 3 : maze->h
		320	);
328		321
329	if (sym == SYMMETRY_X)	322	if (RP->symmetry_used == SYMMETRY_X)
330	for (i = 0; i < RP->Xsize / 2 + 1; i++)	323	for (int i = 0; i < sym_maze->w / 2 + 1; i++)
331	for (j = 0; j < RP->Ysize; j++)	324	for (int j = 0; j < sym_maze->h; j++)
332	{	325	{
		326	sym_maze[i ][j] =
333	sym_maze[i][j] = maze[i][j];	327	sym_maze[sym_maze->w - i - 1][j] = maze[i][j];
334	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
335	};	328	}
		329
336	if (sym == SYMMETRY_Y)	330	if (RP->symmetry_used == SYMMETRY_Y)
337	for (i = 0; i < RP->Xsize; i++)	331	for (int i = 0; i < sym_maze->w; i++)
338	for (j = 0; j < RP->Ysize / 2 + 1; j++)	332	for (int j = 0; j < sym_maze->h / 2 + 1; j++)
339	{
340	sym_maze[i][j] = maze[i][j];
341	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
342	}	333	{
343	if (sym == SYMMETRY_XY)	334	sym_maze[i][j ] =
344	for (i = 0; i < RP->Xsize / 2 + 1; i++)	335	sym_maze[i][sym_maze->h - j - 1] = maze[i][j];
345	for (j = 0; j < RP->Ysize / 2 + 1; j++)
346	{	336	}
347	sym_maze[i][j] = maze[i][j];	337
348	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];	338	if (RP->symmetry_used == SYMMETRY_XY)
349	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];	339	for (int i = 0; i < sym_maze->w / 2 + 1; i++)
350	sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];	340	for (int j = 0; j < sym_maze->h / 2 + 1; j++)
351	}	341	{
352	/* delete the old maze */	342	sym_maze[i ][j ] =
353	for (i = 0; i < Xsize_orig; i++)	343	sym_maze[i ][sym_maze->h - j - 1] =
354	free (maze[i]);	344	sym_maze[sym_maze->w - i - 1][j ] =
355	free (maze);	345	sym_maze[sym_maze->w - i - 1][sym_maze->h - j - 1] = maze[i][j];
		346	}
		347
		348	maze.swap (sym_maze);
		349
356	/* reconnect disjointed spirals */	350	/* reconnect disjointed spirals */
357	if (RP->map_layout_style == LAYOUT_SPIRAL)
358	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
359	/* reconnect disjointed nethackmazes: the routine for	351	/* reconnect disjointed nethackmazes: the routine for
360	spirals will do the trick? */	352	spirals will do the trick? */
		353	if (RP->map_layout_style == LAYOUT_SPIRAL
361	if (RP->map_layout_style == LAYOUT_ROGUELIKE)	354	\|\| RP->map_layout_style == LAYOUT_ROGUELIKE)
362	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);	355	connect_spirals (maze->w, maze->h, RP->symmetry_used, maze);
363
364	return sym_maze;
365	}	356	}
366
367		357
368	/* takes a map and rotates it. This completes the	358	/* takes a map and rotates it. This completes the
369	onion layouts, making them possibly centered on any wall.	359	onion layouts, making them possibly centered on any wall.
370	It'll modify Xsize and Ysize if they're swapped.	360	It'll modify Xsize and Ysize if they're swapped.
371	*/	361	*/
372		362	static void
373	char **	363	rotate_layout (Maze maze, int rotation)
374	rotate_layout (char *maze, int rotation, random_map_params RP)
375	{	364	{
376	char **new_maze;
377	int i, j;
378
379	switch (rotation)	365	switch (rotation)
380	{	366	{
381	case 0:
382	return maze;
383	break;
384	case 2: /* a reflection */	367	case 2: /* a reflection */
385	{	368	{
386	char newmaze = (char ) malloc (sizeof (char) * RP->Xsize * RP->Ysize);	369	Maze new_maze (maze->w, maze->h);
387		370
388	for (i = 0; i < RP->Xsize; i++)	371	for (int i = 0; i < maze->w; i++) /* copy a reflection back */
389	{ /* make a copy */
390	for (j = 0; j < RP->Ysize; j++)	372	for (int j = 0; j < maze->h; j++)
391	{	373	new_maze[i][j] = maze[maze->w - i - 1][maze->h - j - 1];
392	newmaze[i * RP->Ysize + j] = maze[i][j];	374
393	}	375	maze.swap (new_maze);
394	}	376	}
395	for (i = 0; i < RP->Xsize; i++)	377
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	}
406	case 1:	378	case 1:
407	case 3:	379	case 3:
408	{	380	{
409	int swap;	381	Maze new_maze (maze->h, maze->w);
410	new_maze = (char *) calloc (sizeof (char ), RP->Ysize);	382
411	for (i = 0; i < RP->Ysize; i++)
412	{
413	new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
414	}
415	if (rotation == 1) /* swap x and y */	383	if (rotation == 1) /* swap x and y */
416	for (i = 0; i < RP->Xsize; i++)	384	for (int i = 0; i < maze->w; i++)
417	for (j = 0; j < RP->Ysize; j++)	385	for (int j = 0; j < maze->h; j++)
418	new_maze[j][i] = maze[i][j];	386	new_maze[j][i] = maze[i][j];
419		387
420	if (rotation == 3)	388	if (rotation == 3) /* swap x and y */
421	{ /* swap x and y */
422	for (i = 0; i < RP->Xsize; i++)	389	for (int i = 0; i < maze->w; i++)
423	for (j = 0; j < RP->Ysize; j++)	390	for (int j = 0; j < maze->h; j++)
424	new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];	391	new_maze[j][i] = maze[maze->w - i - 1][maze->h - j - 1];
		392
		393	maze.swap (new_maze);
425	}	394	}
426
427	/* delete the old layout */
428	for (i = 0; i < RP->Xsize; i++)
429	free (maze[i]);
430	free (maze);
431
432	swap = RP->Ysize;
433	RP->Ysize = RP->Xsize;
434	RP->Xsize = swap;
435	return new_maze;
436	break;
437	}
438	}	395	}
439	return NULL;
440	}	396	}
441		397
442	/* take a layout and make some rooms in it.	398	/* take a layout and make some rooms in it.
443	--works best on onions.*/	399	--works best on onions.*/
444	void	400	void
…		…
450	for (ti = 0; ti < tries; ti++)	406	for (ti = 0; ti < tries; ti++)
451	{	407	{
452	int dx, dy; /* starting location for looking at creating a door */	408	int dx, dy; /* starting location for looking at creating a door */
453	int cx, cy; /* results of checking on creating walls. */	409	int cx, cy; /* results of checking on creating walls. */
454		410
455	dx = RANDOM () % RP->Xsize;	411	dx = rndm (RP->Xsize);
456	dy = RANDOM () % RP->Ysize;	412	dy = rndm (RP->Ysize);
		413
457	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */	414	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
458	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */	415	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
459	if (cx == -1)	416	if (cx == -1)
460	{	417	{
461	if (cy != -1)	418	if (cy != -1)
462	make_wall (maze, dx, dy, 1);	419	make_wall (maze, dx, dy, 1);
		420
463	continue;	421	continue;
464	}	422	}
		423
465	if (cy == -1)	424	if (cy == -1)
466	{	425	{
467	make_wall (maze, dx, dy, 0);	426	make_wall (maze, dx, dy, 0);
468	continue;	427	continue;
469	}	428	}
		429
470	if (cx < cy)	430	if (cx < cy)
471	make_wall (maze, dx, dy, 0);	431	make_wall (maze, dx, dy, 0);
472	else	432	else
473	make_wall (maze, dx, dy, 1);	433	make_wall (maze, dx, dy, 1);
474	}	434	}
…		…
592	/* puts doors at appropriate locations in a layout. */	552	/* puts doors at appropriate locations in a layout. */
593	void	553	void
594	doorify_layout (char *maze, random_map_params RP)	554	doorify_layout (char *maze, random_map_params RP)
595	{	555	{
596	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */	556	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
597	char *doorlist_x;
598	char *doorlist_y;
599	int doorlocs = 0; /* # of available doorlocations */	557	int doorlocs = 0; /* # of available doorlocations */
600	int i, j;	558	int i, j;
601		559
602	doorlist_x = (char ) malloc (sizeof (int) RP->Xsize * RP->Ysize);	560	char doorlist_x = salloc<char> (RP->Xsize RP->Ysize);
603	doorlist_y = (char ) malloc (sizeof (int) RP->Xsize * RP->Ysize);	561	char doorlist_y = salloc<char> (RP->Xsize RP->Ysize);
604
605		562
606	/* make a list of possible door locations */	563	/* make a list of possible door locations */
607	for (i = 1; i < RP->Xsize - 1; i++)	564	for (i = 1; i < RP->Xsize - 1; i++)
608	for (j = 1; j < RP->Ysize - 1; j++)	565	for (j = 1; j < RP->Ysize - 1; j++)
609	{	566	{
…		…
620	while (ndoors > 0 && doorlocs > 0)	577	while (ndoors > 0 && doorlocs > 0)
621	{	578	{
622	int di;	579	int di;
623	int sindex;	580	int sindex;
624		581
625	di = RANDOM () % doorlocs;	582	di = rndm (doorlocs);
626	i = doorlist_x[di];	583	i = doorlist_x[di];
627	j = doorlist_y[di];	584	j = doorlist_y[di];
628	sindex = surround_flag (maze, i, j, RP);	585	sindex = surround_flag (maze, i, j, RP);
		586
629	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */	587	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */
630	{	588	{
631	maze[i][j] = 'D';	589	maze[i][j] = 'D';
632	ndoors--;	590	ndoors--;
633	}	591	}
		592
634	/* reduce the size of the list */	593	/* reduce the size of the list */
635	doorlocs--;	594	doorlocs--;
636	doorlist_x[di] = doorlist_x[doorlocs];	595	doorlist_x[di] = doorlist_x[doorlocs];
637	doorlist_y[di] = doorlist_y[doorlocs];	596	doorlist_y[di] = doorlist_y[doorlocs];
638	}	597	}
639		598
640	free (doorlist_x);	599	sfree (doorlist_x, RP->Xsize * RP->Ysize);
641	free (doorlist_y);	600	sfree (doorlist_y, RP->Xsize * RP->Ysize);
642	}	601	}
643		602
644	void	603	void
645	write_map_parameters_to_string (char buf, random_map_params RP)	604	write_map_parameters_to_string (char buf, random_map_params RP)
646	{	605	{
…		…
810		769
811	void	770	void
812	write_parameters_to_string (char *buf,	771	write_parameters_to_string (char *buf,
813	int xsize_n,	772	int xsize_n,
814	int ysize_n,	773	int ysize_n,
815	char *wallstyle_n,	774	const char *wallstyle_n,
816	char *floorstyle_n,	775	const char *floorstyle_n,
817	char *monsterstyle_n,	776	const char *monsterstyle_n,
818	char *treasurestyle_n,	777	const char *treasurestyle_n,
819	char *layoutstyle_n,	778	const char *layoutstyle_n,
820	char *decorstyle_n,	779	const char *decorstyle_n,
821	char *doorstyle_n,	780	const char *doorstyle_n,
822	char *exitstyle_n,	781	const char *exitstyle_n,
823	char *final_map_n,	782	const char *final_map_n,
824	char *exit_on_final_map_n,	783	const char *exit_on_final_map_n,
825	char *this_map_n,	784	const char *this_map_n,
826	int layoutoptions1_n,	785	int layoutoptions1_n,
827	int layoutoptions2_n,	786	int layoutoptions2_n,
828	int layoutoptions3_n,	787	int layoutoptions3_n,
829	int symmetry_n,	788	int symmetry_n,
830	int dungeon_depth_n,	789	int dungeon_depth_n,
831	int dungeon_level_n,	790	int dungeon_level_n,
832	int difficulty_n,	791	int difficulty_n,
833	int difficulty_given_n,	792	int difficulty_given_n,
834	int decoroptions_n,	793	int decoroptions_n,
835	int orientation_n,	794	int orientation_n,
836	int origin_x_n, int origin_y_n, uint32_t random_seed_n, int treasureoptions_n, float difficulty_increase)	795	int origin_x_n,
		796	int origin_y_n,
		797	uint32_t random_seed_n,
		798	int treasureoptions_n,
		799	float difficulty_increase)
837	{	800	{
838	char small_buf[16384];	801	char small_buf[16384];
839		802
840	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);	803	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
841		804
…		…
1004		967
1005	walk->copy_to (tmp);	968	walk->copy_to (tmp);
1006	insert_ob_in_ob (tmp, dest_ob);	969	insert_ob_in_ob (tmp, dest_ob);
1007	}	970	}
1008	}	971	}
		972
		973	MazeData::MazeData (int w, int h)
		974	: w(w), h(h)
		975	{
		976	int size = (sizeof (char ) + sizeof (char) h) * w;
		977
		978	col = (char **)salloc<char> (size);
		979
		980	char data = (char )(col + w);
		981
		982	for (int x = w; x--; )
		983	col [x] = data + x * h;
		984	}
		985
		986	MazeData::~MazeData ()
		987	{
		988	int size = (sizeof (char ) + sizeof (char) h) * w;
		989
		990	sfree ((char *)col, size);
		991	}
		992
		993	void MazeData::clear (char fill)
		994	{
		995	memset (col [0], fill, w * h);
		996	}
		997
		998	void MazeData::border (char fill)
		999	{
		1000	for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
		1001	for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
		1002	}
		1003
		1004

Diff Legend

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

Comparing deliantra/server/random_maps/random_map.C (file contents): Revision 1.26 by root, Thu Jan 25 03:54:45 2007 UTC vs. Revision 1.33 by root, Mon Apr 14 22:41:17 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.26 by root, Thu Jan 25 03:54:45 2007 UTC vs.
Revision 1.33 by root, Mon Apr 14 22:41:17 2008 UTC