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 symmetry;
  int difficulty;
  int difficulty_given;
  float difficulty_increase;

  int dungeon_level;
  int dungeon_depth;

  int orientation;
  uint32_t random_seed;
  uint64_t total_map_hp;
  int map_layout_style;
  int symmetry_used;

  HV *hv;
  void hv_clone (); // replaces the hv by a clone'd copy (%new_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;

  random_map_params ();
  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,
  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

// reference
//
// \0  floor only
// #   wall
// D   door
// <   up
// >   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);
  ~layout ();

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

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

  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);

  // makes sure all areas are connected
  MTH void isolation_remover ();

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

  // 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:
  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;
}

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

  point ()
  {
  }

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

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