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

Comparing deliantra/server/random_maps/room_gen_onion.C (file contents):
Revision 1.4 by root, Thu Sep 14 22:34:02 2006 UTC vs.
Revision 1.10 by root, Sat Jan 27 02:19:37 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program 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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24 25
25/* The onion room generator: 26/* The onion room generator:
26Onion rooms are like this: 27Onion rooms are like this:
27 28
… …
78 } 79 }
79 80
80 /* pick some random options if option = 0 */ 81 /* pick some random options if option = 0 */
81 if (option == 0) 82 if (option == 0)
82 { 83 {
83 switch (RANDOM () % 3) 84 switch (rndm (3))
84 { 85 {
85 case 0: 86 case 0:
86 option |= OPT_CENTERED; 87 option |= RMOPT_CENTERED;
87 break; 88 break;
88 case 1: 89 case 1:
89 option |= OPT_BOTTOM_C; 90 option |= RMOPT_BOTTOM_C;
90 break; 91 break;
91 case 2: 92 case 2:
92 option |= OPT_BOTTOM_R; 93 option |= RMOPT_BOTTOM_R;
93 break; 94 break;
94 } 95 }
95 if (RANDOM () % 2) 96 if (rndm (2))
96 option |= OPT_LINEAR; 97 option |= RMOPT_LINEAR;
97 if (RANDOM () % 2) 98 if (rndm (2))
98 option |= OPT_IRR_SPACE; 99 option |= RMOPT_IRR_SPACE;
99 } 100 }
100 101
101 /* write the outer walls, if appropriate. */ 102 /* write the outer walls, if appropriate. */
102 if (!(option & OPT_WALL_OFF)) 103 if (!(option & RMOPT_WALL_OFF))
103 { 104 {
104 for (i = 0; i < xsize; i++) 105 for (i = 0; i < xsize; i++)
105 maze[i][0] = maze[i][ysize - 1] = '#'; 106 maze[i][0] = maze[i][ysize - 1] = '#';
106 for (j = 0; j < ysize; j++) 107 for (j = 0; j < ysize; j++)
107 maze[0][j] = maze[xsize - 1][j] = '#'; 108 maze[0][j] = maze[xsize - 1][j] = '#';
108 }; 109 };
109 110
110 if (option & OPT_WALLS_ONLY) 111 if (option & RMOPT_WALLS_ONLY)
111 return maze; 112 return maze;
112 113
113 /* pick off the mutually exclusive options */ 114 /* pick off the mutually exclusive options */
114 if (option & OPT_BOTTOM_R) 115 if (option & RMOPT_BOTTOM_R)
115 bottom_right_centered_onion (maze, xsize, ysize, option, layers); 116 bottom_right_centered_onion (maze, xsize, ysize, option, layers);
116 else if (option & OPT_BOTTOM_C) 117 else if (option & RMOPT_BOTTOM_C)
117 bottom_centered_onion (maze, xsize, ysize, option, layers); 118 bottom_centered_onion (maze, xsize, ysize, option, layers);
118 else if (option & OPT_CENTERED) 119 else if (option & RMOPT_CENTERED)
119 centered_onion (maze, xsize, ysize, option, layers); 120 centered_onion (maze, xsize, ysize, option, layers);
120 121
121 return maze; 122 return maze;
122} 123}
123 124
124void 125void
125centered_onion (char **maze, int xsize, int ysize, int option, int layers) 126centered_onion (char **maze, int xsize, int ysize, int option, int layers)
127{
128 int i, maxlayers;
129 float *xlocations;
130 float *ylocations;
131
132 maxlayers = (MIN (xsize, ysize) - 2) / 5;
133 if (!maxlayers)
134 return; /* map too small to onionize */
135
136 if (layers > maxlayers)
137 layers = maxlayers;
138
139 if (layers == 0)
140 layers = rndm (maxlayers) + 1;
141
142 xlocations = (float *) calloc (sizeof (float), 2 * layers);
143 ylocations = (float *) calloc (sizeof (float), 2 * layers);
144
145 /* place all the walls */
146 if (option & RMOPT_IRR_SPACE) /* randomly spaced */
147 {
148 int x_spaces_available, y_spaces_available;
149
150 /* the "extra" spaces available for spacing between layers */
151 x_spaces_available = (xsize - 2) - 6 * layers + 1;
152 y_spaces_available = (ysize - 2) - 6 * layers + 1;
153
154
155 /* pick an initial random pitch */
156 for (i = 0; i < 2 * layers; i++)
157 {
158 float xpitch = 2, ypitch = 2;
159
160 if (x_spaces_available > 0)
161 xpitch = 2 + (rndm (x_spaces_available) + rndm (x_spaces_available) + rndm (x_spaces_available)) / 3;
162
163 if (y_spaces_available > 0)
164 ypitch = 2 + (rndm (y_spaces_available) + rndm (y_spaces_available) + rndm (y_spaces_available)) / 3;
165
166 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch;
167 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch;
168 x_spaces_available -= (int) (xpitch - 2);
169 y_spaces_available -= (int) (ypitch - 2);
170 }
171
172 }
173 if (!(option & RMOPT_IRR_SPACE))
174 { /* evenly spaced */
175 float xpitch, ypitch; /* pitch of the onion layers */
176
177 xpitch = (xsize - 2.0) / (2.0 * layers + 1);
178 ypitch = (ysize - 2.0) / (2.0 * layers + 1);
179 xlocations[0] = xpitch;
180 ylocations[0] = ypitch;
181 for (i = 1; i < 2 * layers; i++)
182 {
183 xlocations[i] = xlocations[i - 1] + xpitch;
184 ylocations[i] = ylocations[i - 1] + ypitch;
185 }
186 }
187
188 /* draw all the onion boxes. */
189
190 draw_onion (maze, xlocations, ylocations, layers);
191 make_doors (maze, xlocations, ylocations, layers, option);
192
193}
194
195void
196bottom_centered_onion (char **maze, int xsize, int ysize, int option, int layers)
126{ 197{
127 int i, maxlayers; 198 int i, maxlayers;
128 float *xlocations; 199 float *xlocations;
129 float *ylocations; 200 float *ylocations;
130 201
… …
132 if (!maxlayers) 203 if (!maxlayers)
133 return; /* map too small to onionize */ 204 return; /* map too small to onionize */
134 if (layers > maxlayers) 205 if (layers > maxlayers)
135 layers = maxlayers; 206 layers = maxlayers;
136 if (layers == 0) 207 if (layers == 0)
137 layers = (RANDOM () % maxlayers) + 1; 208 layers = rndm (maxlayers) + 1;
138 xlocations = (float *) calloc (sizeof (float), 2 * layers); 209 xlocations = (float *) calloc (sizeof (float), 2 * layers);
139 ylocations = (float *) calloc (sizeof (float), 2 * layers); 210 ylocations = (float *) calloc (sizeof (float), 2 * layers);
140 211
141 212
142 /* place all the walls */ 213 /* place all the walls */
143 if (option & OPT_IRR_SPACE) /* randomly spaced */ 214 if (option & RMOPT_IRR_SPACE) /* randomly spaced */
144 { 215 {
145 int x_spaces_available, y_spaces_available; 216 int x_spaces_available, y_spaces_available;
146 217
147 /* the "extra" spaces available for spacing between layers */ 218 /* the "extra" spaces available for spacing between layers */
148 x_spaces_available = (xsize - 2) - 6 * layers + 1; 219 x_spaces_available = (xsize - 2) - 6 * layers + 1;
149 y_spaces_available = (ysize - 2) - 6 * layers + 1; 220 y_spaces_available = (ysize - 2) - 3 * layers + 1;
150 221
151 222
152 /* pick an initial random pitch */ 223 /* pick an initial random pitch */
153 for (i = 0; i < 2 * layers; i++) 224 for (i = 0; i < 2 * layers; i++)
154 { 225 {
155 float xpitch = 2, ypitch = 2; 226 float xpitch = 2, ypitch = 2;
156 227
157 if (x_spaces_available > 0) 228 if (x_spaces_available > 0)
158 xpitch = 2 + (RANDOM () % x_spaces_available + RANDOM () % x_spaces_available + RANDOM () % x_spaces_available) / 3; 229 xpitch = 2 + (rndm (x_spaces_available) + rndm (x_spaces_available) + rndm (x_spaces_available)) / 3;
159 230
160 if (y_spaces_available > 0) 231 if (y_spaces_available > 0)
161 ypitch = 2 + (RANDOM () % y_spaces_available + RANDOM () % y_spaces_available + RANDOM () % y_spaces_available) / 3; 232 ypitch = 2 + (rndm (y_spaces_available) + rndm (y_spaces_available) + rndm (y_spaces_available)) / 3;
233
162 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch; 234 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch;
235 if (i < layers)
163 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch; 236 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch;
237 else
238 ylocations[i] = ysize - 1;
239
164 x_spaces_available -= (int) (xpitch - 2); 240 x_spaces_available -= (int) (xpitch - 2);
165 y_spaces_available -= (int) (ypitch - 2); 241 y_spaces_available -= (int) (ypitch - 2);
166 } 242 }
167 243
168 } 244 }
169 if (!(option & OPT_IRR_SPACE)) 245 if (!(option & RMOPT_IRR_SPACE))
170 { /* evenly spaced */ 246 { /* evenly spaced */
171 float xpitch, ypitch; /* pitch of the onion layers */ 247 float xpitch, ypitch; /* pitch of the onion layers */
172 248
173 xpitch = (xsize - 2.0) / (2.0 * layers + 1); 249 xpitch = (xsize - 2.0) / (2.0 * layers + 1);
174 ypitch = (ysize - 2.0) / (2.0 * layers + 1); 250 ypitch = (ysize - 2.0) / (layers + 1);
175 xlocations[0] = xpitch; 251 xlocations[0] = xpitch;
176 ylocations[0] = ypitch; 252 ylocations[0] = ypitch;
177 for (i = 1; i < 2 * layers; i++) 253 for (i = 1; i < 2 * layers; i++)
178 { 254 {
179 xlocations[i] = xlocations[i - 1] + xpitch; 255 xlocations[i] = xlocations[i - 1] + xpitch;
256 if (i < layers)
180 ylocations[i] = ylocations[i - 1] + ypitch; 257 ylocations[i] = ylocations[i - 1] + ypitch;
258 else
259 ylocations[i] = ysize - 1;
181 } 260 }
182 } 261 }
183 262
184 /* draw all the onion boxes. */ 263 /* draw all the onion boxes. */
185 264
186 draw_onion (maze, xlocations, ylocations, layers); 265 draw_onion (maze, xlocations, ylocations, layers);
187 make_doors (maze, xlocations, ylocations, layers, option); 266 make_doors (maze, xlocations, ylocations, layers, option);
188 267
189} 268}
190 269
270
271/* draw_boxes: draws the lines in the maze defining the onion layers */
272
191void 273void
274draw_onion (char **maze, float *xlocations, float *ylocations, int layers)
275{
276 int i, j, l;
277
278 for (l = 0; l < layers; l++)
279 {
280 int x1, x2, y1, y2;
281
282 /* horizontal segments */
283 y1 = (int) ylocations[l];
284 y2 = (int) ylocations[2 * layers - l - 1];
285 for (i = (int) xlocations[l]; i <= (int) xlocations[2 * layers - l - 1]; i++)
286 {
287 maze[i][y1] = '#';
288 maze[i][y2] = '#';
289 }
290
291 /* vertical segments */
292 x1 = (int) xlocations[l];
293 x2 = (int) xlocations[2 * layers - l - 1];
294 for (j = (int) ylocations[l]; j <= (int) ylocations[2 * layers - l - 1]; j++)
295 {
296 maze[x1][j] = '#';
297 maze[x2][j] = '#';
298 }
299
300 }
301}
302
303void
304make_doors (char **maze, float *xlocations, float *ylocations, int layers, int options)
305{
306 int freedoms; /* number of different walls on which we could place a door */
307 int which_wall; /* left, 1, top, 2, right, 3, bottom 4 */
308 int l, x1 = 0, x2, y1 = 0, y2;
309
310 freedoms = 4; /* centered */
311 if (options & RMOPT_BOTTOM_C)
312 freedoms = 3;
313 if (options & RMOPT_BOTTOM_R)
314 freedoms = 2;
315 if (layers <= 0)
316 return;
317
318 /* pick which wall will have a door. */
319 which_wall = rndm (freedoms) + 1;
320 for (l = 0; l < layers; l++)
321 {
322 if (options & RMOPT_LINEAR)
323 { /* linear door placement. */
324 switch (which_wall)
325 {
326 case 1:
327 { /* left hand wall */
328 x1 = (int) xlocations[l];
329 y1 = (int) ((ylocations[l] + ylocations[2 * layers - l - 1]) / 2);
330 break;
331 }
332 case 2:
333 { /* top wall placement */
334 x1 = (int) ((xlocations[l] + xlocations[2 * layers - l - 1]) / 2);
335 y1 = (int) ylocations[l];
336 break;
337 }
338 case 3:
339 { /* right wall placement */
340 x1 = (int) xlocations[2 * layers - l - 1];
341 y1 = (int) ((ylocations[l] + ylocations[2 * layers - l - 1]) / 2);
342 break;
343 }
344 case 4:
345 { /* bottom wall placement */
346 x1 = (int) ((xlocations[l] + xlocations[2 * layers - l - 1]) / 2);
347 y1 = (int) ylocations[2 * layers - l - 1];
348 break;
349 }
350 }
351 }
352 else
353 { /* random door placement. */
354 which_wall = rndm (freedoms) + 1;
355 switch (which_wall)
356 {
357 case 1:
358 { /* left hand wall */
359 x1 = (int) xlocations[l];
360 y2 = (int) (ylocations[2 * layers - l - 1] - ylocations[l] - 1);
361 if (y2 > 0)
362 y1 = (int) (ylocations[l] + rndm (y2) + 1);
363 else
364 y1 = (int) (ylocations[l] + 1);
365 break;
366 }
367 case 2:
368 { /* top wall placement */
369 x2 = (int) ((-xlocations[l] + xlocations[2 * layers - l - 1])) - 1;
370 if (x2 > 0)
371 x1 = (int) (xlocations[l] + rndm (x2) + 1);
372 else
373 x1 = (int) (xlocations[l] + 1);
374 y1 = (int) ylocations[l];
375 break;
376 }
377 case 3:
378 { /* right wall placement */
379 x1 = (int) xlocations[2 * layers - l - 1];
380 y2 = (int) ((-ylocations[l] + ylocations[2 * layers - l - 1])) - 1;
381 if (y2 > 0)
382 y1 = (int) (ylocations[l] + rndm (y2) + 1);
383 else
384 y1 = (int) (ylocations[l] + 1);
385
386 break;
387 }
388 case 4:
389 { /* bottom wall placement */
390 x2 = (int) ((-xlocations[l] + xlocations[2 * layers - l - 1])) - 1;
391 if (x2 > 0)
392 x1 = (int) (xlocations[l] + rndm (x2) + 1);
393 else
394 x1 = (int) (xlocations[l] + 1);
395 y1 = (int) ylocations[2 * layers - l - 1];
396 break;
397 }
398
399 }
400 }
401 if (options & RMOPT_NO_DOORS)
402 maze[x1][y1] = '#'; /* no door. */
403 else
404 maze[x1][y1] = 'D'; /* write the door */
405
406 }
407 /* mark the center of the maze with a C */
408 l = layers - 1;
409 x1 = (int) (xlocations[l] + xlocations[2 * layers - l - 1]) / 2;
410 y1 = (int) (ylocations[l] + ylocations[2 * layers - l - 1]) / 2;
411 maze[x1][y1] = 'C';
412
413 /* not needed anymore */
414 free (xlocations);
415 free (ylocations);
416
417}
418
419void
192bottom_centered_onion (char **maze, int xsize, int ysize, int option, int layers) 420bottom_right_centered_onion (char **maze, int xsize, int ysize, int option, int layers)
193{ 421{
194 int i, maxlayers; 422 int i, maxlayers;
195 float *xlocations; 423 float *xlocations;
196 float *ylocations; 424 float *ylocations;
197 425
… …
199 if (!maxlayers) 427 if (!maxlayers)
200 return; /* map too small to onionize */ 428 return; /* map too small to onionize */
201 if (layers > maxlayers) 429 if (layers > maxlayers)
202 layers = maxlayers; 430 layers = maxlayers;
203 if (layers == 0) 431 if (layers == 0)
204 layers = (RANDOM () % maxlayers) + 1; 432 layers = rndm (maxlayers) + 1;
433
205 xlocations = (float *) calloc (sizeof (float), 2 * layers); 434 xlocations = (float *) calloc (sizeof (float), 2 * layers);
206 ylocations = (float *) calloc (sizeof (float), 2 * layers); 435 ylocations = (float *) calloc (sizeof (float), 2 * layers);
207 436
208
209 /* place all the walls */ 437 /* place all the walls */
210 if (option & OPT_IRR_SPACE) /* randomly spaced */ 438 if (option & RMOPT_IRR_SPACE) /* randomly spaced */
211 { 439 {
212 int x_spaces_available, y_spaces_available; 440 int x_spaces_available, y_spaces_available;
213 441
214 /* the "extra" spaces available for spacing between layers */ 442 /* the "extra" spaces available for spacing between layers */
215 x_spaces_available = (xsize - 2) - 6 * layers + 1; 443 x_spaces_available = (xsize - 2) - 3 * layers + 1;
216 y_spaces_available = (ysize - 2) - 3 * layers + 1; 444 y_spaces_available = (ysize - 2) - 3 * layers + 1;
217 445
218 446
219 /* pick an initial random pitch */ 447 /* pick an initial random pitch */
220 for (i = 0; i < 2 * layers; i++) 448 for (i = 0; i < 2 * layers; i++)
221 { 449 {
222 float xpitch = 2, ypitch = 2; 450 float xpitch = 2, ypitch = 2;
223 451
224 if (x_spaces_available > 0) 452 if (x_spaces_available > 0)
225 xpitch = 2 + (RANDOM () % x_spaces_available + RANDOM () % x_spaces_available + RANDOM () % x_spaces_available) / 3; 453 xpitch = 2 + (rndm (x_spaces_available) + rndm (x_spaces_available) + rndm (x_spaces_available)) / 3;
226 454
227 if (y_spaces_available > 0) 455 if (y_spaces_available > 0)
228 ypitch = 2 + (RANDOM () % y_spaces_available + RANDOM () % y_spaces_available + RANDOM () % y_spaces_available) / 3; 456 ypitch = 2 + (rndm (y_spaces_available) + rndm (y_spaces_available) + rndm (y_spaces_available)) / 3;
457
458 if (i < layers)
229 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch; 459 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch;
460 else
461 xlocations[i] = xsize - 1;
462
230 if (i < layers) 463 if (i < layers)
231 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch; 464 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch;
232 else 465 else
233 ylocations[i] = ysize - 1; 466 ylocations[i] = ysize - 1;
234 x_spaces_available -= (int) (xpitch - 2); 467 x_spaces_available -= (int) (xpitch - 2);
235 y_spaces_available -= (int) (ypitch - 2); 468 y_spaces_available -= (int) (ypitch - 2);
236 } 469 }
237 470
238 } 471 }
239 if (!(option & OPT_IRR_SPACE)) 472 if (!(option & RMOPT_IRR_SPACE))
240 { /* evenly spaced */ 473 { /* evenly spaced */
241 float xpitch, ypitch; /* pitch of the onion layers */ 474 float xpitch, ypitch; /* pitch of the onion layers */
242 475
243 xpitch = (xsize - 2.0) / (2.0 * layers + 1); 476 xpitch = (xsize - 2.0) / (2.0 * layers + 1);
244 ypitch = (ysize - 2.0) / (layers + 1); 477 ypitch = (ysize - 2.0) / (layers + 1);
245 xlocations[0] = xpitch; 478 xlocations[0] = xpitch;
246 ylocations[0] = ypitch; 479 ylocations[0] = ypitch;
247 for (i = 1; i < 2 * layers; i++) 480 for (i = 1; i < 2 * layers; i++)
248 { 481 {
482 if (i < layers)
249 xlocations[i] = xlocations[i - 1] + xpitch; 483 xlocations[i] = xlocations[i - 1] + xpitch;
484 else
485 xlocations[i] = xsize - 1;
250 if (i < layers) 486 if (i < layers)
251 ylocations[i] = ylocations[i - 1] + ypitch; 487 ylocations[i] = ylocations[i - 1] + ypitch;
252 else 488 else
253 ylocations[i] = ysize - 1; 489 ylocations[i] = ysize - 1;
254 } 490 }
… …
258 494
259 draw_onion (maze, xlocations, ylocations, layers); 495 draw_onion (maze, xlocations, ylocations, layers);
260 make_doors (maze, xlocations, ylocations, layers, option); 496 make_doors (maze, xlocations, ylocations, layers, option);
261 497
262} 498}
263
264
265/* draw_boxes: draws the lines in the maze defining the onion layers */
266
267void
268draw_onion (char **maze, float *xlocations, float *ylocations, int layers)
269{
270 int i, j, l;
271
272 for (l = 0; l < layers; l++)
273 {
274 int x1, x2, y1, y2;
275
276 /* horizontal segments */
277 y1 = (int) ylocations[l];
278 y2 = (int) ylocations[2 * layers - l - 1];
279 for (i = (int) xlocations[l]; i <= (int) xlocations[2 * layers - l - 1]; i++)
280 {
281 maze[i][y1] = '#';
282 maze[i][y2] = '#';
283 }
284
285 /* vertical segments */
286 x1 = (int) xlocations[l];
287 x2 = (int) xlocations[2 * layers - l - 1];
288 for (j = (int) ylocations[l]; j <= (int) ylocations[2 * layers - l - 1]; j++)
289 {
290 maze[x1][j] = '#';
291 maze[x2][j] = '#';
292 }
293
294 }
295}
296
297void
298make_doors (char **maze, float *xlocations, float *ylocations, int layers, int options)
299{
300 int freedoms; /* number of different walls on which we could place a door */
301 int which_wall; /* left, 1, top, 2, right, 3, bottom 4 */
302 int l, x1 = 0, x2, y1 = 0, y2;
303
304 freedoms = 4; /* centered */
305 if (options & OPT_BOTTOM_C)
306 freedoms = 3;
307 if (options & OPT_BOTTOM_R)
308 freedoms = 2;
309 if (layers <= 0)
310 return;
311 /* pick which wall will have a door. */
312 which_wall = RANDOM () % freedoms + 1;
313 for (l = 0; l < layers; l++)
314 {
315 if (options & OPT_LINEAR)
316 { /* linear door placement. */
317 switch (which_wall)
318 {
319 case 1:
320 { /* left hand wall */
321 x1 = (int) xlocations[l];
322 y1 = (int) ((ylocations[l] + ylocations[2 * layers - l - 1]) / 2);
323 break;
324 }
325 case 2:
326 { /* top wall placement */
327 x1 = (int) ((xlocations[l] + xlocations[2 * layers - l - 1]) / 2);
328 y1 = (int) ylocations[l];
329 break;
330 }
331 case 3:
332 { /* right wall placement */
333 x1 = (int) xlocations[2 * layers - l - 1];
334 y1 = (int) ((ylocations[l] + ylocations[2 * layers - l - 1]) / 2);
335 break;
336 }
337 case 4:
338 { /* bottom wall placement */
339 x1 = (int) ((xlocations[l] + xlocations[2 * layers - l - 1]) / 2);
340 y1 = (int) ylocations[2 * layers - l - 1];
341 break;
342 }
343 }
344 }
345 else
346 { /* random door placement. */
347 which_wall = RANDOM () % freedoms + 1;
348 switch (which_wall)
349 {
350 case 1:
351 { /* left hand wall */
352 x1 = (int) xlocations[l];
353 y2 = (int) (ylocations[2 * layers - l - 1] - ylocations[l] - 1);
354 if (y2 > 0)
355 y1 = (int) (ylocations[l] + RANDOM () % y2 + 1);
356 else
357 y1 = (int) (ylocations[l] + 1);
358 break;
359 }
360 case 2:
361 { /* top wall placement */
362 x2 = (int) ((-xlocations[l] + xlocations[2 * layers - l - 1])) - 1;
363 if (x2 > 0)
364 x1 = (int) (xlocations[l] + RANDOM () % x2 + 1);
365 else
366 x1 = (int) (xlocations[l] + 1);
367 y1 = (int) ylocations[l];
368 break;
369 }
370 case 3:
371 { /* right wall placement */
372 x1 = (int) xlocations[2 * layers - l - 1];
373 y2 = (int) ((-ylocations[l] + ylocations[2 * layers - l - 1])) - 1;
374 if (y2 > 0)
375 y1 = (int) (ylocations[l] + RANDOM () % y2 + 1);
376 else
377 y1 = (int) (ylocations[l] + 1);
378
379 break;
380 }
381 case 4:
382 { /* bottom wall placement */
383 x2 = (int) ((-xlocations[l] + xlocations[2 * layers - l - 1])) - 1;
384 if (x2 > 0)
385 x1 = (int) (xlocations[l] + RANDOM () % x2 + 1);
386 else
387 x1 = (int) (xlocations[l] + 1);
388 y1 = (int) ylocations[2 * layers - l - 1];
389 break;
390 }
391
392 }
393 }
394 if (options & OPT_NO_DOORS)
395 maze[x1][y1] = '#'; /* no door. */
396 else
397 maze[x1][y1] = 'D'; /* write the door */
398
399 }
400 /* mark the center of the maze with a C */
401 l = layers - 1;
402 x1 = (int) (xlocations[l] + xlocations[2 * layers - l - 1]) / 2;
403 y1 = (int) (ylocations[l] + ylocations[2 * layers - l - 1]) / 2;
404 maze[x1][y1] = 'C';
405
406 /* not needed anymore */
407 free (xlocations);
408 free (ylocations);
409
410}
411
412void
413bottom_right_centered_onion (char **maze, int xsize, int ysize, int option, int layers)
414{
415 int i, maxlayers;
416 float *xlocations;
417 float *ylocations;
418
419 maxlayers = (MIN (xsize, ysize) - 2) / 5;
420 if (!maxlayers)
421 return; /* map too small to onionize */
422 if (layers > maxlayers)
423 layers = maxlayers;
424 if (layers == 0)
425 layers = (RANDOM () % maxlayers) + 1;
426 xlocations = (float *) calloc (sizeof (float), 2 * layers);
427 ylocations = (float *) calloc (sizeof (float), 2 * layers);
428
429
430 /* place all the walls */
431 if (option & OPT_IRR_SPACE) /* randomly spaced */
432 {
433 int x_spaces_available, y_spaces_available;
434
435 /* the "extra" spaces available for spacing between layers */
436 x_spaces_available = (xsize - 2) - 3 * layers + 1;
437 y_spaces_available = (ysize - 2) - 3 * layers + 1;
438
439
440 /* pick an initial random pitch */
441 for (i = 0; i < 2 * layers; i++)
442 {
443 float xpitch = 2, ypitch = 2;
444
445 if (x_spaces_available > 0)
446 xpitch = 2 + (RANDOM () % x_spaces_available + RANDOM () % x_spaces_available + RANDOM () % x_spaces_available) / 3;
447
448 if (y_spaces_available > 0)
449 ypitch = 2 + (RANDOM () % y_spaces_available + RANDOM () % y_spaces_available + RANDOM () % y_spaces_available) / 3;
450 if (i < layers)
451 xlocations[i] = ((i > 0) ? xlocations[i - 1] : 0) + xpitch;
452 else
453 xlocations[i] = xsize - 1;
454
455 if (i < layers)
456 ylocations[i] = ((i > 0) ? ylocations[i - 1] : 0) + ypitch;
457 else
458 ylocations[i] = ysize - 1;
459 x_spaces_available -= (int) (xpitch - 2);
460 y_spaces_available -= (int) (ypitch - 2);
461 }
462
463 }
464 if (!(option & OPT_IRR_SPACE))
465 { /* evenly spaced */
466 float xpitch, ypitch; /* pitch of the onion layers */
467
468 xpitch = (xsize - 2.0) / (2.0 * layers + 1);
469 ypitch = (ysize - 2.0) / (layers + 1);
470 xlocations[0] = xpitch;
471 ylocations[0] = ypitch;
472 for (i = 1; i < 2 * layers; i++)
473 {
474 if (i < layers)
475 xlocations[i] = xlocations[i - 1] + xpitch;
476 else
477 xlocations[i] = xsize - 1;
478 if (i < layers)
479 ylocations[i] = ylocations[i - 1] + ypitch;
480 else
481 ylocations[i] = ysize - 1;
482 }
483 }
484
485 /* draw all the onion boxes. */
486
487 draw_onion (maze, xlocations, ylocations, layers);
488 make_doors (maze, xlocations, ylocations, layers, option);
489
490}

Diff Legend

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