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];
  char monsterstyle[512];
  char layoutstyle[512];
  char doorstyle[512];
  shstr origin_map;
  shstr final_map;
  shstr this_map;
  char exit_on_final_map[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;
  int origin_x;
  int origin_y;
  uint32_t random_seed;
  uint64_t total_map_hp;
  int map_layout_style;
  int symmetry_used;

  struct region *region;

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

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

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

// use this in new code
struct LayoutData 
{
  char **col;
  int w, h;

  LayoutData (int w, int h);
  ~LayoutData ();

  operator char **()
  {
    return col;
  }

  // for debugging, print layout to stdout
  void print ();

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

  void fill_rand (int perc);

  // makes sure all areas are connected. dirty=true carves rounder but also
  // more walls, dirty=false carves narrow corridors.
  void isolation_remover (bool dirty = 0);

  // generates a cave, subtype 0 is a rough cave, randomly open or closed
  void gen_cave (int subtype);
  void erode_1_2 (int c1, int c2 = -1, int repeat = 1);

  void swap (LayoutData &layout)
  {
    ::swap (layout.col, col);
    ::swap (layout.w  , w  );
    ::swap (layout.h  , h  );
  }
};

// basically a layoutdata point - do not use in new code
struct Layout
{
  LayoutData *ptr;

  Layout ()
  {
  }

  Layout (int xsize, int ysize)
  : ptr (new LayoutData (xsize, ysize))
  {
  }

  Layout (random_map_params *RP)
  : ptr (new LayoutData (RP->Xsize, RP->Ysize))
  {
  }

  void free ()
  {
    delete ptr;
  }

  LayoutData *operator ->() const
  {
    return ptr;
  }

  operator char **() const
  {
    return *ptr;
  }

  void swap (Layout &layout)
  {
    ::swap (layout.ptr, ptr);
  }
};

// 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.30
Committed:	Wed Jun 30 23:03:40 2010 UTC (13 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.29:	+26 -8 lines
Log Message:	add cave maze type
#	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			char monsterstyle[512];
34			char layoutstyle[512];
35			char doorstyle[512];
36	root	1.7	shstr origin_map;
37			shstr final_map;
38			shstr this_map;
39	root	1.1	char exit_on_final_map[512];
40	root	1.26
41	root	1.11	int xsize, ysize;
42	root	1.1	int expand2x;
43			int layoutoptions1;
44			int layoutoptions2;
45			int layoutoptions3;
46			int symmetry;
47			int difficulty;
48			int difficulty_given;
49			float difficulty_increase;
50	root	1.8
51	root	1.1	int dungeon_level;
52			int dungeon_depth;
53	root	1.8
54	root	1.1	int orientation;
55	root	1.28	int origin_x;
56	root	1.1	int origin_y;
57	root	1.12	uint32_t random_seed;
58	root	1.6	uint64_t total_map_hp;
59	root	1.1	int map_layout_style;
60			int symmetry_used;
61	root	1.6
62	elmex	1.2	struct region *region;
63	root	1.11
64	root	1.26	HV *hv;
65	root	1.28	void hv_clone (); // replaces the hv by a clone'd copy (%new_hv = { %hv })
66
67			shstr_tmp as_shstr () const;
68	root	1.26
69			// fetch something from the options hash
70	root	1.28	SV get_sv (const char option) const;
71			const_utf8_string get_str (const char *option, const_utf8_string fallback = "") const;
72			IV get_iv (const char *option, IV fallback = 0) const;
73			UV get_uv (const char *option, UV fallback = 0) const;
74			NV get_nv (const char *option, NV fallback = 0) const;
75
76			void set (const char option, SV value) const;
77			void set (const char *option, const_utf8_string value) const;
78			void set (const char *option, IV value) const;
79			void set (const char *option, UV value) const;
80			void set (const char *option, NV value) const;
81	root	1.26
82	root	1.28	void set (const char *option, int value) const { set (option, (IV)value); }
83	root	1.26
84	root	1.11	// "private", adjusted sizes
85			int Xsize;
86			int Ysize;
87	root	1.26
88			~random_map_params ();
89	root	1.6	};
90	root	1.1
91	root	1.6	enum {
92			LAYOUT_NONE,
93			LAYOUT_ONION,
94			LAYOUT_MAZE,
95			LAYOUT_SPIRAL,
96			LAYOUT_ROGUELIKE,
97			LAYOUT_SNAKE,
98			LAYOUT_SQUARE_SPIRAL,
99	root	1.30	LAYOUT_CAVE,
100	root	1.6	NROFLAYOUTS,
101			};
102	root	1.1
103			/*
104			* Move these defines out of room_gen_onion.c to here, as
105			* other files (like square_spiral) also uses them.
106
107			options:
108			0 Pick random options below
109			1 "centered"
110			2 linear doors (default is nonlinear)
111			4 bottom "centered"
112			8 bottom-right centered
113			16 irregularly/randomly spaced layers (default: regular)
114			32 outer wall off: i.e., no outer wall.
115
116			*/
117
118	root	1.6	enum {
119			RMOPT_RANDOM = 0,
120			RMOPT_CENTERED = 1,
121			RMOPT_LINEAR = 2,
122			RMOPT_BOTTOM_C = 4,
123			RMOPT_BOTTOM_R = 8,
124			RMOPT_IRR_SPACE = 16,
125			RMOPT_WALL_OFF = 32,
126			RMOPT_WALLS_ONLY = 64,
127			RMOPT_NO_DOORS = 256, /* Place walls insead of doors. Produces broken map. */
128			};
129	root	1.1
130			/* symmetry definitions--used in this file AND in treasure.c:
131			the numerical values matter so don't change them. */
132	root	1.6	enum {
133			SYMMETRY_RANDOM,
134			SYMMETRY_NONE,
135			SYMMETRY_X,
136			SYMMETRY_Y,
137			SYMMETRY_XY,
138			};
139	root	1.1
140	root	1.13	// 12 has been experimentally :( determined ot be a lot more stable
141			// than 11 or 10, leading to the assumption that something inherently
142			// needs a minimum size of at least 12
143			#define MIN_RANDOM_MAP_SIZE 12
144	root	1.1
145	root	1.20	// reference
146			//
147			// \0 floor only
148			// # wall
149			// D door
150			// < up
151			// > down
152			// C "center" (of onion layout)
153			// . ?? (rogue)
154			//
155
156	root	1.30	// use this in new code
157	root	1.29	struct LayoutData
158	root	1.17	{
159			char **col;
160	root	1.18	int w, h;
161	root	1.17
162	root	1.19	LayoutData (int w, int h);
163			~LayoutData ();
164	root	1.17
165			operator char **()
166			{
167			return col;
168			}
169	root	1.18
170	root	1.30	// for debugging, print layout to stdout
171			void print ();
172
173			// simple inpainting
174	root	1.29	void fill (char fill);
175			void clear () { fill (0); }
176	root	1.18	void border (char fill = '#');
177	root	1.29	void rect (int x1, int y1, int x2, int y2, char fill); // x2, y2 exclusive
178
179	root	1.30	void fill_rand (int perc);
180
181	root	1.29	// makes sure all areas are connected. dirty=true carves rounder but also
182	root	1.30	// more walls, dirty=false carves narrow corridors.
183	root	1.29	void isolation_remover (bool dirty = 0);
184	root	1.30
185			// generates a cave, subtype 0 is a rough cave, randomly open or closed
186			void gen_cave (int subtype);
187			void erode_1_2 (int c1, int c2 = -1, int repeat = 1);
188
189			void swap (LayoutData &layout)
190			{
191			::swap (layout.col, col);
192			::swap (layout.w , w );
193			::swap (layout.h , h );
194			}
195	root	1.17	};
196
197	root	1.30	// basically a layoutdata point - do not use in new code
198	root	1.19	struct Layout
199	root	1.17	{
200	root	1.19	LayoutData *ptr;
201	root	1.17
202	root	1.19	Layout ()
203	root	1.17	{
204			}
205
206	root	1.19	Layout (int xsize, int ysize)
207			: ptr (new LayoutData (xsize, ysize))
208	root	1.17	{
209			}
210
211	root	1.19	Layout (random_map_params *RP)
212			: ptr (new LayoutData (RP->Xsize, RP->Ysize))
213	root	1.17	{
214			}
215
216			void free ()
217			{
218			delete ptr;
219			}
220
221	root	1.19	LayoutData *operator ->() const
222	root	1.18	{
223			return ptr;
224			}
225
226			operator char **() const
227	root	1.17	{
228			return *ptr;
229			}
230	root	1.18
231	root	1.30	void swap (Layout &layout)
232	root	1.18	{
233	root	1.30	::swap (layout.ptr, ptr);
234	root	1.18	}
235	root	1.17	};
236
237	root	1.25	// utility functions, to use rmg_rndm instead of rndm.
238			static inline int
239			rmg_find_free_spot (const object ob, maptile m, int x, int y, int start, int stop)
240			{
241			swap (rmg_rndm, rndm);
242			int i = find_free_spot (ob, m, x, y, start, stop);
243			swap (rmg_rndm, rndm);
244			return i;
245			}
246
247	root	1.30	// a simple point helper struct
248	root	1.29	struct point
249			{
250			short x;
251			short y;
252
253			point ()
254			{
255			}
256
257			point (int x, int y)
258			: x(x), y(y)
259			{
260			}
261			};
262
263	root	1.30	// something like a vector or stack, but without
264			// out of bounds checking
265	root	1.29	template<typename T>
266			struct fixed_stack
267			{
268			T *data;
269			int size;
270			int max;
271
272			fixed_stack ()
273			: size (0), data (0)
274			{
275			}
276
277			fixed_stack (int max)
278			: size (0), max (max)
279			{
280			data = salloc<T> (max);
281			}
282
283			void reset (int new_max)
284			{
285			sfree (data, max);
286			size = 0;
287			max = new_max;
288			data = salloc<T> (max);
289			}
290
291			void free ()
292			{
293			sfree (data, max);
294			data = 0;
295			}
296
297			~fixed_stack ()
298			{
299			sfree (data, max);
300			}
301
302			T &operator[](int idx)
303			{
304			return data [idx];
305			}
306
307			void push (T v)
308			{
309			data [size++] = v;
310			}
311
312			T &pop ()
313			{
314			return data [--size];
315			}
316
317			T remove (int idx)
318			{
319			T v = data [idx];
320
321			data [idx] = data [--size];
322
323			return v;
324			}
325			};
326
327	root	1.6	#endif
328	root	1.1