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 treasurestyle[512];
  char layoutstyle[512];
  char doorstyle[512];
  char decorstyle[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 decoroptions;
  int orientation;
  int origin_y;
  int origin_x;
  uint32_t random_seed;
  uint64_t total_map_hp;
  int map_layout_style;
  int treasureoptions;
  int symmetry_used;

  struct region *region;

  HV *hv;

  // fetch something from the options hash
  const_utf8_string get_str (const_utf8_string option, const_utf8_string fallback = "") const;
  IV                get_iv  (const_utf8_string option, IV                fallback =  0) const;

  void set (const_utf8_string option, const_utf8_string value);
  void set (const_utf8_string 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 : zero_initialised
{
  char **col;
  int w, h;

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

  operator char **()
  {
    return col;
  }

  void clear (char fill = 0);
  void border (char fill = '#');
};

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

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

#endif

Revision:	1.26
Committed:	Sat Jun 26 22:10:18 2010 UTC (13 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.25:	+12 -6 lines
Log Message:	* empty log message *
#	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 treasurestyle[512];
35	char layoutstyle[512];
36	char doorstyle[512];
37	char decorstyle[512];
38	shstr origin_map;
39	shstr final_map;
40	shstr this_map;
41	char exit_on_final_map[512];
42
43	int xsize, ysize;
44	int expand2x;
45	int layoutoptions1;
46	int layoutoptions2;
47	int layoutoptions3;
48	int symmetry;
49	int difficulty;
50	int difficulty_given;
51	float difficulty_increase;
52
53	int dungeon_level;
54	int dungeon_depth;
55
56	int decoroptions;
57	int orientation;
58	int origin_y;
59	int origin_x;
60	uint32_t random_seed;
61	uint64_t total_map_hp;
62	int map_layout_style;
63	int treasureoptions;
64	int symmetry_used;
65
66	struct region *region;
67
68	HV *hv;
69
70	// fetch something from the options hash
71	const_utf8_string get_str (const_utf8_string option, const_utf8_string fallback = "") const;
72	IV get_iv (const_utf8_string option, IV fallback = 0) const;
73
74	void set (const_utf8_string option, const_utf8_string value);
75	void set (const_utf8_string option, IV value);
76
77	// "private", adjusted sizes
78	int Xsize;
79	int Ysize;
80
81	~random_map_params ();
82	};
83
84	enum {
85	LAYOUT_NONE,
86	LAYOUT_ONION,
87	LAYOUT_MAZE,
88	LAYOUT_SPIRAL,
89	LAYOUT_ROGUELIKE,
90	LAYOUT_SNAKE,
91	LAYOUT_SQUARE_SPIRAL,
92	NROFLAYOUTS,
93	};
94
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	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
122	/* symmetry definitions--used in this file AND in treasure.c:
123	the numerical values matter so don't change them. */
124	enum {
125	SYMMETRY_RANDOM,
126	SYMMETRY_NONE,
127	SYMMETRY_X,
128	SYMMETRY_Y,
129	SYMMETRY_XY,
130	};
131
132	// 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
137	// reference
138	//
139	// \0 floor only
140	// # wall
141	// D door
142	// < up
143	// > down
144	// C "center" (of onion layout)
145	// . ?? (rogue)
146	//
147
148	struct LayoutData : zero_initialised
149	{
150	char **col;
151	int w, h;
152
153	LayoutData (int w, int h);
154	~LayoutData ();
155
156	operator char **()
157	{
158	return col;
159	}
160
161	void clear (char fill = 0);
162	void border (char fill = '#');
163	};
164
165	struct Layout
166	{
167	LayoutData *ptr;
168
169	Layout ()
170	{
171	}
172
173	Layout (int xsize, int ysize)
174	: ptr (new LayoutData (xsize, ysize))
175	{
176	}
177
178	Layout (random_map_params *RP)
179	: ptr (new LayoutData (RP->Xsize, RP->Ysize))
180	{
181	}
182
183	void free ()
184	{
185	delete ptr;
186	}
187
188	LayoutData *operator ->() const
189	{
190	return ptr;
191	}
192
193	operator char **() const
194	{
195	return *ptr;
196	}
197
198	void swap (const Layout &layout) const
199	{
200	::swap (layout.ptr->col, ptr->col);
201	::swap (layout.ptr->w , ptr->w );
202	::swap (layout.ptr->h , ptr->h );
203	}
204	};
205
206	// utility functions, to use rmg_rndm instead of rndm.
207	static inline int
208	rmg_find_free_spot (const object ob, maptile m, int x, int y, int start, int stop)
209	{
210	swap (rmg_rndm, rndm);
211	int i = find_free_spot (ob, m, x, y, start, stop);
212	swap (rmg_rndm, rndm);
213	return i;
214	}
215
216	#endif
217