ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/random_maps/random_map.C
(Generate patch)

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.9 by root, Thu Dec 14 22:45:40 2006 UTC vs.
Revision 1.41 by root, Thu May 8 13:47:19 2008 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
20 21 * The authors can be reached via e-mail to <support@deliantra.net>
21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22 */
23 23
24#include <time.h> 24#include <time.h>
25#include <stdio.h> 25#include <stdio.h>
26#include <global.h> 26#include <global.h>
27#include <maze_gen.h>
28#include <room_gen.h>
29#include <random_map.h> 27#include <random_map.h>
30#include <rproto.h> 28#include <rproto.h>
31#include <sproto.h> 29#include <sproto.h>
32 30
31#define CEDE coroapi::cede_to_tick ()
32
33static void symmetrize_layout (Layout maze, random_map_params *RP);
34static void rotate_layout (Layout maze, int rotation);
35
33void 36void
34dump_layout (char **layout, RMParms * RP) 37dump_layout (Layout layout)
35{ 38{
36 { 39 for (int j = 0; j < layout->h; j++)
37 int i, j;
38
39 for (i = 0; i < RP->Xsize; i++)
40 { 40 {
41 for (j = 0; j < RP->Ysize; j++) 41 for (int i = 0; i < layout->w; i++)
42 { 42 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
43 if (layout[i][j] == 0) 43
44 layout[i][j] = ' '; 44 putc ('\n', stdout);
45 printf ("%c", layout[i][j]);
46 if (layout[i][j] == ' ')
47 layout[i][j] = 0;
48 }
49 printf ("\n");
50 } 45 }
51 }
52 printf ("\n");
53}
54 46
55extern FILE *logfile; 47 putc ('\n', stdout);
48}
56 49
57maptile * 50bool
58generate_random_map (const char *OutFileName, RMParms * RP) 51maptile::generate_random_map (random_map_params *RP)
59{ 52{
60 char **layout, buf[HUGE_BUF]; 53 char buf[16384];
61 maptile *theMap;
62 int i; 54 int i;
63 55
56 RP->Xsize = RP->xsize;
57 RP->Ysize = RP->ysize;
58
64 /* pick a random seed, or use the one from the input file */ 59 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 60 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 61 ? RP->random_seed + RP->dungeon_level
62 : time (0);
67 63
68 SRANDOM (RP->random_seed); 64 // we run "single-threaded"
65 rmg_rndm.seed (RP->random_seed);
69 66
70 write_map_parameters_to_string (buf, RP); 67 write_map_parameters_to_string (buf, RP);
71 68
72 if (RP->difficulty == 0) 69 if (RP->difficulty == 0)
73 { 70 {
… …
81 } 78 }
82 else 79 else
83 RP->difficulty_given = 1; 80 RP->difficulty_given = 1;
84 81
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 82 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 83 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
87 84
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 85 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 86 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
87
88 if (RP->symmetry == SYMMETRY_RANDOM)
89 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
90 else
91 RP->symmetry_used = RP->symmetry;
92
93 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
94 RP->Ysize = RP->Ysize / 2 + 1;
95
96 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
97 RP->Xsize = RP->Xsize / 2 + 1;
90 98
91 if (RP->expand2x > 0) 99 if (RP->expand2x > 0)
92 { 100 {
93 RP->Xsize /= 2; 101 RP->Xsize /= 2;
94 RP->Ysize /= 2; 102 RP->Ysize /= 2;
95 } 103 }
96 104
97 layout = layoutgen (RP);
98
99#ifdef RMAP_DEBUG
100 dump_layout (layout, RP);
101#endif
102
103 /* increment these for the current map */
104 RP->dungeon_level += 1;
105 /* allow constant-difficulty maps. */
106 /* difficulty+=1; */
107
108 /* rotate the layout randomly */
109 layout = rotate_layout (layout, RANDOM () % 4, RP);
110#ifdef RMAP_DEBUG
111 dump_layout (layout, RP);
112#endif
113
114 /* allocate the map and set the floor */
115 theMap = make_map_floor (layout, RP->floorstyle, RP);
116
117 /* set the name of the map. */
118 strcpy (theMap->path, OutFileName);
119
120 /* set region */
121 theMap->region = RP->region;
122
123 /* create walls unless the wallstyle is "none" */
124 if (strcmp (RP->wallstyle, "none"))
125 {
126 make_map_walls (theMap, layout, RP->wallstyle, RP);
127
128 /* place doors unless doorstyle or wallstyle is "none" */
129 if (strcmp (RP->doorstyle, "none"))
130 put_doors (theMap, layout, RP->doorstyle, RP);
131
132 }
133
134 /* create exits unless the exitstyle is "none" */
135 if (strcmp (RP->exitstyle, "none"))
136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
137
138 place_specials_in_map (theMap, layout, RP);
139
140 /* create monsters unless the monsterstyle is "none" */
141 if (strcmp (RP->monsterstyle, "none"))
142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
143
144 /* treasures needs to have a proper difficulty set for the map. */
145 theMap->difficulty = calculate_difficulty (theMap);
146
147 /* create treasure unless the treasurestyle is "none" */
148 if (strcmp (RP->treasurestyle, "none"))
149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
150
151 /* create decor unless the decorstyle is "none" */
152 if (strcmp (RP->decorstyle, "none"))
153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
154
155 /* generate treasures, etc. */
156 fix_auto_apply (theMap);
157
158 unblock_exits (theMap, layout, RP);
159
160 /* free the layout */
161 for (i = 0; i < RP->Xsize; i++)
162 free (layout[i]);
163 free (layout);
164
165 theMap->msg = strdup (buf);
166
167 return theMap;
168}
169
170/* function selects the layout function and gives it whatever
171 arguments it needs. */
172char **
173layoutgen (RMParms * RP)
174{
175 char **maze = 0;
176 int oxsize = RP->Xsize, oysize = RP->Ysize;
177
178 if (RP->symmetry == RANDOM_SYM)
179 RP->symmetry_used = (RANDOM () % (XY_SYM)) + 1;
180 else
181 RP->symmetry_used = RP->symmetry;
182
183 if (RP->symmetry_used == Y_SYM || RP->symmetry_used == XY_SYM)
184 RP->Ysize = RP->Ysize / 2 + 1;
185 if (RP->symmetry_used == X_SYM || RP->symmetry_used == XY_SYM)
186 RP->Xsize = RP->Xsize / 2 + 1;
187
188 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
189 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
191 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192 RP->map_layout_style = 0; 105 RP->map_layout_style = LAYOUT_NONE;
193 106
194 /* Redo this - there was a lot of redundant code of checking for preset 107 /* Redo this - there was a lot of redundant code of checking for preset
195 * layout style and then random layout style. Instead, figure out 108 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 109 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 110 * calls the code to make the maps.
198 */ 111 */
199 if (strstr (RP->layoutstyle, "onion")) 112 if (strstr (RP->layoutstyle, "onion"))
200 {
201 RP->map_layout_style = ONION_LAYOUT; 113 RP->map_layout_style = LAYOUT_ONION;
202 }
203
204 if (strstr (RP->layoutstyle, "maze")) 114 else if (strstr (RP->layoutstyle, "maze"))
205 {
206 RP->map_layout_style = MAZE_LAYOUT; 115 RP->map_layout_style = LAYOUT_MAZE;
207 }
208
209 if (strstr (RP->layoutstyle, "spiral")) 116 else if (strstr (RP->layoutstyle, "spiral"))
210 {
211 RP->map_layout_style = SPIRAL_LAYOUT; 117 RP->map_layout_style = LAYOUT_SPIRAL;
212 }
213
214 if (strstr (RP->layoutstyle, "rogue")) 118 else if (strstr (RP->layoutstyle, "rogue"))
215 {
216 RP->map_layout_style = ROGUELIKE_LAYOUT; 119 RP->map_layout_style = LAYOUT_ROGUELIKE;
217 }
218
219 if (strstr (RP->layoutstyle, "snake")) 120 else if (strstr (RP->layoutstyle, "snake"))
220 {
221 RP->map_layout_style = SNAKE_LAYOUT; 121 RP->map_layout_style = LAYOUT_SNAKE;
222 }
223
224 if (strstr (RP->layoutstyle, "squarespiral")) 122 else if (strstr (RP->layoutstyle, "squarespiral"))
225 {
226 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 123 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
124 else if (RP->map_layout_style == LAYOUT_NONE)
125 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
126 else
127 abort ();
128
129 Layout layout = layoutgen (RP);
130
131#ifdef RMAP_DEBUG
132 dump_layout (layout);
133#endif
134
135 /* increment these for the current map */
136 ++RP->dungeon_level;
137
138 // need to patch RP becasue following code doesn't use the Layout object
139 RP->Xsize = layout->w;
140 RP->Ysize = layout->h;
141
142 /* allocate the map and set the floor */
143 make_map_floor (layout, RP->floorstyle, RP);
144
145 /* set region */
146 default_region = RP->region;
147
148 CEDE;
149
150 place_specials_in_map (this, layout, RP);
151
152 CEDE;
153
154 /* create walls unless the wallstyle is "none" */
155 if (strcmp (RP->wallstyle, "none"))
227 } 156 {
228 /* No style found - choose one ranomdly */ 157 make_map_walls (this, layout, RP->wallstyle, RP);
229 if (RP->map_layout_style == 0) 158
159 /* place doors unless doorstyle or wallstyle is "none" */
160 if (strcmp (RP->doorstyle, "none"))
161 put_doors (this, layout, RP->doorstyle, RP);
230 { 162 }
231 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 163
232 } 164 CEDE;
165
166 /* create exits unless the exitstyle is "none" */
167 if (strcmp (RP->exitstyle, "none"))
168 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
169
170 CEDE;
171
172 /* create monsters unless the monsterstyle is "none" */
173 if (strcmp (RP->monsterstyle, "none"))
174 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
175
176 CEDE;
177
178 /* treasures needs to have a proper difficulty set for the map. */
179 difficulty = estimate_difficulty ();
180
181 CEDE;
182
183 /* create treasure unless the treasurestyle is "none" */
184 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
185
186 CEDE;
187
188 /* create decor unless the decorstyle is "none" */
189 if (strcmp (RP->decorstyle, "none"))
190 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
191
192 CEDE;
193
194 /* generate treasures, etc. */
195 fix_auto_apply ();
196
197 CEDE;
198
199 unblock_exits (this, layout, RP);
200
201 msg = strdup (buf);
202 in_memory = MAP_ACTIVE;
203
204 CEDE;
205
206 return 1;
207}
208
209/* function selects the layout function and gives it whatever
210 arguments it needs. */
211Layout
212layoutgen (random_map_params *RP)
213{
214 Layout layout (RP);
233 215
234 switch (RP->map_layout_style) 216 switch (RP->map_layout_style)
235 { 217 {
236 218 case LAYOUT_ONION:
237 case ONION_LAYOUT:
238 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 219 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
220
239 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 221 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
240 roomify_layout (maze, RP); 222 roomify_layout (layout, RP);
223
241 break; 224 break;
242 225
243 case MAZE_LAYOUT: 226 case LAYOUT_MAZE:
244 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 227 maze_gen (layout, rmg_rndm (2));
245 if (!(RANDOM () % 2)) 228
229 if (!(rmg_rndm (2)))
246 doorify_layout (maze, RP); 230 doorify_layout (layout, RP);
231
247 break; 232 break;
248 233
249 case SPIRAL_LAYOUT: 234 case LAYOUT_SPIRAL:
250 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 235 map_gen_spiral (layout, RP->layoutoptions1);
251 if (!(RANDOM () % 2)) 236
237 if (!(rmg_rndm (2)))
252 doorify_layout (maze, RP); 238 doorify_layout (layout, RP);
239
253 break; 240 break;
254 241
255 case ROGUELIKE_LAYOUT: 242 case LAYOUT_ROGUELIKE:
256 /* Don't put symmetry in rogue maps. There isn't much reason to 243 /* Don't put symmetry in rogue maps. There isn't much reason to
257 * do so in the first place (doesn't make it any more interesting), 244 * do so in the first place (doesn't make it any more interesting),
258 * but more importantly, the symmetry code presumes we are symmetrizing 245 * but more importantly, the symmetry code presumes we are symmetrizing
259 * spirals, or maps with lots of passages - making a symmetric rogue 246 * spirals, or maps with lots of passages - making a symmetric rogue
260 * map fails because its likely that the passages the symmetry process 247 * map fails because its likely that the passages the symmetry process
261 * creates may not connect the rooms. 248 * creates may not connect the rooms.
262 */ 249 */
263 RP->symmetry_used = NO_SYM; 250 RP->symmetry_used = SYMMETRY_NONE;
264 RP->Ysize = oysize; 251 roguelike_layout_gen (layout, RP->layoutoptions1);
265 RP->Xsize = oxsize;
266 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
267 /* no doorifying... done already */ 252 /* no doorifying... done already */
268 break; 253 break;
269 254
270 case SNAKE_LAYOUT: 255 case LAYOUT_SNAKE:
271 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 256 make_snake_layout (layout, RP->layoutoptions1);
272 if (RANDOM () % 2) 257
258 if (rmg_rndm (2))
273 roomify_layout (maze, RP); 259 roomify_layout (layout, RP);
260
274 break; 261 break;
275 262
276 case SQUARE_SPIRAL_LAYOUT: 263 case LAYOUT_SQUARE_SPIRAL:
277 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 264 make_square_spiral_layout (layout, RP->layoutoptions1);
278 if (RANDOM () % 2) 265
266 if (rmg_rndm (2))
279 roomify_layout (maze, RP); 267 roomify_layout (layout, RP);
268
280 break; 269 break;
281 }
282 270
283 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 271 default:
272 abort ();
273 }
274
275 /* rotate the layout randomly */
276 rotate_layout (layout, rmg_rndm (4));
277
278 symmetrize_layout (layout, RP);
279
284#ifdef RMAP_DEBUG 280#ifdef RMAP_DEBUG
285 dump_layout (maze, RP); 281 dump_layout (layout);
286#endif 282#endif
283
287 if (RP->expand2x) 284 if (RP->expand2x)
288 { 285 expand2x (layout);
289 maze = expand2x (maze, RP->Xsize, RP->Ysize);
290 RP->Xsize = RP->Xsize * 2 - 1;
291 RP->Ysize = RP->Ysize * 2 - 1;
292 }
293 return maze;
294}
295 286
287 return layout;
288}
296 289
297/* takes a map and makes it symmetric: adjusts Xsize and 290/* takes a map and makes it symmetric: adjusts Xsize and
298Ysize to produce a symmetric map. */ 291 * Ysize to produce a symmetric map.
299 292 */
300char ** 293static void
301symmetrize_layout (char **maze, int sym, RMParms * RP) 294symmetrize_layout (Layout layout, random_map_params *RP)
302{ 295{
303 int i, j; 296 if (RP->symmetry_used == SYMMETRY_NONE)
304 char **sym_maze;
305 int Xsize_orig, Ysize_orig;
306
307 Xsize_orig = RP->Xsize;
308 Ysize_orig = RP->Ysize;
309 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
310 if (sym == NO_SYM)
311 {
312 RP->Xsize = Xsize_orig;
313 RP->Ysize = Ysize_orig;
314 return maze; 297 return;
315 }
316 /* pick new sizes */
317 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize);
318 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize);
319 298
320 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 299 Layout sym_layout (
321 for (i = 0; i < RP->Xsize; i++) 300 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
322 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 301 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
302 );
323 303
324 if (sym == X_SYM) 304 if (RP->symmetry_used == SYMMETRY_X)
325 for (i = 0; i < RP->Xsize / 2 + 1; i++) 305 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
326 for (j = 0; j < RP->Ysize; j++) 306 for (int j = 0; j < sym_layout->h; j++)
327 { 307 {
328 sym_maze[i][j] = maze[i][j]; 308 sym_layout[i ][j] =
329 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 309 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
330 }; 310 }
331 if (sym == Y_SYM) 311
332 for (i = 0; i < RP->Xsize; i++) 312 if (RP->symmetry_used == SYMMETRY_Y)
313 for (int i = 0; i < sym_layout->w; i++)
333 for (j = 0; j < RP->Ysize / 2 + 1; j++) 314 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
334 {
335 sym_maze[i][j] = maze[i][j];
336 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
337 } 315 {
338 if (sym == XY_SYM) 316 sym_layout[i][j ] =
339 for (i = 0; i < RP->Xsize / 2 + 1; i++) 317 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
340 for (j = 0; j < RP->Ysize / 2 + 1; j++)
341 { 318 }
342 sym_maze[i][j] = maze[i][j]; 319
343 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 320 if (RP->symmetry_used == SYMMETRY_XY)
344 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 321 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
345 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j]; 322 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
346 } 323 {
347 /* delete the old maze */ 324 sym_layout[i ][j ] =
348 for (i = 0; i < Xsize_orig; i++) 325 sym_layout[i ][sym_layout->h - j - 1] =
349 free (maze[i]); 326 sym_layout[sym_layout->w - i - 1][j ] =
350 free (maze); 327 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
328 }
329
330 layout.swap (sym_layout);
331 sym_layout.free ();
332
351 /* reconnect disjointed spirals */ 333 /* reconnect disjointed spirals */
352 if (RP->map_layout_style == SPIRAL_LAYOUT)
353 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
354 /* reconnect disjointed nethackmazes: the routine for 334 /* reconnect disjointed nethacklayouts: the routine for
355 spirals will do the trick? */ 335 spirals will do the trick? */
356 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 336 if (RP->map_layout_style == LAYOUT_SPIRAL
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 337 || RP->map_layout_style == LAYOUT_ROGUELIKE)
358 338 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
359 return sym_maze;
360} 339}
361
362 340
363/* takes a map and rotates it. This completes the 341/* takes a map and rotates it. This completes the
364 onion layouts, making them possibly centered on any wall. 342 onion layouts, making them possibly centered on any wall.
365 It'll modify Xsize and Ysize if they're swapped. 343 It'll modify Xsize and Ysize if they're swapped.
366*/ 344*/
367 345static void
368char ** 346rotate_layout (Layout layout, int rotation)
369rotate_layout (char **maze, int rotation, RMParms * RP)
370{ 347{
371 char **new_maze; 348 int w = layout->w;
372 int i, j; 349 int h = layout->h;
373 350
374 switch (rotation) 351 switch (rotation)
375 { 352 {
376 case 0:
377 return maze;
378 break;
379 case 2: /* a reflection */ 353 case 2: /* a reflection */
380 { 354 {
381 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 355 Layout new_layout (w, h);
382 356
383 for (i = 0; i < RP->Xsize; i++) 357 for (int i = 0; i < w; i++) /* copy a reflection back */
384 { /* make a copy */
385 for (j = 0; j < RP->Ysize; j++) 358 for (int j = 0; j < h; j++)
386 { 359 new_layout[i][j] = layout[w - i - 1][h - j - 1];
387 newmaze[i * RP->Ysize + j] = maze[i][j]; 360
388 } 361 layout.swap (new_layout);
389 } 362 new_layout.free ();
390 for (i = 0; i < RP->Xsize; i++)
391 { /* copy a reflection back */
392 for (j = 0; j < RP->Ysize; j++)
393 {
394 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
395 }
396 }
397 free (newmaze);
398 return maze;
399 break;
400 } 363 }
364 break;
365
401 case 1: 366 case 1:
402 case 3: 367 case 3:
403 { 368 {
404 int swap; 369 Layout new_layout (h, w);
405 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 370
406 for (i = 0; i < RP->Ysize; i++)
407 {
408 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
409 }
410 if (rotation == 1) /* swap x and y */ 371 if (rotation == 1) /* swap x and y */
411 for (i = 0; i < RP->Xsize; i++)
412 for (j = 0; j < RP->Ysize; j++)
413 new_maze[j][i] = maze[i][j];
414
415 if (rotation == 3)
416 { /* swap x and y */
417 for (i = 0; i < RP->Xsize; i++)
418 for (j = 0; j < RP->Ysize; j++)
419 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
420 }
421
422 /* delete the old layout */
423 for (i = 0; i < RP->Xsize; i++) 372 for (int i = 0; i < w; i++)
424 free (maze[i]); 373 for (int j = 0; j < h; j++)
425 free (maze); 374 new_layout[j][i] = layout[i][j];
426 375
427 swap = RP->Ysize; 376 if (rotation == 3) /* swap x and y */
428 RP->Ysize = RP->Xsize; 377 for (int i = 0; i < w; i++)
429 RP->Xsize = swap; 378 for (int j = 0; j < h; j++)
430 return new_maze; 379 new_layout[j][i] = layout[w - i - 1][h - j - 1];
431 break; 380
381 layout.swap (new_layout);
382 new_layout.free ();
432 } 383 }
384 break;
433 } 385 }
434 return NULL;
435} 386}
436 387
437/* take a layout and make some rooms in it. 388/* take a layout and make some rooms in it.
438 --works best on onions.*/ 389 --works best on onions.*/
439void 390void
440roomify_layout (char **maze, RMParms * RP) 391roomify_layout (char **maze, random_map_params *RP)
441{ 392{
442 int tries = RP->Xsize * RP->Ysize / 30; 393 int tries = RP->Xsize * RP->Ysize / 30;
443 int ti; 394 int ti;
444 395
445 for (ti = 0; ti < tries; ti++) 396 for (ti = 0; ti < tries; ti++)
446 { 397 {
447 int dx, dy; /* starting location for looking at creating a door */ 398 int dx, dy; /* starting location for looking at creating a door */
448 int cx, cy; /* results of checking on creating walls. */ 399 int cx, cy; /* results of checking on creating walls. */
449 400
450 dx = RANDOM () % RP->Xsize; 401 dx = rmg_rndm (RP->Xsize);
451 dy = RANDOM () % RP->Ysize; 402 dy = rmg_rndm (RP->Ysize);
403
452 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 404 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
453 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 405 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
454 if (cx == -1) 406 if (cx == -1)
455 { 407 {
456 if (cy != -1) 408 if (cy != -1)
457 make_wall (maze, dx, dy, 1); 409 make_wall (maze, dx, dy, 1);
410
458 continue; 411 continue;
459 } 412 }
413
460 if (cy == -1) 414 if (cy == -1)
461 { 415 {
462 make_wall (maze, dx, dy, 0); 416 make_wall (maze, dx, dy, 0);
463 continue; 417 continue;
464 } 418 }
419
465 if (cx < cy) 420 if (cx < cy)
466 make_wall (maze, dx, dy, 0); 421 make_wall (maze, dx, dy, 0);
467 else 422 else
468 make_wall (maze, dx, dy, 1); 423 make_wall (maze, dx, dy, 1);
469 } 424 }
… …
472/* checks the layout to see if I can stick a horizontal(dir = 0) wall 427/* checks the layout to see if I can stick a horizontal(dir = 0) wall
473 (or vertical, dir == 1) 428 (or vertical, dir == 1)
474 here which ends up on other walls sensibly. */ 429 here which ends up on other walls sensibly. */
475 430
476int 431int
477can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 432can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
478{ 433{
479 int i1; 434 int i1;
480 int length = 0; 435 int length = 0;
481 436
482 /* dont make walls if we're on the edge. */ 437 /* dont make walls if we're on the edge. */
… …
557make_wall (char **maze, int x, int y, int dir) 512make_wall (char **maze, int x, int y, int dir)
558{ 513{
559 maze[x][y] = 'D'; /* mark a door */ 514 maze[x][y] = 'D'; /* mark a door */
560 switch (dir) 515 switch (dir)
561 { 516 {
562 case 0: /* horizontal */ 517 case 0: /* horizontal */
563 { 518 {
564 int i1; 519 int i1;
565 520
566 for (i1 = x - 1; maze[i1][y] == 0; i1--) 521 for (i1 = x - 1; maze[i1][y] == 0; i1--)
567 maze[i1][y] = '#'; 522 maze[i1][y] = '#';
568 for (i1 = x + 1; maze[i1][y] == 0; i1++) 523 for (i1 = x + 1; maze[i1][y] == 0; i1++)
569 maze[i1][y] = '#'; 524 maze[i1][y] = '#';
570 break; 525 break;
571 } 526 }
572 case 1: /* vertical */ 527 case 1: /* vertical */
573 { 528 {
574 int i1; 529 int i1;
575 530
576 for (i1 = y - 1; maze[x][i1] == 0; i1--) 531 for (i1 = y - 1; maze[x][i1] == 0; i1--)
577 maze[x][i1] = '#'; 532 maze[x][i1] = '#';
578 for (i1 = y + 1; maze[x][i1] == 0; i1++) 533 for (i1 = y + 1; maze[x][i1] == 0; i1++)
579 maze[x][i1] = '#'; 534 maze[x][i1] = '#';
580 break; 535 break;
581 } 536 }
582 } 537 }
583 538
584 return 0; 539 return 0;
585} 540}
586 541
587/* puts doors at appropriate locations in a layout. */ 542/* puts doors at appropriate locations in a layout. */
588
589void 543void
590doorify_layout (char **maze, RMParms * RP) 544doorify_layout (char **maze, random_map_params *RP)
591{ 545{
592 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 546 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
593 char *doorlist_x;
594 char *doorlist_y;
595 int doorlocs = 0; /* # of available doorlocations */ 547 int doorlocs = 0; /* # of available doorlocations */
596 int i, j;
597 548
598 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
599 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
600
601 551
602 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
603 for (i = 1; i < RP->Xsize - 1; i++) 553 for (int i = 1; i < RP->Xsize - 1; i++)
604 for (j = 1; j < RP->Ysize - 1; j++) 554 for (int j = 1; j < RP->Ysize - 1; j++)
605 { 555 {
606 int sindex = surround_flag (maze, i, j, RP); 556 int sindex = surround_flag (maze, i, j, RP);
607 557
608 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 558 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
609 { 559 {
610 doorlist_x[doorlocs] = i; 560 doorlist_x[doorlocs] = i;
611 doorlist_y[doorlocs] = j; 561 doorlist_y[doorlocs] = j;
612 doorlocs++; 562 doorlocs++;
613 } 563 }
614 } 564 }
565
615 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
616 { 567 {
617 int di; 568 int di = rmg_rndm (doorlocs);
618 int sindex;
619
620 di = RANDOM () % doorlocs;
621 i = doorlist_x[di]; 569 int i = doorlist_x[di];
622 j = doorlist_y[di]; 570 int j = doorlist_y[di];
623 sindex = surround_flag (maze, i, j, RP); 571 int sindex = surround_flag (maze, i, j, RP);
572
624 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 573 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
625 { 574 {
626 maze[i][j] = 'D'; 575 maze[i][j] = 'D';
627 ndoors--; 576 ndoors--;
628 } 577 }
578
629 /* reduce the size of the list */ 579 /* reduce the size of the list */
630 doorlocs--; 580 doorlocs--;
631 doorlist_x[di] = doorlist_x[doorlocs]; 581 doorlist_x[di] = doorlist_x[doorlocs];
632 doorlist_y[di] = doorlist_y[doorlocs]; 582 doorlist_y[di] = doorlist_y[doorlocs];
633 } 583 }
634 free (doorlist_x);
635 free (doorlist_y);
636}
637 584
585 sfree (doorlist_x, RP->Xsize * RP->Ysize);
586 sfree (doorlist_y, RP->Xsize * RP->Ysize);
587}
638 588
639void 589void
640write_map_parameters_to_string (char *buf, RMParms * RP) 590write_map_parameters_to_string (char *buf, random_map_params *RP)
641{ 591{
642
643 char small_buf[256]; 592 char small_buf[16384];
644 593
645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 594 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
646 595
647 if (RP->wallstyle[0]) 596 if (RP->wallstyle[0])
648 { 597 {
649 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 598 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
650 strcat (buf, small_buf); 599 strcat (buf, small_buf);
… …
690 { 639 {
691 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 640 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
692 strcat (buf, small_buf); 641 strcat (buf, small_buf);
693 } 642 }
694 643
695 if (RP->final_map[0]) 644 if (RP->final_map.length ())
696 { 645 {
697 sprintf (small_buf, "final_map %s\n", RP->final_map); 646 sprintf (small_buf, "final_map %s\n", &RP->final_map);
698 strcat (buf, small_buf); 647 strcat (buf, small_buf);
699 } 648 }
700 649
701 if (RP->exit_on_final_map[0]) 650 if (RP->exit_on_final_map[0])
702 { 651 {
703 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 652 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
704 strcat (buf, small_buf); 653 strcat (buf, small_buf);
705 } 654 }
706 655
707 if (RP->this_map[0]) 656 if (RP->this_map.length ())
708 { 657 {
709 sprintf (small_buf, "origin_map %s\n", RP->this_map); 658 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
710 strcat (buf, small_buf); 659 strcat (buf, small_buf);
711 } 660 }
712 661
713 if (RP->expand2x) 662 if (RP->expand2x)
714 { 663 {
… …
720 { 669 {
721 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 670 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
722 strcat (buf, small_buf); 671 strcat (buf, small_buf);
723 } 672 }
724 673
725
726 if (RP->layoutoptions2) 674 if (RP->layoutoptions2)
727 { 675 {
728 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 676 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
729 strcat (buf, small_buf); 677 strcat (buf, small_buf);
730 } 678 }
731 679
732
733 if (RP->layoutoptions3) 680 if (RP->layoutoptions3)
734 { 681 {
735 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 682 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
736 strcat (buf, small_buf); 683 strcat (buf, small_buf);
737 } 684 }
… …
739 if (RP->symmetry) 686 if (RP->symmetry)
740 { 687 {
741 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 688 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
742 strcat (buf, small_buf); 689 strcat (buf, small_buf);
743 } 690 }
744
745 691
746 if (RP->difficulty && RP->difficulty_given) 692 if (RP->difficulty && RP->difficulty_given)
747 { 693 {
748 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 694 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
749 strcat (buf, small_buf); 695 strcat (buf, small_buf);
… …
785 if (RP->origin_y) 731 if (RP->origin_y)
786 { 732 {
787 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 733 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
788 strcat (buf, small_buf); 734 strcat (buf, small_buf);
789 } 735 }
736
737 if (RP->treasureoptions)
738 {
739 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
740 strcat (buf, small_buf);
741 }
742
790 if (RP->random_seed) 743 if (RP->random_seed)
791 { 744 {
792 /* Add one so that the next map is a bit different */
793 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 745 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
794 strcat (buf, small_buf); 746 strcat (buf, small_buf);
795 }
796
797 if (RP->treasureoptions)
798 { 747 }
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 748
800 strcat (buf, small_buf); 749 if (RP->custom)
801 } 750 {
802 751 sprintf (small_buf, "custom %s\n", RP->custom);
803 752 strcat (buf, small_buf);
753 }
804} 754}
805 755
806void 756void
807write_parameters_to_string (char *buf, 757write_parameters_to_string (char *buf,
808 int xsize_n, 758 int xsize_n,
809 int ysize_n, 759 int ysize_n,
810 char *wallstyle_n, 760 const char *wallstyle_n,
811 char *floorstyle_n, 761 const char *floorstyle_n,
812 char *monsterstyle_n, 762 const char *monsterstyle_n,
813 char *treasurestyle_n, 763 const char *treasurestyle_n,
814 char *layoutstyle_n, 764 const char *layoutstyle_n,
815 char *decorstyle_n, 765 const char *decorstyle_n,
816 char *doorstyle_n, 766 const char *doorstyle_n,
817 char *exitstyle_n, 767 const char *exitstyle_n,
818 char *final_map_n, 768 const char *final_map_n,
819 char *exit_on_final_map_n, 769 const char *exit_on_final_map_n,
820 char *this_map_n, 770 const char *this_map_n,
821 int layoutoptions1_n, 771 int layoutoptions1_n,
822 int layoutoptions2_n, 772 int layoutoptions2_n,
823 int layoutoptions3_n, 773 int layoutoptions3_n,
824 int symmetry_n, 774 int symmetry_n,
825 int dungeon_depth_n, 775 int dungeon_depth_n,
826 int dungeon_level_n, 776 int dungeon_level_n,
827 int difficulty_n, 777 int difficulty_n,
828 int difficulty_given_n, 778 int difficulty_given_n,
829 int decoroptions_n, 779 int decoroptions_n,
830 int orientation_n, 780 int orientation_n,
831 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 781 int origin_x_n,
782 int origin_y_n,
783 uint32_t random_seed_n,
784 int treasureoptions_n,
785 float difficulty_increase)
832{ 786{
833
834 char small_buf[256]; 787 char small_buf[16384];
835 788
836 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 789 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
837 790
838 if (wallstyle_n && wallstyle_n[0]) 791 if (wallstyle_n && wallstyle_n[0])
839 { 792 {
… …
904 if (layoutoptions1_n) 857 if (layoutoptions1_n)
905 { 858 {
906 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 859 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
907 strcat (buf, small_buf); 860 strcat (buf, small_buf);
908 } 861 }
909
910 862
911 if (layoutoptions2_n) 863 if (layoutoptions2_n)
912 { 864 {
913 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 865 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
914 strcat (buf, small_buf); 866 strcat (buf, small_buf);
… …
970 if (origin_y_n) 922 if (origin_y_n)
971 { 923 {
972 sprintf (small_buf, "origin_y %d\n", origin_y_n); 924 sprintf (small_buf, "origin_y %d\n", origin_y_n);
973 strcat (buf, small_buf); 925 strcat (buf, small_buf);
974 } 926 }
927
975 if (random_seed_n) 928 if (random_seed_n)
976 { 929 {
977 /* Add one so that the next map is a bit different */ 930 /* Add one so that the next map is a bit different */
978 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 931 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
979 strcat (buf, small_buf); 932 strcat (buf, small_buf);
980 } 933 }
981 934
982 if (treasureoptions_n) 935 if (treasureoptions_n)
983 { 936 {
984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 937 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
985 strcat (buf, small_buf); 938 strcat (buf, small_buf);
986 } 939 }
987
988
989} 940}
990 941
991/* copy an object with an inventory... i.e., duplicate the inv too. */ 942/////////////////////////////////////////////////////////////////////////////
992void
993copy_object_with_inv (object *src_ob, object *dest_ob)
994{
995 object *walk, *tmp;
996 943
997 src_ob->copy_to (dest_ob); 944LayoutData::LayoutData (int w, int h)
945: w(w), h(h)
946{
947 int size = (sizeof (char *) + sizeof (char) * h) * w;
998 948
999 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 949 col = (char **)salloc<char> (size);
1000 { 950
1001 tmp = object::create (); 951 char *data = (char *)(col + w);
1002 walk->copy_to (tmp); 952
1003 insert_ob_in_ob (tmp, dest_ob); 953 for (int x = w; x--; )
1004 } 954 col [x] = data + x * h;
1005} 955}
956
957LayoutData::~LayoutData ()
958{
959 int size = (sizeof (char *) + sizeof (char) * h) * w;
960
961 sfree ((char *)col, size);
962}
963
964void LayoutData::clear (char fill)
965{
966 memset (col [0], fill, w * h);
967}
968
969void LayoutData::border (char fill)
970{
971 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
972 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
973}
974

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines