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

Comparing deliantra/server/random_maps/wall.C (file contents):
Revision 1.3 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.12 by root, Sat Dec 30 18:45:28 2006 UTC

1/*
2 * static char *rcsid_wall_c =
3 * "$Id: wall.C,v 1.3 2006/09/03 00:18:42 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29#include <global.h> 24#include <global.h>
30#include <random_map.h> 25#include <random_map.h>
31#include <rproto.h> 26#include <rproto.h>
… …
34 29
35 30
36/* given a layout and a coordinate, tell me which squares up/down/right/left 31/* given a layout and a coordinate, tell me which squares up/down/right/left
37 are occupied. */ 32 are occupied. */
38 33
34int
39int surround_flag(char **layout,int i,int j,RMParms *RP){ 35surround_flag (char **layout, int i, int j, random_map_params * RP)
36{
40 /* 1 = wall to left, 37 /* 1 = wall to left,
41 2 = wall to right, 38 2 = wall to right,
42 4 = wall above 39 4 = wall above
43 8 = wall below */ 40 8 = wall below */
41 int surround_index = 0;
42
43 if ((i > 0) && layout[i - 1][j] != 0)
44 int surround_index = 0; 44 surround_index |= 1;
45 if((i > 0) && layout[i-1][j]!=0) surround_index |=1;
46 if((i < RP->Xsize-1) && layout[i+1][j]!=0) surround_index |=2; 45 if ((i < RP->Xsize - 1) && layout[i + 1][j] != 0)
47 if((j > 0) && layout[i][j-1]!=0) surround_index |=4; 46 surround_index |= 2;
47 if ((j > 0) && layout[i][j - 1] != 0)
48 surround_index |= 4;
48 if((j < RP->Ysize-1) && layout[i][j+1]!=0) surround_index |=8; 49 if ((j < RP->Ysize - 1) && layout[i][j + 1] != 0)
50 surround_index |= 8;
49 return surround_index; 51 return surround_index;
50} 52}
51 53
52 54
53/* like surround_flag, but only walls count. 55/* like surround_flag, but only walls count.
54 */ 56 */
55 57
58int
56int surround_flag2(char **layout,int i,int j,RMParms *RP){ 59surround_flag2 (char **layout, int i, int j, random_map_params * RP)
60{
57 /* 1 = wall to left, 61 /* 1 = wall to left,
58 2 = wall to right, 62 2 = wall to right,
59 4 = wall above 63 4 = wall above
60 8 = wall below */ 64 8 = wall below */
65 int surround_index = 0;
66
67 if ((i > 0) && layout[i - 1][j] == '#')
61 int surround_index = 0; 68 surround_index |= 1;
62 if((i > 0) && layout[i-1][j]=='#') surround_index |=1;
63 if((i < RP->Xsize-1) && layout[i+1][j]=='#') surround_index |=2; 69 if ((i < RP->Xsize - 1) && layout[i + 1][j] == '#')
64 if((j > 0) && layout[i][j-1]=='#') surround_index |=4; 70 surround_index |= 2;
71 if ((j > 0) && layout[i][j - 1] == '#')
72 surround_index |= 4;
65 if((j < RP->Ysize-1) && layout[i][j+1]=='#') surround_index |=8; 73 if ((j < RP->Ysize - 1) && layout[i][j + 1] == '#')
74 surround_index |= 8;
66 return surround_index; 75 return surround_index;
67} 76}
68 77
69 78
70/* like surround_flag, except it checks a map, not a layout. 79/* like surround_flag, except it checks a map, not a layout.
71 * Since this is part of the random map code, presumption 80 * Since this is part of the random map code, presumption
72 * is that this is not a tiled map. 81 * is that this is not a tiled map.
73 * What is considered blocking and not is somewhat hard coded. 82 * What is considered blocking and not is somewhat hard coded.
74 */ 83 */
84int
75int surround_flag3(mapstruct *map,sint16 i,sint16 j,RMParms *RP){ 85surround_flag3 (maptile *map, sint16 i, sint16 j, random_map_params * RP)
86{
76 /* 87 /*
77 * 1 = blocked to left, 88 * 1 = blocked to left,
78 * 2 = blocked to right, 89 * 2 = blocked to right,
79 * 4 = blocked above 90 * 4 = blocked above
80 * 8 = blocked below 91 * 8 = blocked below
81 */ 92 */
82 93
83 int surround_index = 0; 94 int surround_index = 0;
84 95
85 if((i > 0) && (GET_MAP_MOVE_BLOCK(map, i-1,j) & ~MOVE_BLOCK_DEFAULT)) 96 if ((i > 0) && (GET_MAP_MOVE_BLOCK (map, i - 1, j) & ~MOVE_BLOCK_DEFAULT))
86 surround_index |=1; 97 surround_index |= 1;
87 if((i < RP->Xsize-1) && (GET_MAP_MOVE_BLOCK(map, i+1,j) & ~MOVE_BLOCK_DEFAULT)) 98 if ((i < RP->Xsize - 1) && (GET_MAP_MOVE_BLOCK (map, i + 1, j) & ~MOVE_BLOCK_DEFAULT))
88 surround_index |=2; 99 surround_index |= 2;
89 if((j > 0) && (GET_MAP_MOVE_BLOCK(map, i,j-1) & ~MOVE_BLOCK_DEFAULT)) 100 if ((j > 0) && (GET_MAP_MOVE_BLOCK (map, i, j - 1) & ~MOVE_BLOCK_DEFAULT))
90 surround_index |=4; 101 surround_index |= 4;
91 if((j < RP->Ysize-1) && (GET_MAP_MOVE_BLOCK(map,i,j+1) & ~MOVE_BLOCK_DEFAULT)) 102 if ((j < RP->Ysize - 1) && (GET_MAP_MOVE_BLOCK (map, i, j + 1) & ~MOVE_BLOCK_DEFAULT))
92 surround_index |=8; 103 surround_index |= 8;
93 104
94 return surround_index; 105 return surround_index;
95} 106}
96 107
97/* like surround_flag2, except it checks a map, not a layout. */ 108/* like surround_flag2, except it checks a map, not a layout. */
98 109
99int surround_flag4(mapstruct *map,int i,int j,RMParms *RP){ 110int
111surround_flag4 (maptile *map, int i, int j, random_map_params * RP)
112{
100 /* 1 = blocked to left, 113 /* 1 = blocked to left,
101 2 = blocked to right, 114 2 = blocked to right,
102 4 = blocked above 115 4 = blocked above
103 8 = blocked below */ 116 8 = blocked below */
117 int surround_index = 0;
118
119 if ((i > 0) && wall_blocked (map, i - 1, j))
104 int surround_index = 0; 120 surround_index |= 1;
105
106 if((i > 0) && wall_blocked(map,i-1,j)) surround_index |=1;
107 if((i < RP->Xsize-1) && wall_blocked(map,i+1,j)) surround_index |=2; 121 if ((i < RP->Xsize - 1) && wall_blocked (map, i + 1, j))
122 surround_index |= 2;
108 if((j > 0) && wall_blocked(map,i,j-1)) surround_index |=4; 123 if ((j > 0) && wall_blocked (map, i, j - 1))
124 surround_index |= 4;
109 if((j < RP->Ysize-1) && wall_blocked(map,i,j+1)) surround_index |=8; 125 if ((j < RP->Ysize - 1) && wall_blocked (map, i, j + 1))
126 surround_index |= 8;
110 127
111 return surround_index; 128 return surround_index;
112} 129}
113 130
114/* takes a map and a layout, and puts walls in the map (picked from 131/* takes a map and a layout, and puts walls in the map (picked from
115 w_style) at '#' marks. */ 132 w_style) at '#' marks. */
116 133
134void
117void make_map_walls(mapstruct *map,char **layout, char *w_style,RMParms *RP) { 135make_map_walls (maptile *map, char **layout, char *w_style, random_map_params * RP)
136{
118 char styledirname[256]; 137 char styledirname[256];
119 char stylefilepath[256]; 138 char stylefilepath[256];
120 mapstruct *style_map=0; 139 maptile *style_map = 0;
121 object *the_wall; 140 object *the_wall;
122 141
123 /* get the style map */ 142 /* get the style map */
124 if(!strcmp(w_style,"none")) return; 143 if (!strcmp (w_style, "none"))
144 return;
125 sprintf(styledirname,"%s","/styles/wallstyles"); 145 sprintf (styledirname, "%s", "/styles/wallstyles");
126 sprintf(stylefilepath,"%s/%s",styledirname,w_style); 146 sprintf (stylefilepath, "%s/%s", styledirname, w_style);
127 style_map = find_style(styledirname,w_style,-1); 147 style_map = find_style (styledirname, w_style, -1);
128 if(style_map == 0) return; 148 if (style_map == 0)
149 return;
129 150
130 /* fill up the map with the given floor style */ 151 /* fill up the map with the given floor style */
131 if((the_wall=pick_random_object(style_map))!=NULL) { 152 if ((the_wall = pick_random_object (style_map)) != NULL)
153 {
132 int i,j; 154 int i, j;
133 char *cp; 155 char *cp;
134 int joinedwalls=0; 156 int joinedwalls = 0;
135 object *thiswall; 157 object *thiswall;
136 158
137 sprintf(RP->wall_name,"%s", &the_wall->arch->name); 159 sprintf (RP->wall_name, "%s", &the_wall->arch->name);
138 if ((cp=strchr(RP->wall_name,'_'))!=NULL) { 160 if ((cp = strchr (RP->wall_name, '_')) != NULL)
161 {
139 *cp=0; 162 *cp = 0;
140 joinedwalls=1; 163 joinedwalls = 1;
141 } 164 }
142 165
143 for(i=0;i<RP->Xsize;i++) 166 for (i = 0; i < RP->Xsize; i++)
144 for(j=0;j<RP->Ysize;j++) { 167 for (j = 0; j < RP->Ysize; j++)
168 {
145 if(layout[i][j]=='#') { 169 if (layout[i][j] == '#')
170 {
146 if(joinedwalls) 171 if (joinedwalls)
147 thiswall=pick_joined_wall(the_wall,layout,i,j,RP); 172 thiswall = pick_joined_wall (the_wall, layout, i, j, RP);
148 else 173 else
149 thiswall=arch_to_object(the_wall->arch); 174 thiswall = arch_to_object (the_wall->arch);
150 thiswall->x = i; 175 thiswall->x = i;
151 thiswall->y = j; 176 thiswall->y = j;
152 thiswall->move_block = MOVE_ALL; 177 thiswall->move_block = MOVE_ALL;
153 insert_ob_in_map(thiswall,map,thiswall,INS_NO_MERGE | INS_NO_WALK_ON); 178 insert_ob_in_map (thiswall, map, thiswall, INS_NO_MERGE | INS_NO_WALK_ON);
154 } 179 }
155 } 180 }
156 } 181 }
157} 182}
158 183
159 184
160/* picks the right wall type for this square, to make it look nice, 185/* picks the right wall type for this square, to make it look nice,
161 and have everything nicely joined. It uses the layout. */ 186 and have everything nicely joined. It uses the layout. */
162 187
188object *
163object *pick_joined_wall(object *the_wall,char **layout,int i,int j,RMParms *RP) { 189pick_joined_wall (object *the_wall, char **layout, int i, int j, random_map_params * RP)
190{
164 /* 1 = wall to left, 191 /* 1 = wall to left,
165 2 = wall to right, 192 2 = wall to right,
166 4 = wall above 193 4 = wall above
167 8 = wall below */ 194 8 = wall below */
168 int surround_index=0; 195 int surround_index = 0;
169 int l; 196 int l;
170 char wall_name[64]; 197 char wall_name[64];
171 archetype *wall_arch=0; 198 archetype *wall_arch = 0;
172 199
173 strcpy(wall_name,the_wall->arch->name); 200 strcpy (wall_name, the_wall->arch->name);
174 201
175 /* conventionally, walls are named like this: 202 /* conventionally, walls are named like this:
176 wallname_wallcode, where wallcode indicates 203 wallname_wallcode, where wallcode indicates
177 a joinedness, and wallname is the wall. 204 a joinedness, and wallname is the wall.
178 this code depends on the convention for 205 this code depends on the convention for
179 finding the right wall. */ 206 finding the right wall. */
180 207
181 /* extract the wall name, which is the text up to the leading _ */ 208 /* extract the wall name, which is the text up to the leading _ */
182 for(l=0;l<64;l++) { 209 for (l = 0; l < 64; l++)
210 {
183 if(wall_name[l]=='_') { 211 if (wall_name[l] == '_')
212 {
184 wall_name[l] = 0; 213 wall_name[l] = 0;
185 break;
186 }
187 }
188
189 surround_index = surround_flag2(layout,i,j,RP);
190
191 switch(surround_index) {
192 case 0:
193 strcat(wall_name,"_0");
194 break; 214 break;
195 case 1: 215 }
216 }
217
218 surround_index = surround_flag2 (layout, i, j, RP);
219
220 switch (surround_index)
221 {
222 case 0:
196 strcat(wall_name,"_1_3"); 223 strcat (wall_name, "_0");
197 break; 224 break;
198 case 2: 225 case 1:
199 strcat(wall_name,"_1_4"); 226 strcat (wall_name, "_1_3");
200 break; 227 break;
201 case 3: 228 case 2:
202 strcat(wall_name,"_2_1_2"); 229 strcat (wall_name, "_1_4");
203 break; 230 break;
204 case 4: 231 case 3:
205 strcat(wall_name,"_1_2"); 232 strcat (wall_name, "_2_1_2");
206 break; 233 break;
207 case 5: 234 case 4:
208 strcat(wall_name,"_2_2_4"); 235 strcat (wall_name, "_1_2");
209 break; 236 break;
210 case 6: 237 case 5:
211 strcat(wall_name,"_2_2_1"); 238 strcat (wall_name, "_2_2_4");
212 break; 239 break;
213 case 7: 240 case 6:
214 strcat(wall_name,"_3_1"); 241 strcat (wall_name, "_2_2_1");
215 break; 242 break;
216 case 8: 243 case 7:
217 strcat(wall_name,"_1_1"); 244 strcat (wall_name, "_3_1");
218 break; 245 break;
219 case 9: 246 case 8:
220 strcat(wall_name,"_2_2_3"); 247 strcat (wall_name, "_1_1");
221 break; 248 break;
222 case 10: 249 case 9:
223 strcat(wall_name,"_2_2_2"); 250 strcat (wall_name, "_2_2_3");
224 break; 251 break;
225 case 11: 252 case 10:
226 strcat(wall_name,"_3_3"); 253 strcat (wall_name, "_2_2_2");
227 break; 254 break;
228 case 12: 255 case 11:
229 strcat(wall_name,"_2_1_1"); 256 strcat (wall_name, "_3_3");
230 break; 257 break;
231 case 13: 258 case 12:
232 strcat(wall_name,"_3_4"); 259 strcat (wall_name, "_2_1_1");
233 break; 260 break;
234 case 14: 261 case 13:
235 strcat(wall_name,"_3_2"); 262 strcat (wall_name, "_3_4");
236 break; 263 break;
237 case 15: 264 case 14:
238 strcat(wall_name,"_4"); 265 strcat (wall_name, "_3_2");
239 break; 266 break;
267 case 15:
268 strcat (wall_name, "_4");
269 break;
240 } 270 }
241 wall_arch = find_archetype(wall_name); 271 wall_arch = archetype::find (wall_name);
242 if(wall_arch) return arch_to_object(wall_arch); 272
243 else { 273 return wall_arch
244 nroferrors--; 274 ? arch_to_object (wall_arch)
245 return arch_to_object(the_wall->arch); 275 : arch_to_object (the_wall->arch);
246 }
247
248
249} 276}
250 277
251 278
252/* this takes a map, and changes an existing wall to match what's blocked 279/* this takes a map, and changes an existing wall to match what's blocked
253 * around it, counting only doors and walls as blocked. If insert_flag is 280 * around it, counting only doors and walls as blocked. If insert_flag is
254 * 1, it will go ahead and insert the wall into the map. If not, it 281 * 1, it will go ahead and insert the wall into the map. If not, it
255 * will only return the wall which would belong there, and doesn't 282 * will only return the wall which would belong there, and doesn't
256 * remove anything. It depends on the 283 * remove anything. It depends on the
257 * global, previously-set variable, "wall_name" 284 * global, previously-set variable, "wall_name"
258 */ 285 */
259 286
287object *
260object * retrofit_joined_wall(mapstruct *the_map,int i,int j,int insert_flag,RMParms *RP) { 288retrofit_joined_wall (maptile *the_map, int i, int j, int insert_flag, random_map_params * RP)
289{
261 /* 1 = wall to left, 290 /* 1 = wall to left,
262 * 2 = wall to right, 291 * 2 = wall to right,
263 * 4 = wall above 292 * 4 = wall above
264 * 8 = wall below 293 * 8 = wall below
265 */ 294 */
266 int surround_index=0; 295 int surround_index = 0;
267 int l; 296 int l;
268 object *the_wall=0; 297 object *the_wall = 0;
269 object *new_wall=0; 298 object *new_wall = 0;
270 archetype * wall_arch=0; 299 archetype *wall_arch = 0;
271 300
272 /* first find the wall */ 301 /* first find the wall */
273 for(the_wall = get_map_ob(the_map,i,j);the_wall!=NULL;the_wall=the_wall->above) 302 for (the_wall = GET_MAP_OB (the_map, i, j); the_wall != NULL; the_wall = the_wall->above)
274 if ((the_wall->move_type & MOVE_WALK) && the_wall->type!=EXIT && the_wall->type!=TELEPORTER) 303 if ((the_wall->move_type & MOVE_WALK) && the_wall->type != EXIT && the_wall->type != TELEPORTER)
275 break; 304 break;
276 305
277 306
278 /* if what we found is a door, don't remove it, set the_wall to NULL to 307 /* if what we found is a door, don't remove it, set the_wall to NULL to
279 * signal that later. 308 * signal that later.
280 */ 309 */
281 if(the_wall && (the_wall->type==DOOR || the_wall->type==LOCKED_DOOR) ) { 310 if (the_wall && (the_wall->type == DOOR || the_wall->type == LOCKED_DOOR))
311 {
282 the_wall=NULL; 312 the_wall = NULL;
283 /* if we're not supposed to insert a new wall where there wasn't one, 313 /* if we're not supposed to insert a new wall where there wasn't one,
284 * we've gotta leave. 314 * we've gotta leave.
285 */ 315 */
286 if(insert_flag==0) return 0; 316 if (insert_flag == 0)
317 return 0;
287 } 318 }
288 else if(the_wall==NULL) return NULL; 319 else if (the_wall == NULL)
320 return NULL;
289 321
290 /* canonicalize the wall name */ 322 /* canonicalize the wall name */
291 for(l=0;l<64;l++) { 323 for (l = 0; l < 64; l++)
324 {
292 if(RP->wall_name[l]=='_') { 325 if (RP->wall_name[l] == '_')
326 {
293 RP->wall_name[l] = 0; 327 RP->wall_name[l] = 0;
294 break; 328 break;
295 } 329 }
296 } 330 }
297 331
298 surround_index = surround_flag4(the_map,i,j,RP); 332 surround_index = surround_flag4 (the_map, i, j, RP);
299 /* This would be a lot cleaner to just us a lookup table, 333 /* This would be a lot cleaner to just us a lookup table,
300 * eg, wall_suffix[surround_index] 334 * eg, wall_suffix[surround_index]
301 */ 335 */
302 switch(surround_index) { 336 switch (surround_index)
337 {
303 case 0: 338 case 0:
304 strcat(RP->wall_name,"_0"); 339 strcat (RP->wall_name, "_0");
305 break; 340 break;
306 case 1: 341 case 1:
307 strcat(RP->wall_name,"_1_3"); 342 strcat (RP->wall_name, "_1_3");
308 break; 343 break;
309 case 2: 344 case 2:
310 strcat(RP->wall_name,"_1_4"); 345 strcat (RP->wall_name, "_1_4");
311 break; 346 break;
312 case 3: 347 case 3:
313 strcat(RP->wall_name,"_2_1_2"); 348 strcat (RP->wall_name, "_2_1_2");
314 break; 349 break;
315 case 4: 350 case 4:
316 strcat(RP->wall_name,"_1_2"); 351 strcat (RP->wall_name, "_1_2");
317 break; 352 break;
318 case 5: 353 case 5:
319 strcat(RP->wall_name,"_2_2_4"); 354 strcat (RP->wall_name, "_2_2_4");
320 break; 355 break;
321 case 6: 356 case 6:
322 strcat(RP->wall_name,"_2_2_1"); 357 strcat (RP->wall_name, "_2_2_1");
323 break; 358 break;
324 case 7: 359 case 7:
325 strcat(RP->wall_name,"_3_1"); 360 strcat (RP->wall_name, "_3_1");
326 break; 361 break;
327 case 8: 362 case 8:
328 strcat(RP->wall_name,"_1_1"); 363 strcat (RP->wall_name, "_1_1");
329 break; 364 break;
330 case 9: 365 case 9:
331 strcat(RP->wall_name,"_2_2_3"); 366 strcat (RP->wall_name, "_2_2_3");
332 break; 367 break;
333 case 10: 368 case 10:
334 strcat(RP->wall_name,"_2_2_2"); 369 strcat (RP->wall_name, "_2_2_2");
335 break; 370 break;
336 case 11: 371 case 11:
337 strcat(RP->wall_name,"_3_3"); 372 strcat (RP->wall_name, "_3_3");
338 break; 373 break;
339 case 12: 374 case 12:
340 strcat(RP->wall_name,"_2_1_1"); 375 strcat (RP->wall_name, "_2_1_1");
341 break; 376 break;
342 case 13: 377 case 13:
343 strcat(RP->wall_name,"_3_4"); 378 strcat (RP->wall_name, "_3_4");
344 break; 379 break;
345 case 14: 380 case 14:
346 strcat(RP->wall_name,"_3_2"); 381 strcat (RP->wall_name, "_3_2");
347 break; 382 break;
348 case 15: 383 case 15:
349 strcat(RP->wall_name,"_4"); 384 strcat (RP->wall_name, "_4");
350 break; 385 break;
351 } 386 }
387
352 wall_arch = find_archetype(RP->wall_name); 388 wall_arch = archetype::find (RP->wall_name);
353 if(wall_arch!=NULL) { 389
390 if (!wall_arch)
391 {
354 new_wall=arch_to_object(wall_arch); 392 new_wall = arch_to_object (wall_arch);
355 new_wall->x = i; 393 new_wall->x = i;
356 new_wall->y = j; 394 new_wall->y = j;
395
357 if(the_wall && the_wall->map) { 396 if (the_wall && the_wall->map)
358 remove_ob(the_wall); 397 {
359 free_object(the_wall); 398 the_wall->remove ();
399 the_wall->destroy ();
360 } 400 }
401
361 the_wall->move_block = MOVE_ALL; 402 the_wall->move_block = MOVE_ALL;
362 insert_ob_in_map(new_wall,the_map,new_wall,INS_NO_MERGE | INS_NO_WALK_ON); 403 insert_ob_in_map (new_wall, the_map, new_wall, INS_NO_MERGE | INS_NO_WALK_ON);
363 } 404 }
364 else 405
365 nroferrors--; /* it's OK not to find an arch. */
366 return new_wall; 406 return new_wall;
367} 407}
368
369

Diff Legend

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