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.1 by elmex, Sun Aug 13 17:16:03 2006 UTC vs.
Revision 1.4 by root, Thu Sep 14 22:34:02 2006 UTC

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

Diff Legend

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