server/random_maps/random_map.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify
 * it under the terms of the 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 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
{
  char wallstyle[512];
  char wall_name[512];
  char floorstyle[512];
  char monsterstyle[512];
  char treasurestyle[512];
  char layoutstyle[512];
  char doorstyle[512];
  char decorstyle[512];
  shstr origin_map;
  shstr final_map;
  char exitstyle[512];
  shstr this_map;
  char exit_on_final_map[512];
  char *custom;
        
  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;

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

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

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

#endif

Revision:	1.19
Committed:	Tue Apr 15 03:00:24 2008 UTC (16 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.18:	+15 -15 lines
Log Message:	new logging thread, fix bugs in random map generator
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your 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 GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/
23
24	#ifndef RANDOM_MAP_H
25	#define RANDOM_MAP_H
26
27	#include "util.h"
28
29	struct random_map_params
30	{
31	char wallstyle[512];
32	char wall_name[512];
33	char floorstyle[512];
34	char monsterstyle[512];
35	char treasurestyle[512];
36	char layoutstyle[512];
37	char doorstyle[512];
38	char decorstyle[512];
39	shstr origin_map;
40	shstr final_map;
41	char exitstyle[512];
42	shstr this_map;
43	char exit_on_final_map[512];
44	char *custom;
45
46	int xsize, ysize;
47	int expand2x;
48	int layoutoptions1;
49	int layoutoptions2;
50	int layoutoptions3;
51	int symmetry;
52	int difficulty;
53	int difficulty_given;
54	float difficulty_increase;
55
56	int dungeon_level;
57	int dungeon_depth;
58
59	int decoroptions;
60	int orientation;
61	int origin_y;
62	int origin_x;
63	uint32_t random_seed;
64	uint64_t total_map_hp;
65	int map_layout_style;
66	int treasureoptions;
67	int symmetry_used;
68
69	struct region *region;
70
71	// "private", adjusted sizes
72	int Xsize;
73	int Ysize;
74	};
75
76	enum {
77	LAYOUT_NONE,
78	LAYOUT_ONION,
79	LAYOUT_MAZE,
80	LAYOUT_SPIRAL,
81	LAYOUT_ROGUELIKE,
82	LAYOUT_SNAKE,
83	LAYOUT_SQUARE_SPIRAL,
84	NROFLAYOUTS,
85	};
86
87	/*
88	* Move these defines out of room_gen_onion.c to here, as
89	* other files (like square_spiral) also uses them.
90
91	options:
92	0 Pick random options below
93	1 "centered"
94	2 linear doors (default is nonlinear)
95	4 bottom "centered"
96	8 bottom-right centered
97	16 irregularly/randomly spaced layers (default: regular)
98	32 outer wall off: i.e., no outer wall.
99
100	*/
101
102	enum {
103	RMOPT_RANDOM = 0,
104	RMOPT_CENTERED = 1,
105	RMOPT_LINEAR = 2,
106	RMOPT_BOTTOM_C = 4,
107	RMOPT_BOTTOM_R = 8,
108	RMOPT_IRR_SPACE = 16,
109	RMOPT_WALL_OFF = 32,
110	RMOPT_WALLS_ONLY = 64,
111	RMOPT_NO_DOORS = 256, /* Place walls insead of doors. Produces broken map. */
112	};
113
114	/* symmetry definitions--used in this file AND in treasure.c:
115	the numerical values matter so don't change them. */
116	enum {
117	SYMMETRY_RANDOM,
118	SYMMETRY_NONE,
119	SYMMETRY_X,
120	SYMMETRY_Y,
121	SYMMETRY_XY,
122	};
123
124	// 12 has been experimentally :( determined ot be a lot more stable
125	// than 11 or 10, leading to the assumption that something inherently
126	// needs a minimum size of at least 12
127	#define MIN_RANDOM_MAP_SIZE 12
128
129	struct LayoutData : zero_initialised
130	{
131	char **col;
132	int w, h;
133
134	LayoutData (int w, int h);
135	~LayoutData ();
136
137	operator char **()
138	{
139	return col;
140	}
141
142	void clear (char fill = 0);
143	void border (char fill = '#');
144	};
145
146	struct Layout
147	{
148	LayoutData *ptr;
149
150	Layout ()
151	{
152	}
153
154	Layout (int xsize, int ysize)
155	: ptr (new LayoutData (xsize, ysize))
156	{
157	}
158
159	Layout (random_map_params *RP)
160	: ptr (new LayoutData (RP->Xsize, RP->Ysize))
161	{
162	}
163
164	void free ()
165	{
166	delete ptr;
167	}
168
169	LayoutData *operator ->() const
170	{
171	return ptr;
172	}
173
174	operator char **() const
175	{
176	return *ptr;
177	}
178
179	void swap (const Layout &layout) const
180	{
181	::swap (layout.ptr->col, ptr->col);
182	::swap (layout.ptr->w , ptr->w );
183	::swap (layout.ptr->h , ptr->h );
184	}
185	};
186
187	#endif
188