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

Comparing deliantra/server/random_maps/expand2x.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.7 by root, Mon Apr 14 22:41:17 2008 UTC

1
1/* 2/*
2 * Expands a layout by 2x in each dimension. 3 * Expands a layout by 2x in each dimension.
3 * H. S. Teoh 4 * H. S. Teoh
4 * -------------------------------------------------------------------------- 5 * --------------------------------------------------------------------------
5 * $Id: expand2x.C,v 1.2 2006/08/29 08:01:36 root Exp $ 6 * $Id: expand2x.C,v 1.7 2008/04/14 22:41:17 root Exp $
6 * 7 *
7 * ALGORITHM 8 * ALGORITHM
8 * 9 *
9 * ... (TBW) 10 * ... (TBW)
10 */ 11 */
11 12
12#include <stdlib.h> /* just in case */ 13#include "global.h"
13#include <expand2x.h> /* use compiler to do sanity check */ 14#include "random_map.h"
14 15#include "rproto.h"
15
16/* PROTOTYPES */
17
18static void expand_misc(char **newlayout, int i, int j, char **layout,
19 int xsize, int ysize);
20static void expand_wall(char **newlayout, int i, int j, char **layout,
21 int xsize, int ysize);
22static void expand_door(char **newlayout, int i, int j, char **layout,
23 int xsize, int ysize);
24
25
26/* FUNCTIONS */
27
28char **expand2x(char **layout, int xsize, int ysize) {
29 int i,j;
30 int nxsize = xsize*2 - 1;
31 int nysize = ysize*2 - 1;
32
33 /* Allocate new layout */
34 char **newlayout = (char **)calloc(sizeof(char*), nxsize);
35 for (i=0; i<nxsize; i++) {
36 newlayout[i] = (char *) calloc(sizeof(char), nysize);
37 }
38
39 for (i=0; i<xsize; i++) {
40 for (j=0; j<ysize; j++) {
41 switch(layout[i][j]) {
42 case '#':
43 expand_wall(newlayout, i,j, layout, xsize, ysize);
44 break;
45 case 'D':
46 expand_door(newlayout, i,j, layout, xsize, ysize);
47 break;
48 default:
49 expand_misc(newlayout, i,j, layout, xsize, ysize);
50 }
51 }
52 }
53
54 /* Dump old layout */
55 for (i=0; i<xsize; i++) {
56 free(layout[i]);
57 }
58 free(layout);
59
60 return newlayout;
61}
62 16
63/* Copy the old tile X into the new one at location (i*2, j*2) and 17/* Copy the old tile X into the new one at location (i*2, j*2) and
64 * fill up the rest of the 2x2 result with \0: 18 * fill up the rest of the 2x2 result with \0:
65 * X ---> X \0 19 * X ---> X \0
66 * \0 \0 20 * \0 \0
67 */ 21 */
68static void expand_misc(char **newlayout, int i, int j, char **layout, 22static void
69 int xsize, int ysize) { 23expand_misc (Maze newlayout, int i, int j, Maze layout)
24{
70 newlayout[i*2][j*2] = layout[i][j]; 25 newlayout[i * 2][j * 2] = layout[i][j];
71 /* (Note: no need to reset rest of 2x2 area to \0 because calloc does that 26 /* (Note: no need to reset rest of 2x2 area to \0 because calloc does that
72 * for us.) */ 27 * for us.) */
73} 28}
74 29
75/* Returns a bitmap that represents which squares on the right and bottom 30/* Returns a bitmap that represents which squares on the right and bottom
… …
77 * 1 match on (i+1, j) 32 * 1 match on (i+1, j)
78 * 2 match on (i, j+1) 33 * 2 match on (i, j+1)
79 * 4 match on (i+1, j+1) 34 * 4 match on (i+1, j+1)
80 * and the possible combinations thereof. 35 * and the possible combinations thereof.
81 */ 36 */
37static int
82static int calc_pattern(char ch, char **layout, int i, int j, 38calc_pattern (char ch, Maze layout, int i, int j)
83 int xsize, int ysize) { 39{
84 int pattern = 0; 40 int pattern = 0;
85 41
86 if (i+1<xsize && layout[i+1][j]==ch) 42 if (i + 1 < layout->w && layout[i + 1][j] == ch)
87 pattern |= 1; 43 pattern |= 1;
88 44
89 if (j+1<ysize) { 45 if (j + 1 < layout->h)
46 {
90 if (layout[i][j+1]==ch) 47 if (layout[i][j + 1] == ch)
91 pattern |= 2; 48 pattern |= 2;
92 if (i+1<xsize && layout[i+1][j+1]==ch) 49 if (i + 1 < layout->w && layout[i + 1][j + 1] == ch)
93 pattern |= 4; 50 pattern |= 4;
94 } 51 }
95 52
96 return pattern; 53 return pattern;
97} 54}
98 55
99/* Expand a wall. This function will try to sensibly connect the resulting 56/* Expand a wall. This function will try to sensibly connect the resulting
100 * wall to adjacent wall squares, so that the result won't have disconnected 57 * wall to adjacent wall squares, so that the result won't have disconnected
101 * walls. 58 * walls.
102 */ 59 */
103static void expand_wall(char **newlayout, int i, int j, char **layout, 60static void
104 int xsize, int ysize) { 61expand_wall (Maze newlayout, int i, int j, Maze layout)
62{
105 int wall_pattern = calc_pattern('#', layout, i, j, xsize, ysize); 63 int wall_pattern = calc_pattern ('#', layout, i, j);
106 int door_pattern = calc_pattern('D', layout, i, j, xsize, ysize); 64 int door_pattern = calc_pattern ('D', layout, i, j);
107 int both_pattern = wall_pattern | door_pattern; 65 int both_pattern = wall_pattern | door_pattern;
108 66
109 newlayout[i*2][j*2] = '#'; 67 newlayout[i * 2][j * 2] = '#';
110 if (i+1 < xsize) { 68
111 if (both_pattern & 1) { /* join walls/doors to the right */ 69 if (i + 1 < layout->w)
70 {
71 if (both_pattern & 1)
72 { /* join walls/doors to the right */
112/* newlayout[i*2+1][j*2] = '#'; */ 73/* newlayout[i*2+1][j*2] = '#'; */
113 newlayout[i*2+1][j*2] = layout[i+1][j]; 74 newlayout[i * 2 + 1][j * 2] = layout[i + 1][j];
114 } 75 }
115 }
116
117 if (j+1 < ysize) {
118 if (both_pattern & 2) { /* join walls/doors to the bottom */
119/* newlayout[i*2][j*2+1] = '#'; */
120 newlayout[i*2][j*2+1] = layout[i][j+1];
121 } 76 }
122 77
123 if (wall_pattern==7) { /* if orig layout is a 2x2 wall block, 78 if (j + 1 < layout->h)
79 {
80 if (both_pattern & 2)
81 { /* join walls/doors to the bottom */
82/* newlayout[i*2][j*2+1] = '#'; */
83 newlayout[i * 2][j * 2 + 1] = layout[i][j + 1];
84 }
85
86 if (wall_pattern == 7)
87 { /* if orig layout is a 2x2 wall block,
124 * we fill the result with walls. */ 88 * we fill the result with walls. */
125 newlayout[i*2+1][j*2+1] = '#'; 89 newlayout[i * 2 + 1][j * 2 + 1] = '#';
90 }
126 } 91 }
127 }
128} 92}
129 93
130/* This function will try to sensibly connect doors so that they meet up with 94/* This function will try to sensibly connect doors so that they meet up with
131 * adjacent walls. Note that it will also presumptuously delete (ignore) doors 95 * adjacent walls. Note that it will also presumptuously delete (ignore) doors
132 * that it doesn't know how to correctly expand. 96 * that it doesn't know how to correctly expand.
133 */ 97 */
134static void expand_door(char **newlayout, int i, int j, char **layout, 98static void
135 int xsize, int ysize) { 99expand_door (Maze newlayout, int i, int j, Maze layout)
100{
136 int wall_pattern = calc_pattern('#', layout, i, j, xsize, ysize); 101 int wall_pattern = calc_pattern ('#', layout, i, j);
137 int door_pattern = calc_pattern('D', layout, i, j, xsize, ysize); 102 int door_pattern = calc_pattern ('D', layout, i, j);
138 int join_pattern; 103 int join_pattern;
139 104
140 /* Doors "like" to connect to walls more than other doors. If there is 105 /* Doors "like" to connect to walls more than other doors. If there is
141 * a wall and another door, this door will connect to the wall and 106 * a wall and another door, this door will connect to the wall and
142 * disconnect from the other door. */ 107 * disconnect from the other door. */
143 if (wall_pattern & 3) { 108 if (wall_pattern & 3)
144 join_pattern = wall_pattern; 109 join_pattern = wall_pattern;
145 } else { 110 else
146 join_pattern = door_pattern; 111 join_pattern = door_pattern;
147 }
148 112
149 newlayout[i*2][j*2] = 'D'; 113 newlayout[i * 2][j * 2] = 'D';
150 if (i+1 < xsize) {
151 if (join_pattern & 1) { /* there is a door/wall to the right */
152 newlayout[i*2+1][j*2]='D';
153 }
154 }
155 114
156 if (j+1 < ysize) { 115 if (i + 1 < layout->w)
157 if (join_pattern & 2) { /* there is a door/wall below */ 116 if (join_pattern & 1)
117 /* there is a door/wall to the right */
118 newlayout[i * 2 + 1][j * 2] = 'D';
119
120 if (j + 1 < layout->h)
121 if (join_pattern & 2)
122 /* there is a door/wall below */
158 newlayout[i*2][j*2+1]='D'; 123 newlayout[i * 2][j * 2 + 1] = 'D';
159 }
160 }
161} 124}
162 125
126void
127expand2x (Maze layout)
128{
129 Maze newlayout (layout->w * 2 - 1, layout->h * 2 - 1);
130 newlayout->clear ();
131
132 for (int i = 0; i < layout->w; i++)
133 for (int j = 0; j < layout->h; j++)
134 switch (layout[i][j])
135 {
136 case '#': expand_wall (newlayout, i, j, layout); break;
137 case 'D': expand_door (newlayout, i, j, layout); break;
138 default: expand_misc (newlayout, i, j, layout); break;
139 }
140
141 layout.swap (newlayout);
142}
143

Diff Legend

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