server/random_maps/random_map.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#ifndef RANDOM_MAP_H
#define RANDOM_MAP_H

#include "util.h"

struct random_map_params : zero_initialised
{
  char wall_name[512];
 
  int xsize, ysize;
  int expand2x;
  int layoutoptions1;
  int layoutoptions2;
  int layoutoptions3;
  int difficulty;
  int difficulty_given;
  float difficulty_increase;

  int dungeon_level;
  int dungeon_depth;

  uint32_t random_seed;
  uint64_t total_map_hp;

  HV *hv;

  shstr_tmp as_shstr () const;

  // fetch something from the options hash
  SV               *get_sv  (const char *option) const;
  const_utf8_string get_str (const char *option, const_utf8_string fallback = "") const;
  IV                get_iv  (const char *option, IV                fallback =  0) const;
  UV                get_uv  (const char *option, UV                fallback =  0) const;
  NV                get_nv  (const char *option, NV                fallback =  0) const;

  void set (const char *option, SV               *value) const;
  void set (const char *option, const_utf8_string value) const;
  void set (const char *option, IV                value) const;
  void set (const char *option, UV                value) const;
  void set (const char *option, NV                value) const;

  void set (const char *option, int value) const { set (option, (IV)value); }

  // "private", adjusted sizes
  int Xsize;
  int Ysize;

  int map_layout_style;
  int symmetry_used;

  random_map_params ();
  random_map_params (random_map_params *RP);
  random_map_params (HV *hv);
  ~random_map_params ();
};

enum {
  LAYOUT_NONE,
  LAYOUT_ONION,
  LAYOUT_MAZE,
  LAYOUT_SPIRAL,
  LAYOUT_ROGUELIKE,
  LAYOUT_SNAKE,
  LAYOUT_SQUARE_SPIRAL,
  LAYOUT_CAVE,
  LAYOUT_CASTLE,
  LAYOUT_MULTIPLE,
  NROFLAYOUTS,
};

/*
 * Move these defines out of room_gen_onion.c to here, as
 * other files (like square_spiral) also uses them.

options:
0       Pick random options below
1       "centered"
2       linear doors (default is nonlinear)
4       bottom "centered"
8  bottom-right centered
16      irregularly/randomly spaced layers (default: regular)
32      outer wall off:  i.e., no outer wall.

*/

enum {
  RMOPT_RANDOM     =   0,
  RMOPT_CENTERED   =   1,
  RMOPT_LINEAR     =   2,
  RMOPT_BOTTOM_C   =   4,
  RMOPT_BOTTOM_R   =   8,
  RMOPT_IRR_SPACE  =  16,
  RMOPT_WALL_OFF   =  32,
  RMOPT_WALLS_ONLY =  64,
  RMOPT_NO_DOORS   = 256, /* Place walls insead of doors.  Produces broken map. */  
};

/* symmetry definitions--used in this file AND in treasure.c:
the numerical values matter so don't change them. */
enum {
  SYMMETRY_RANDOM,
  SYMMETRY_NONE,
  SYMMETRY_X,
  SYMMETRY_Y,
  SYMMETRY_XY,
};

// 12 has been experimentally :( determined ot be a lot more stable
// than 11 or 10, leading to the assumption that something inherently
// needs a minimum size of at least 12
#define MIN_RANDOM_MAP_SIZE 12

// we often use signed chars for coordinates (and U8 for distances)
#define MAX_RANDOM_MAP_SIZE 120

// a simple point helper struct
struct point
{
  int x;
  int y;

  point ()
  {
  }

  point (int x, int y)
  : x(x), y(y)
  {
  }
};

//
// reference
//
// \0  floor only
// #   wall
// D   door
// <   entrance (traditionally up)
// >   exit (traditionally down)
// C   "center" (of onion maze)
// .   ?? (rogue)
//

// use this in new code
INTERFACE_CLASS(layout)
struct layout 
{
  typedef char cell;

  cell **data;
  int w, h;

  layout (int w, int h);
  layout (layout &copy);

  // reference rect in other layout - will not keep the data alive,
  // so never swap with it's orig, or free the orig when in use.
  layout (layout &orig, int x1, int y1, int x2, int y2);

  ~layout ();

  operator cell **() const
  {
    return data;
  }

  void swap (layout &maze)
  {
    ::swap (maze.data, data);
    ::swap (maze.w   , w   );
    ::swap (maze.h   , h   );
    ::swap (maze.size, size);
  }

  MTH void swap (layout *maze) { swap (*maze); }

  // for debugging, print maze to stdout
  MTH void print () const;

  // simple inpainting
  MTH void fill (char fill);
  MTH void clear () { fill (0); }
  MTH void border (char fill = '#');
  MTH void rect (int x1, int y1, int x2, int y2, char fill); // x2, y2 exclusive
  MTH void fill_rect (int x1, int y1, int x2, int y2, char fill); // x2, y2 exclusive

  MTH void fill_rand (int perc);
  MTH void replace (char from, char to);

  point find (char target, int mode = 0); // mode 0=random, 1=upleft, 2=upright, 3=downright, 4=downleft

  // makes sure all areas are connected
  // perturb = 0 - very horz/vert tunnels
  // perturb = 1 - straight but round
  // perturb = 2 - snaky tunnels
  MTH void isolation_remover (int perturb = 2);

  // generates a cave, subtype 0 is a rough cave, randomly open or closed
  MTH void gen_cave (int subtype);
  MTH void gen_castle (); // generates straightish structures

  // helper functions to modify the maze
  MTH void erode_1_2 (int c1, int c2 = -1, int repeat = 1);
  MTH void doorify ();
  MTH void roomify (); // make some rooms in it, works best on onions
  MTH void expand2x ();
  MTH void symmetrize (int symmetry);
  MTH void rotate (int rotation); // rotate by 1=90, 2=180, 3=270 degrees

  void generate (random_map_params *RP);
private:
  int size;
  void alloc (int w, int h);
};

// utility functions, to use rmg_rndm instead of rndm.
static inline int
rmg_find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
{
  swap (rmg_rndm, rndm);
  int i = find_free_spot (ob, m, x, y, start, stop);
  swap (rmg_rndm, rndm);
  return i;
}

// something like a vector or stack, but without
// out of bounds checking
template<typename T>
struct fixed_stack
{
  T *data;
  int size;
  int max;

  fixed_stack ()
  : size (0), data (0)
  {
  }

  fixed_stack (int max)
  : size (0), max (max)
  {
    data = salloc<T> (max);
  }

  void reset (int new_max)
  {
    sfree (data, max);
    size = 0;
    max = new_max;
    data = salloc<T> (max);
  }

  void free ()
  {
    sfree (data, max);
    data = 0;
  }

  ~fixed_stack ()
  {
    sfree (data, max);
  }

  T &operator[](int idx)
  {
    return data [idx];
  }

  void push (T v)
  {
    data [size++] = v;
  }

  T &pop ()
  {
    return data [--size];
  }

  T remove (int idx)
  {
    T v = data [idx];

    data [idx] = data [--size];

    return v;
  }
};

#endif

Revision:	1.45
Committed:	Mon Jul 5 00:07:21 2010 UTC (13 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.44:	+22 -18 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/*
2	root	1.16	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	root	1.14	*
4	root	1.23	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.22	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6			* Copyright (©) 1992 Frank Tore Johansen
7	root	1.14	*
8	root	1.21	* Deliantra is free software: you can redistribute it and/or modify it under
9			* the terms of the Affero GNU General Public License as published by the
10			* Free Software Foundation, either version 3 of the License, or (at your
11			* option) any later version.
12	root	1.14	*
13	root	1.15	* 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	root	1.14	*
18	root	1.21	* You should have received a copy of the Affero GNU General Public License
19			* and the GNU General Public License along with this program. If not, see
20			* <http://www.gnu.org/licenses/>.
21	root	1.14	*
22	root	1.16	* The authors can be reached via e-mail to <support@deliantra.net>
23	root	1.1	*/
24
25			#ifndef RANDOM_MAP_H
26			#define RANDOM_MAP_H
27
28	root	1.17	#include "util.h"
29
30	root	1.25	struct random_map_params : zero_initialised
31	root	1.6	{
32	root	1.1	char wall_name[512];
33	root	1.26
34	root	1.11	int xsize, ysize;
35	root	1.1	int expand2x;
36			int layoutoptions1;
37			int layoutoptions2;
38			int layoutoptions3;
39			int difficulty;
40			int difficulty_given;
41			float difficulty_increase;
42	root	1.8
43	root	1.1	int dungeon_level;
44			int dungeon_depth;
45	root	1.8
46	root	1.12	uint32_t random_seed;
47	root	1.6	uint64_t total_map_hp;
48
49	root	1.26	HV *hv;
50	root	1.28
51			shstr_tmp as_shstr () const;
52	root	1.26
53			// fetch something from the options hash
54	root	1.28	SV get_sv (const char option) const;
55			const_utf8_string get_str (const char *option, const_utf8_string fallback = "") const;
56			IV get_iv (const char *option, IV fallback = 0) const;
57			UV get_uv (const char *option, UV fallback = 0) const;
58			NV get_nv (const char *option, NV fallback = 0) const;
59
60			void set (const char option, SV value) const;
61			void set (const char *option, const_utf8_string value) const;
62			void set (const char *option, IV value) const;
63			void set (const char *option, UV value) const;
64			void set (const char *option, NV value) const;
65	root	1.26
66	root	1.28	void set (const char *option, int value) const { set (option, (IV)value); }
67	root	1.26
68	root	1.11	// "private", adjusted sizes
69			int Xsize;
70			int Ysize;
71	root	1.26
72	root	1.44	int map_layout_style;
73			int symmetry_used;
74
75	root	1.39	random_map_params ();
76	root	1.41	random_map_params (random_map_params *RP);
77	root	1.39	random_map_params (HV *hv);
78	root	1.26	~random_map_params ();
79	root	1.6	};
80	root	1.1
81	root	1.6	enum {
82			LAYOUT_NONE,
83			LAYOUT_ONION,
84			LAYOUT_MAZE,
85			LAYOUT_SPIRAL,
86			LAYOUT_ROGUELIKE,
87			LAYOUT_SNAKE,
88			LAYOUT_SQUARE_SPIRAL,
89	root	1.30	LAYOUT_CAVE,
90	root	1.42	LAYOUT_CASTLE,
91	root	1.41	LAYOUT_MULTIPLE,
92	root	1.6	NROFLAYOUTS,
93			};
94	root	1.1
95			/*
96			* Move these defines out of room_gen_onion.c to here, as
97			* other files (like square_spiral) also uses them.
98
99			options:
100			0 Pick random options below
101			1 "centered"
102			2 linear doors (default is nonlinear)
103			4 bottom "centered"
104			8 bottom-right centered
105			16 irregularly/randomly spaced layers (default: regular)
106			32 outer wall off: i.e., no outer wall.
107
108			*/
109
110	root	1.6	enum {
111			RMOPT_RANDOM = 0,
112			RMOPT_CENTERED = 1,
113			RMOPT_LINEAR = 2,
114			RMOPT_BOTTOM_C = 4,
115			RMOPT_BOTTOM_R = 8,
116			RMOPT_IRR_SPACE = 16,
117			RMOPT_WALL_OFF = 32,
118			RMOPT_WALLS_ONLY = 64,
119			RMOPT_NO_DOORS = 256, /* Place walls insead of doors. Produces broken map. */
120			};
121	root	1.1
122			/* symmetry definitions--used in this file AND in treasure.c:
123			the numerical values matter so don't change them. */
124	root	1.6	enum {
125			SYMMETRY_RANDOM,
126			SYMMETRY_NONE,
127			SYMMETRY_X,
128			SYMMETRY_Y,
129			SYMMETRY_XY,
130			};
131	root	1.1
132	root	1.13	// 12 has been experimentally :( determined ot be a lot more stable
133			// than 11 or 10, leading to the assumption that something inherently
134			// needs a minimum size of at least 12
135			#define MIN_RANDOM_MAP_SIZE 12
136	root	1.1
137	root	1.31	// we often use signed chars for coordinates (and U8 for distances)
138			#define MAX_RANDOM_MAP_SIZE 120
139
140	root	1.45	// a simple point helper struct
141			struct point
142			{
143			int x;
144			int y;
145
146			point ()
147			{
148			}
149
150			point (int x, int y)
151			: x(x), y(y)
152			{
153			}
154			};
155
156			//
157	root	1.20	// reference
158			//
159			// \0 floor only
160			// # wall
161			// D door
162	root	1.45	// < entrance (traditionally up)
163			// > exit (traditionally down)
164	root	1.34	// C "center" (of onion maze)
165	root	1.20	// . ?? (rogue)
166			//
167
168	root	1.30	// use this in new code
169	root	1.34	INTERFACE_CLASS(layout)
170			struct layout
171	root	1.17	{
172	root	1.35	typedef char cell;
173
174			cell **data;
175	root	1.18	int w, h;
176	root	1.17
177	root	1.34	layout (int w, int h);
178	root	1.36	layout (layout &copy);
179	root	1.41
180			// reference rect in other layout - will not keep the data alive,
181			// so never swap with it's orig, or free the orig when in use.
182			layout (layout &orig, int x1, int y1, int x2, int y2);
183
184	root	1.34	~layout ();
185	root	1.17
186	root	1.35	operator cell **() const
187	root	1.17	{
188	root	1.35	return data;
189	root	1.17	}
190	root	1.18
191	root	1.34	void swap (layout &maze)
192	root	1.32	{
193	root	1.35	::swap (maze.data, data);
194	root	1.40	::swap (maze.w , w );
195			::swap (maze.h , h );
196			::swap (maze.size, size);
197	root	1.32	}
198
199	root	1.35	MTH void swap (layout maze) { swap (maze); }
200
201	root	1.34	// for debugging, print maze to stdout
202			MTH void print () const;
203	root	1.30
204			// simple inpainting
205	root	1.34	MTH void fill (char fill);
206			MTH void clear () { fill (0); }
207			MTH void border (char fill = '#');
208			MTH void rect (int x1, int y1, int x2, int y2, char fill); // x2, y2 exclusive
209	root	1.37	MTH void fill_rect (int x1, int y1, int x2, int y2, char fill); // x2, y2 exclusive
210	root	1.29
211	root	1.34	MTH void fill_rand (int perc);
212	root	1.45	MTH void replace (char from, char to);
213
214			point find (char target, int mode = 0); // mode 0=random, 1=upleft, 2=upright, 3=downright, 4=downleft
215	root	1.30
216	root	1.37	// makes sure all areas are connected
217	root	1.42	// perturb = 0 - very horz/vert tunnels
218			// perturb = 1 - straight but round
219			// perturb = 2 - snaky tunnels
220			MTH void isolation_remover (int perturb = 2);
221	root	1.30
222			// generates a cave, subtype 0 is a rough cave, randomly open or closed
223	root	1.34	MTH void gen_cave (int subtype);
224	root	1.42	MTH void gen_castle (); // generates straightish structures
225	root	1.33
226	root	1.34	// helper functions to modify the maze
227			MTH void erode_1_2 (int c1, int c2 = -1, int repeat = 1);
228			MTH void doorify ();
229			MTH void roomify (); // make some rooms in it, works best on onions
230			MTH void expand2x ();
231			MTH void symmetrize (int symmetry);
232			MTH void rotate (int rotation); // rotate by 1=90, 2=180, 3=270 degrees
233	root	1.30
234	root	1.32	void generate (random_map_params *RP);
235	root	1.36	private:
236	root	1.40	int size;
237	root	1.36	void alloc (int w, int h);
238	root	1.17	};
239
240	root	1.25	// utility functions, to use rmg_rndm instead of rndm.
241			static inline int
242			rmg_find_free_spot (const object ob, maptile m, int x, int y, int start, int stop)
243			{
244			swap (rmg_rndm, rndm);
245			int i = find_free_spot (ob, m, x, y, start, stop);
246			swap (rmg_rndm, rndm);
247			return i;
248			}
249
250	root	1.30	// something like a vector or stack, but without
251			// out of bounds checking
252	root	1.29	template<typename T>
253			struct fixed_stack
254			{
255			T *data;
256			int size;
257			int max;
258
259			fixed_stack ()
260			: size (0), data (0)
261			{
262			}
263
264			fixed_stack (int max)
265			: size (0), max (max)
266			{
267			data = salloc<T> (max);
268			}
269
270			void reset (int new_max)
271			{
272			sfree (data, max);
273			size = 0;
274			max = new_max;
275			data = salloc<T> (max);
276			}
277
278			void free ()
279			{
280			sfree (data, max);
281			data = 0;
282			}
283
284			~fixed_stack ()
285			{
286			sfree (data, max);
287			}
288
289			T &operator[](int idx)
290			{
291			return data [idx];
292			}
293
294			void push (T v)
295			{
296			data [size++] = v;
297			}
298
299			T &pop ()
300			{
301			return data [--size];
302			}
303
304			T remove (int idx)
305			{
306			T v = data [idx];
307
308			data [idx] = data [--size];
309
310			return v;
311			}
312			};
313
314	root	1.6	#endif
315	root	1.1