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,
  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)
//

struct LayoutData 
{
  char **col;
  int w, h;

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

  operator char **()
  {
    return col;
  }

  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

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

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 (const Layout &layout) const
  {
    ::swap (layout.ptr->col, ptr->col);
    ::swap (layout.ptr->w  , ptr->w  );
    ::swap (layout.ptr->h  , ptr->h  );
  }

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

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

struct point
{
  short x;
  short y;

  point ()
  {
  }

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

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