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.4 by root, Thu Sep 14 22:34:02 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.4 2006/09/14 22:34:02 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, int xsize, int ysize);
19static void expand_wall (char **newlayout, int i, int j, char **layout, int xsize, int ysize);
20static void expand_door (char **newlayout, int i, int j, char **layout, int xsize, int ysize);
21
22
23/* FUNCTIONS */
24
25char **
26expand2x (char **layout, int xsize, int ysize)
27{
28 int i, j;
29 int nxsize = xsize * 2 - 1;
30 int nysize = ysize * 2 - 1;
31
32 /* Allocate new layout */
33 char **newlayout = (char **) calloc (sizeof (char *), nxsize);
34
35 for (i = 0; i < nxsize; i++)
36 {
37 newlayout[i] = (char *) calloc (sizeof (char), nysize);
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 }
56 }
57
58 /* Dump old layout */
59 for (i = 0; i < xsize; i++)
60 {
61 free (layout[i]);
62 }
63 free (layout);
64
65 return newlayout;
66}
67 16
68/* 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
69 * fill up the rest of the 2x2 result with \0: 18 * fill up the rest of the 2x2 result with \0:
70 * X ---> X \0 19 * X ---> X \0
71 * \0 \0 20 * \0 \0
72 */ 21 */
73static void 22static void
74expand_misc (char **newlayout, int i, int j, char **layout, int xsize, int ysize) 23expand_misc (Maze newlayout, int i, int j, Maze layout)
75{ 24{
76 newlayout[i * 2][j * 2] = layout[i][j]; 25 newlayout[i * 2][j * 2] = layout[i][j];
77 /* (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
78 * for us.) */ 27 * for us.) */
79} 28}
… …
84 * 2 match on (i, j+1) 33 * 2 match on (i, j+1)
85 * 4 match on (i+1, j+1) 34 * 4 match on (i+1, j+1)
86 * and the possible combinations thereof. 35 * and the possible combinations thereof.
87 */ 36 */
88static int 37static int
89calc_pattern (char ch, char **layout, int i, int j, int xsize, int ysize) 38calc_pattern (char ch, Maze layout, int i, int j)
90{ 39{
91 int pattern = 0; 40 int pattern = 0;
92 41
93 if (i + 1 < xsize && layout[i + 1][j] == ch) 42 if (i + 1 < layout->w && layout[i + 1][j] == ch)
94 pattern |= 1; 43 pattern |= 1;
95 44
96 if (j + 1 < ysize) 45 if (j + 1 < layout->h)
97 { 46 {
98 if (layout[i][j + 1] == ch) 47 if (layout[i][j + 1] == ch)
99 pattern |= 2; 48 pattern |= 2;
100 if (i + 1 < xsize && layout[i + 1][j + 1] == ch) 49 if (i + 1 < layout->w && layout[i + 1][j + 1] == ch)
101 pattern |= 4; 50 pattern |= 4;
102 } 51 }
103 52
104 return pattern; 53 return pattern;
105} 54}
… …
107/* 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
108 * 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
109 * walls. 58 * walls.
110 */ 59 */
111static void 60static void
112expand_wall (char **newlayout, int i, int j, char **layout, int xsize, int ysize) 61expand_wall (Maze newlayout, int i, int j, Maze layout)
113{ 62{
114 int wall_pattern = calc_pattern ('#', layout, i, j, xsize, ysize); 63 int wall_pattern = calc_pattern ('#', layout, i, j);
115 int door_pattern = calc_pattern ('D', layout, i, j, xsize, ysize); 64 int door_pattern = calc_pattern ('D', layout, i, j);
116 int both_pattern = wall_pattern | door_pattern; 65 int both_pattern = wall_pattern | door_pattern;
117 66
118 newlayout[i * 2][j * 2] = '#'; 67 newlayout[i * 2][j * 2] = '#';
119 if (i + 1 < xsize) 68
69 if (i + 1 < layout->w)
120 { 70 {
121 if (both_pattern & 1) 71 if (both_pattern & 1)
122 { /* join walls/doors to the right */ 72 { /* join walls/doors to the right */
123
124/* newlayout[i*2+1][j*2] = '#'; */ 73/* newlayout[i*2+1][j*2] = '#'; */
125 newlayout[i * 2 + 1][j * 2] = layout[i + 1][j]; 74 newlayout[i * 2 + 1][j * 2] = layout[i + 1][j];
126 } 75 }
127 } 76 }
128 77
129 if (j + 1 < ysize) 78 if (j + 1 < layout->h)
130 { 79 {
131 if (both_pattern & 2) 80 if (both_pattern & 2)
132 { /* join walls/doors to the bottom */ 81 { /* join walls/doors to the bottom */
133
134/* newlayout[i*2][j*2+1] = '#'; */ 82/* newlayout[i*2][j*2+1] = '#'; */
135 newlayout[i * 2][j * 2 + 1] = layout[i][j + 1]; 83 newlayout[i * 2][j * 2 + 1] = layout[i][j + 1];
136 } 84 }
137 85
138 if (wall_pattern == 7) 86 if (wall_pattern == 7)
… …
146/* 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
147 * adjacent walls. Note that it will also presumptuously delete (ignore) doors 95 * adjacent walls. Note that it will also presumptuously delete (ignore) doors
148 * that it doesn't know how to correctly expand. 96 * that it doesn't know how to correctly expand.
149 */ 97 */
150static void 98static void
151expand_door (char **newlayout, int i, int j, char **layout, int xsize, int ysize) 99expand_door (Maze newlayout, int i, int j, Maze layout)
152{ 100{
153 int wall_pattern = calc_pattern ('#', layout, i, j, xsize, ysize); 101 int wall_pattern = calc_pattern ('#', layout, i, j);
154 int door_pattern = calc_pattern ('D', layout, i, j, xsize, ysize); 102 int door_pattern = calc_pattern ('D', layout, i, j);
155 int join_pattern; 103 int join_pattern;
156 104
157 /* 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
158 * 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
159 * disconnect from the other door. */ 107 * disconnect from the other door. */
160 if (wall_pattern & 3) 108 if (wall_pattern & 3)
161 {
162 join_pattern = wall_pattern; 109 join_pattern = wall_pattern;
163 }
164 else 110 else
165 {
166 join_pattern = door_pattern; 111 join_pattern = door_pattern;
167 }
168 112
169 newlayout[i * 2][j * 2] = 'D'; 113 newlayout[i * 2][j * 2] = 'D';
170 if (i + 1 < xsize) 114
171 { 115 if (i + 1 < layout->w)
172 if (join_pattern & 1) 116 if (join_pattern & 1)
173 { /* there is a door/wall to the right */ 117 /* there is a door/wall to the right */
174 newlayout[i * 2 + 1][j * 2] = 'D'; 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 */
123 newlayout[i * 2][j * 2 + 1] = 'D';
124}
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;
175 } 139 }
176 }
177 140
178 if (j + 1 < ysize) 141 layout.swap (newlayout);
179 {
180 if (join_pattern & 2)
181 { /* there is a door/wall below */
182 newlayout[i * 2][j * 2 + 1] = 'D';
183 }
184 }
185} 142}
143

Diff Legend

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