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

Comparing deliantra/server/random_maps/layout.C (file contents):
Revision 1.14 by root, Sat Jul 3 02:19:10 2010 UTC vs.
Revision 1.18 by root, Sat Jul 3 13:39:04 2010 UTC

… …
77} 77}
78 78
79void 79void
80layout::fill (char fill) 80layout::fill (char fill)
81{ 81{
82 memset (data [0], fill, w * h); 82 //memset (data [0], fill, w * h); // only when contiguous :/
83 fill_rect (0, 0, w, h, fill);
83} 84}
84 85
85void 86void
86layout::rect (int x1, int y1, int x2, int y2, char fill) 87layout::rect (int x1, int y1, int x2, int y2, char fill)
87{ 88{
… …
220 if (x < dist.w - 1 && !dist [x + 1][y]) push_flood_fill (dist, seeds, x + 1, y); 221 if (x < dist.w - 1 && !dist [x + 1][y]) push_flood_fill (dist, seeds, x + 1, y);
221 } 222 }
222} 223}
223 224
224static inline void 225static inline void
225make_tunnel (layout &dist, pointlist &seeds, int x, int y, U8 d) 226make_tunnel (layout &dist, pointlist &seeds, int x, int y, U8 d, int perturb)
226{ 227{
227 for (;;) 228 for (;;)
228 { 229 {
229 point neigh[4]; 230 point neigh[4];
230 int ncnt = 0; 231 int ncnt = 0;
231 232
233 d += perturb > 1;
234
232 if (x > 0 && U8 (dist [x - 1][y]) <= d && dist [x - 1][y] > 1) neigh [ncnt++] = point (x - 1, y); 235 if (x > 0 && U8 (dist [x - 1][y]) < d && dist [x - 1][y] > 1) neigh [ncnt++] = point (x - 1, y);
233 if (x < dist.w - 1 && U8 (dist [x + 1][y]) <= d && dist [x + 1][y] > 1) neigh [ncnt++] = point (x + 1, y); 236 if (x < dist.w - 1 && U8 (dist [x + 1][y]) < d && dist [x + 1][y] > 1) neigh [ncnt++] = point (x + 1, y);
234 if (y > 0 && U8 (dist [x][y - 1]) <= d && dist [x][y - 1] > 1) neigh [ncnt++] = point (x, y - 1); 237 if (y > 0 && U8 (dist [x][y - 1]) < d && dist [x][y - 1] > 1) neigh [ncnt++] = point (x, y - 1);
235 if (y < dist.h - 1 && U8 (dist [x][y + 1]) <= d && dist [x][y + 1] > 1) neigh [ncnt++] = point (x, y + 1); 238 if (y < dist.h - 1 && U8 (dist [x][y + 1]) < d && dist [x][y + 1] > 1) neigh [ncnt++] = point (x, y + 1);
236 239
237 if (!ncnt) 240 if (!ncnt)
238 return; 241 return;
239 242
240 point &p = neigh [rmg_rndm (ncnt)]; 243 point &p = neigh [perturb ? rmg_rndm (ncnt) : 0];
241 244
242 seeds.push (p); 245 seeds.push (p);
243 246
244 x = p.x; 247 x = p.x;
245 y = p.y; 248 y = p.y;
… …
263} 266}
264 267
265// isolation remover, works on a "distance" map 268// isolation remover, works on a "distance" map
266// the map must be initialised with 0 == rooms, 255 = walls 269// the map must be initialised with 0 == rooms, 255 = walls
267static void noinline 270static void noinline
268isolation_remover (layout &dist) 271isolation_remover (layout &dist, unsigned int perturb = 2)
269{ 272{
270 // dist contains 273 // dist contains
271 // 0 == invisited rooms 274 // 0 == invisited rooms
272 // 1 == visited rooms 275 // 1 == visited rooms
273 // 2+ shortest distance to random near room 276 // 2+ shortest distance to random near room
274 277
278 max_it (perturb, 0);
279 min_it (perturb, 2);
280
275 // phase 1, find seed 281 // phase 1, find seed
276 int cnt = 0; 282 int cnt = 0;
277 int x, y; 283 int x, y;
278 284
279 for (int i = 0; i < dist.w; ++i) 285 for (int i = 0; i < dist.w; ++i)
… …
310 316
311 if (!dist [x][y]) 317 if (!dist [x][y])
312 { 318 {
313 // found new isolated area, make tunnel 319 // found new isolated area, make tunnel
314 push_flood_fill (dist, seeds, x, y); 320 push_flood_fill (dist, seeds, x, y);
315 make_tunnel (dist, seeds, x, y, 255); 321 make_tunnel (dist, seeds, x, y, 254, perturb);
316 } 322 }
317 else 323 else
318 { 324 {
319 // nothing here, continue to expand 325 // nothing here, continue to expand
320 U8 d = U8 (dist [x][y]) + 1; 326 U8 d = U8 (dist [x][y]) + 1;
… …
326 } 332 }
327 } 333 }
328} 334}
329 335
330void 336void
331layout::isolation_remover () 337layout::isolation_remover (int perturb)
332{ 338{
333 layout dist (w - 2, h - 2); // map without border 339 layout dist (w - 2, h - 2); // map without border
334 340
335 for (int x = 1; x < w - 1; ++x) 341 for (int x = 1; x < w - 1; ++x)
336 for (int y = 1; y < h - 1; ++y) 342 for (int y = 1; y < h - 1; ++y)
337 dist [x - 1][y - 1] = data [x][y] == '#' ? U8 (255) : 0; 343 dist [x - 1][y - 1] = data [x][y] == '#' ? U8 (255) : 0;
338 344
339 ::isolation_remover (dist); 345 ::isolation_remover (dist, perturb);
340 346
341 // now copy the tunnels over 347 // now copy the tunnels over
342 for (int x = 1; x < w - 1; ++x) 348 for (int x = 1; x < w - 1; ++x)
343 for (int y = 1; y < h - 1; ++y) 349 for (int y = 1; y < h - 1; ++y)
344 if (data [x][y] == '#' && dist [x - 1][y - 1] == 1) 350 if (data [x][y] == '#' && dist [x - 1][y - 1] == 1)
345 data [x][y] = 0; 351 data [x][y] = 0;
346}
347
348/////////////////////////////////////////////////////////////////////////////
349
350// inspired mostly by http://www.jimrandomh.org/misc/caves.txt
351void
352layout::gen_cave (int subtype)
353{
354 switch (subtype)
355 {
356 // a rough cave
357 case 0:
358 fill_rand (rmg_rndm (85, 97));
359 break;
360
361 // corridors
362 case 1:
363 fill_rand (rmg_rndm (5, 40));
364 erode_1_2 (5, 2, 10);
365 erode_1_2 (5, -1, 10);
366 erode_1_2 (5, 2, 1);
367 break;
368
369 // somewhat open, roundish
370 case 2:
371 fill_rand (45);
372 erode_1_2 (5, 0, 5);
373 erode_1_2 (5, 1, 1);
374 break;
375
376 // wide open, some room-like structures
377 case 3:
378 fill_rand (45);
379 erode_1_2 (5, 2, 4);
380 erode_1_2 (5, -1, 3);
381 break;
382 }
383
384 border ();
385 isolation_remover ();
386} 352}
387 353
388///////////////////////////////////////////////////////////////////////////// 354/////////////////////////////////////////////////////////////////////////////
389 355
390//+GPL 356//+GPL
… …
810 else 776 else
811 make_wall (*this, dx, dy, 1); 777 make_wall (*this, dx, dy, 1);
812 } 778 }
813} 779}
814 780
781//-GPL
782
815///////////////////////////////////////////////////////////////////////////// 783/////////////////////////////////////////////////////////////////////////////
784
785// inspired mostly by http://www.jimrandomh.org/misc/caves.txt
786void
787layout::gen_cave (int subtype)
788{
789 switch (subtype)
790 {
791 // a rough cave
792 case 0:
793 fill_rand (rmg_rndm (85, 97));
794 break;
795
796 // corridors
797 case 1:
798 fill_rand (rmg_rndm (5, 40));
799 erode_1_2 (5, 2, 10);
800 erode_1_2 (5, -1, 10);
801 erode_1_2 (5, 2, 1);
802 break;
803
804 // somewhat open, roundish
805 case 2:
806 fill_rand (45);
807 erode_1_2 (5, 0, 5);
808 erode_1_2 (5, 1, 1);
809 break;
810
811 // wide open, some room-like structures
812 case 3:
813 fill_rand (45);
814 erode_1_2 (5, 2, 4);
815 erode_1_2 (5, -1, 3);
816 break;
817 }
818
819 border ();
820 isolation_remover ();
821}
822
823void
824layout::gen_castle ()
825{
826 fill ('#');
827
828 for (int n = w * h / 30 + 1; n--; )
829 {
830 int rw = rmg_rndm (6, 10);
831 int rh = rmg_rndm (6, 10);
832
833 int rx = rmg_rndm (0, w - rw);
834 int ry = rmg_rndm (0, h - rh);
835
836 rect (rx, ry, rx + rw, ry + rh, '#');
837 fill_rect (rx + 1, ry + 1, rx + rw - 1, ry + rh - 1, 0);
838 }
839
840 border ();
841 isolation_remover (0);
842}
843
844static void
845gen_mixed_ (layout &maze, random_map_params *RP, int dir)
846{
847 if (maze.w < 20 && maze.h < 20 && !rmg_rndm (3))
848 dir = 2; // stop recursion randomly
849
850 if (dir == 0 && maze.w > 16)
851 {
852 int m = rmg_rndm (8, maze.w - 8);
853
854 layout m1 (maze, 0, 0, m , maze.h); gen_mixed_ (m1, RP, !dir);
855 layout m2 (maze, m, 0, maze.w, maze.h); gen_mixed_ (m2, RP, !dir);
856 }
857 else if (dir == 1 && maze.h > 16)
858 {
859 int m = rmg_rndm (8, maze.h - 8);
860
861 layout m1 (maze, 0, 0, maze.w, m ); gen_mixed_ (m1, RP, !dir);
862 layout m2 (maze, 0, m, maze.w, maze.h); gen_mixed_ (m2, RP, !dir);
863 }
864 else
865 {
866 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 2) + 1;
867
868 if (RP->map_layout_style == LAYOUT_MULTIPLE)
869 ++RP->map_layout_style;
870
871 maze.generate (RP);
872 }
873}
874
875// recursive subdivision with random sublayouts
876static void
877gen_mixed (layout &maze, random_map_params *RP)
878{
879 random_map_params &rp = *new random_map_params (RP);
880 gen_mixed_ (maze, &rp, rmg_rndm (2));
881 delete &rp;
882
883 maze.border ();
884 maze.isolation_remover ();
885}
886
887//+GPL
816 888
817/* function selects the maze function and gives it whatever 889/* function selects the maze function and gives it whatever
818 arguments it needs. */ 890 arguments it needs. */
819void 891void
820layout::generate (random_map_params *RP) 892layout::generate (random_map_params *RP)
… …
880 if (rmg_rndm (2)) 952 if (rmg_rndm (2))
881 doorify (); 953 doorify ();
882 954
883 break; 955 break;
884 956
957 case LAYOUT_CASTLE:
958 gen_castle ();
959
960 if (rmg_rndm (2))
961 doorify ();
962
963 break;
964
965 case LAYOUT_MULTIPLE:
966 gen_mixed (*this, RP);
967 break;
968
885 default: 969 default:
886 abort (); 970 abort ();
887 } 971 }
888
889 /* rotate the maze randomly */
890 rotate (rmg_rndm (4));
891
892 symmetrize (RP->symmetry_used);
893
894#if 0
895 print ();//D
896#endif
897
898 if (RP->expand2x)
899 expand2x ();
900} 972}
901 973
902//-GPL 974//-GPL
903 975
904#if 0 976#if 0
… …
909 rmg_rndm.seed (time (0)); 981 rmg_rndm.seed (time (0));
910 982
911 for(int i=1;i<100;i++) 983 for(int i=1;i<100;i++)
912 { 984 {
913 layout maze (40, 25); 985 layout maze (40, 25);
914 maze.fill_rand (85); 986 maze.gen_castle ();
915 maze.border (); 987 maze.doorify ();
916 maze.isolation_remover ();
917 maze.print (); 988 maze.print ();
989 exit(0);
918 } 990 }
919 991
920 exit (1); 992 exit (1);
921 } 993 }
922} demo; 994} demo;

Diff Legend

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