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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:03 2006 UTC vs.
Revision 1.12 by root, Sun Dec 31 19:02:24 2006 UTC

1/*
2 * static char *rcsid_treasure_c =
3 * "$Id: treasure.C,v 1.1 2006/08/13 17:16:03 elmex Exp $";
4 */
5 1
6/* 2/*
7 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
8 4
9 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
… …
21 17
22 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 23*/
28 24
29/* placing treasure in maps, where appropriate. */ 25/* placing treasure in maps, where appropriate. */
30 26
31 27
… …
34#include <random_map.h> 30#include <random_map.h>
35#include <rproto.h> 31#include <rproto.h>
36 32
37/* some defines for various options which can be set. */ 33/* some defines for various options which can be set. */
38 34
39#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */ 35#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */
40#define HIDDEN 2 /* doors to treasure are hidden. */ 36#define HIDDEN 2 /* doors to treasure are hidden. */
41#define KEYREQUIRED 4 /* chest has a key, which is placed randomly in the map. */ 37#define KEYREQUIRED 4 /* chest has a key, which is placed randomly in the map. */
42#define DOORED 8 /* treasure has doors around it. */ 38#define DOORED 8 /* treasure has doors around it. */
43#define TRAPPED 16 /* trap dropped in same location as chest. */ 39#define TRAPPED 16 /* trap dropped in same location as chest. */
44#define SPARSE 32 /* 1/2 as much treasure as default */ 40#define SPARSE 32 /* 1/2 as much treasure as default */
45#define RICH 64 /* 2x as much treasure as default */ 41#define RICH 64 /* 2x as much treasure as default */
46#define FILLED 128 /* Fill/tile the entire map with treasure */ 42#define FILLED 128 /* Fill/tile the entire map with treasure */
47#define LAST_OPTION 64 /* set this to the last real option, for random */ 43#define LAST_OPTION 64 /* set this to the last real option, for random */
48 44
49#define NO_PASS_DOORS 0 45#define NO_PASS_DOORS 0
50#define PASS_DOORS 1 46#define PASS_DOORS 1
51 47
52 48
53/* returns true if square x,y has P_NO_PASS set, which is true for walls 49/* returns true if square x,y has P_NO_PASS set, which is true for walls
54 * and doors but not monsters. 50 * and doors but not monsters.
55 * This function is not map tile aware. 51 * This function is not map tile aware.
56 */ 52 */
57 53
54int
58int wall_blocked(mapstruct *m, int x, int y) { 55wall_blocked (maptile *m, int x, int y)
56{
59 int r; 57 int r;
60 58
61 if(OUT_OF_REAL_MAP(m,x,y)) 59 if (OUT_OF_REAL_MAP (m, x, y))
62 return 1; 60 return 1;
63 r = GET_MAP_MOVE_BLOCK(m,x,y) & ~MOVE_BLOCK_DEFAULT; 61 r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;
64 return r; 62 return r;
65} 63}
66 64
67/* place treasures in the map, given the 65/* place treasures in the map, given the
68map, (required) 66map, (required)
69layout, (required) 67layout, (required)
70treasure style (may be empty or NULL, or "none" to cause no treasure.) 68treasure style (may be empty or NULL, or "none" to cause no treasure.)
71treasureoptions (may be 0 for random choices or positive) 69treasureoptions (may be 0 for random choices or positive)
72*/ 70*/
73 71
72void
74void place_treasure(mapstruct *map,char **layout, char *treasure_style,int treasureoptions,RMParms *RP) { 73place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP)
74{
75 char styledirname[256]; 75 char styledirname[256];
76 char stylefilepath[256]; 76 char stylefilepath[256];
77 mapstruct *style_map=0; 77 maptile *style_map = 0;
78 int num_treasures; 78 int num_treasures;
79 79
80 /* bail out if treasure isn't wanted. */ 80 /* bail out if treasure isn't wanted. */
81 if(treasure_style) if(!strcmp(treasure_style,"none")) return; 81 if (treasure_style)
82 if (!strcmp (treasure_style, "none"))
83 return;
84 if (treasureoptions <= 0)
82 if(treasureoptions<=0) treasureoptions=RANDOM() % (2*LAST_OPTION); 85 treasureoptions = RANDOM () % (2 * LAST_OPTION);
83 86
84 /* filter out the mutually exclusive options */ 87 /* filter out the mutually exclusive options */
85 if((treasureoptions & RICH) &&(treasureoptions &SPARSE)) { 88 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
86 if(RANDOM()%2) treasureoptions -=1; 89 {
90 if (RANDOM () % 2)
91 treasureoptions -= 1;
92 else
87 else treasureoptions-=2;} 93 treasureoptions -= 2;
94 }
88 95
89 /* pick the number of treasures */ 96 /* pick the number of treasures */
90 if(treasureoptions & SPARSE) 97 if (treasureoptions & SPARSE)
91 num_treasures = BC_RANDOM(RP->total_map_hp/600+RP->difficulty/2+1); 98 num_treasures = BC_RANDOM (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);
92 else if(treasureoptions & RICH) 99 else if (treasureoptions & RICH)
93 num_treasures = BC_RANDOM(RP->total_map_hp/150+2*RP->difficulty+1); 100 num_treasures = BC_RANDOM (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);
101 else
94 else num_treasures = BC_RANDOM(RP->total_map_hp/300+RP->difficulty+1); 102 num_treasures = BC_RANDOM (RP->total_map_hp / 300 + RP->difficulty + 1);
95 103
96 if(num_treasures <= 0 ) return; 104 if (num_treasures <= 0)
105 return;
97 106
98 /* get the style map */ 107 /* get the style map */
99 sprintf(styledirname,"%s","/styles/treasurestyles"); 108 sprintf (styledirname, "%s", "/styles/treasurestyles");
100 sprintf(stylefilepath,"%s/%s",styledirname,treasure_style); 109 sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
101 style_map = find_style(styledirname,treasure_style,-1); 110 style_map = find_style (styledirname, treasure_style, -1);
102 111
103 /* all the treasure at one spot in the map. */ 112 /* all the treasure at one spot in the map. */
104 if(treasureoptions & CONCENTRATED) { 113 if (treasureoptions & CONCENTRATED)
114 {
105 115
106 /* map_layout_style global, and is previously set */ 116 /* map_layout_style global, and is previously set */
107 switch(RP->map_layout_style) { 117 switch (RP->map_layout_style)
108 case ONION_LAYOUT:
109 case SPIRAL_LAYOUT:
110 case SQUARE_SPIRAL_LAYOUT:
111 { 118 {
119 case LAYOUT_ONION:
120 case LAYOUT_SPIRAL:
121 case LAYOUT_SQUARE_SPIRAL:
122 {
112 int i,j; 123 int i, j;
124
113 /* search the onion for C's or '>', and put treasure there. */ 125 /* search the onion for C's or '>', and put treasure there. */
114 for(i=0;i<RP->Xsize;i++) { 126 for (i = 0; i < RP->Xsize; i++)
127 {
115 for(j=0;j<RP->Ysize;j++) { 128 for (j = 0; j < RP->Ysize; j++)
129 {
116 if(layout[i][j]=='C' || layout[i][j]=='>') { 130 if (layout[i][j] == 'C' || layout[i][j] == '>')
131 {
117 int tdiv = RP->symmetry_used; 132 int tdiv = RP->symmetry_used;
133 object **doorlist;
134 object *chest;
135
136 if (tdiv == 3)
137 tdiv = 2; /* this symmetry uses a divisor of 2 */
138 /* don't put a chest on an exit. */
139 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
140 if (!chest)
141 continue; /* if no chest was placed NEXT */
142 if (treasureoptions & (DOORED | HIDDEN))
143 {
144 doorlist = find_doors_in_room (map, i, j, RP);
145 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
146 free (doorlist);
147 }
148 }
149 }
150 }
151 break;
152 }
153 default:
154 {
155 int i, j, tries;
156 object *chest;
118 object **doorlist; 157 object **doorlist;
119 object *chest; 158
120 if(tdiv==3) tdiv = 2; /* this symmetry uses a divisor of 2*/ 159 i = j = -1;
121 /* don't put a chest on an exit. */ 160 tries = 0;
161 while (i == -1 && tries < 100)
162 {
163 i = RANDOM () % (RP->Xsize - 2) + 1;
164 j = RANDOM () % (RP->Ysize - 2) + 1;
165 find_enclosed_spot (map, &i, &j, RP);
166 if (wall_blocked (map, i, j))
167 i = -1;
168 tries++;
169 }
122 chest=place_chest(treasureoptions,i,j,map,style_map,num_treasures/tdiv,RP); 170 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
123 if(!chest) continue; /* if no chest was placed NEXT */ 171 if (!chest)
172 return;
173 i = chest->x;
174 j = chest->y;
124 if(treasureoptions & (DOORED|HIDDEN)) { 175 if (treasureoptions & (DOORED | HIDDEN))
125 doorlist=find_doors_in_room(map,i,j,RP); 176 {
177 doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
126 lock_and_hide_doors(doorlist,map,treasureoptions,RP); 178 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
127 free(doorlist); 179 free (doorlist);
128 } 180 }
129 } 181 }
130 } 182 }
183 }
184 else
185 { /* DIFFUSE treasure layout */
186 int ti, i, j;
187
188 for (ti = 0; ti < num_treasures; ti++)
131 } 189 {
132 break;
133 }
134 default:
135 {
136 int i,j,tries;
137 object *chest;
138 object **doorlist;
139 i=j=-1;tries=0;
140 while(i==-1&&tries<100) {
141 i = RANDOM()%(RP->Xsize-2)+1; 190 i = RANDOM () % (RP->Xsize - 2) + 1;
142 j = RANDOM()%(RP->Ysize-2)+1; 191 j = RANDOM () % (RP->Ysize - 2) + 1;
143 find_enclosed_spot(map,&i,&j,RP);
144 if(wall_blocked(map,i,j)) i=-1;
145 tries++;
146 }
147 chest=place_chest(treasureoptions,i,j,map,style_map,num_treasures,RP);
148 if(!chest) return;
149 i = chest->x; j = chest->y;
150 if(treasureoptions & (DOORED|HIDDEN)) {
151 doorlist=surround_by_doors(map,layout,i,j,treasureoptions);
152 lock_and_hide_doors(doorlist,map,treasureoptions,RP);
153 free(doorlist);
154 }
155 }
156 }
157 }
158 else { /* DIFFUSE treasure layout */
159 int ti,i,j;
160 for(ti=0;ti<num_treasures;ti++) {
161 i = RANDOM()%(RP->Xsize-2)+1;
162 j = RANDOM()%(RP->Ysize-2)+1;
163 place_chest(treasureoptions,i,j,map,style_map,1,RP); 192 place_chest (treasureoptions, i, j, map, style_map, 1, RP);
164 } 193 }
165 } 194 }
166} 195}
167
168
169 196
170/* put a chest into the map, near x and y, with the treasure style 197/* put a chest into the map, near x and y, with the treasure style
171 determined (may be null, or may be a treasure list from lib/treasures, 198 determined (may be null, or may be a treasure list from lib/treasures,
172 if the global variable "treasurestyle" is set to that treasure list's name */ 199 if the global variable "treasurestyle" is set to that treasure list's name */
173 200
201object *
174object * place_chest(int treasureoptions,int x, int y,mapstruct *map, mapstruct *style_map,int n_treasures,RMParms *RP) { 202place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
203{
175 object *the_chest; 204 object *the_chest;
176 int i,xl,yl; 205 int i, xl, yl;
177 206
178 the_chest = get_archetype("chest"); /* was "chest_2" */ 207 the_chest = get_archetype ("chest"); /* was "chest_2" */
179 208
180 /* first, find a place to put the chest. */ 209 /* first, find a place to put the chest. */
181 i = find_first_free_spot(the_chest,map,x,y); 210 i = find_first_free_spot (the_chest, map, x, y);
182 if (i == -1) { 211 if (i == -1)
183 free_object(the_chest); 212 {
213 the_chest->destroy ();
184 return NULL; 214 return NULL;
185 } 215 }
186 xl = x + freearr_x[i]; yl = y + freearr_y[i]; 216 xl = x + freearr_x[i];
217 yl = y + freearr_y[i];
187 218
188 /* if the placement is blocked, return a fail. */ 219 /* if the placement is blocked, return a fail. */
189 if(wall_blocked(map,xl,yl)) return 0; 220 if (wall_blocked (map, xl, yl))
190 221 return 0;
191 222
192 /* put the treasures in the chest. */ 223 /* put the treasures in the chest. */
193 /* if(style_map) { */ 224 /* if(style_map) { */
194#if 0 /* don't use treasure style maps for now! */ 225#if 0 /* don't use treasure style maps for now! */
195 int ti; 226 int ti;
227
196 /* if treasurestyle lists a treasure list, use it. */ 228 /* if treasurestyle lists a treasure list, use it. */
197 treasurelist *tlist=find_treasurelist(RP->treasurestyle); 229 treasurelist *tlist = find_treasurelist (RP->treasurestyle);
230
198 if(tlist!=NULL) 231 if (tlist != NULL)
199 for(ti=0;ti<n_treasures;ti++) { /* use the treasure list */ 232 for (ti = 0; ti < n_treasures; ti++)
233 { /* use the treasure list */
200 object *new_treasure=pick_random_object(style_map); 234 object *new_treasure = pick_random_object (style_map);
235
201 insert_ob_in_ob(arch_to_object(new_treasure->arch),the_chest); 236 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
202 } 237 }
203 else { /* use the style map */ 238 else
239 { /* use the style map */
240 the_chest->randomitems = tlist;
241 the_chest->stats.hp = n_treasures;
242 }
243#endif
244 { /* neither style_map no treasure list given */
245 treasurelist *tlist = find_treasurelist ("chest");
246
204 the_chest->randomitems=tlist; 247 the_chest->randomitems = tlist;
205 the_chest->stats.hp = n_treasures; 248 the_chest->stats.hp = n_treasures;
206 } 249 }
207#endif
208 else { /* neither style_map no treasure list given */
209 treasurelist *tlist=find_treasurelist("chest");
210 the_chest->randomitems=tlist;
211 the_chest->stats.hp = n_treasures;
212 }
213 250
214 /* stick a trap in the chest if required */ 251 /* stick a trap in the chest if required */
215 if(treasureoptions & TRAPPED) { 252 if (treasureoptions & TRAPPED)
253 {
216 mapstruct *trap_map=find_style("/styles/trapstyles","traps",-1); 254 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
217 object *the_trap; 255 object *the_trap;
256
218 if(trap_map) { 257 if (trap_map)
258 {
219 the_trap= pick_random_object(trap_map); 259 the_trap = pick_random_object (trap_map);
220 the_trap->stats.Cha = 10+RP->difficulty; 260 the_trap->stats.Cha = 10 + RP->difficulty;
221 the_trap->level = BC_RANDOM((3*RP->difficulty)/2); 261 the_trap->level = BC_RANDOM ((3 * RP->difficulty) / 2);
222 if(the_trap) { 262 if (the_trap)
263 {
223 object *new_trap; 264 object *new_trap;
265
224 new_trap = arch_to_object(the_trap->arch); 266 new_trap = arch_to_object (the_trap->arch);
225 copy_object(new_trap,the_trap); 267 new_trap->copy_to (the_trap);
226 new_trap->x = x; 268 new_trap->x = x;
227 new_trap->y = y; 269 new_trap->y = y;
228 insert_ob_in_ob(new_trap,the_chest); 270 insert_ob_in_ob (new_trap, the_chest);
271 }
229 } 272 }
230 }
231 } 273 }
232 274
233 /* set the chest lock code, and call the keyplacer routine with 275 /* set the chest lock code, and call the keyplacer routine with
234 the lockcode. It's not worth bothering to lock the chest if 276 the lockcode. It's not worth bothering to lock the chest if
235 there's only 1 treasure....*/ 277 there's only 1 treasure.... */
236 278
237 if((treasureoptions & KEYREQUIRED)&&n_treasures>1) { 279 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
280 {
238 char keybuf[256]; 281 char keybuf[256];
282
239 sprintf(keybuf,"%d",(int)RANDOM()); 283 sprintf (keybuf, "%d", (int) RANDOM ());
240 the_chest->slaying = add_string(keybuf); 284 the_chest->slaying = keybuf;
241 keyplace(map,x,y,keybuf,PASS_DOORS,1,RP); 285 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
242 } 286 }
243 287
244 /* actually place the chest. */ 288 /* actually place the chest. */
245 the_chest->x = xl; the_chest->y = yl; 289 the_chest->x = xl;
290 the_chest->y = yl;
246 insert_ob_in_map(the_chest,map,NULL,0); 291 insert_ob_in_map (the_chest, map, NULL, 0);
247 return the_chest; 292 return the_chest;
248} 293}
249 294
250 295
251/* finds the closest monster and returns him, regardless of doors 296/* finds the closest monster and returns him, regardless of doors
252 or walls */ 297 or walls */
253object *find_closest_monster(mapstruct *map,int x,int y,RMParms *RP) { 298object *
299find_closest_monster (maptile *map, int x, int y, random_map_params *RP)
300{
254 int i; 301 int i;
302
255 for(i=0;i<SIZEOFFREE;i++) { 303 for (i = 0; i < SIZEOFFREE; i++)
304 {
256 int lx,ly; 305 int lx, ly;
306
257 lx=x+freearr_x[i]; 307 lx = x + freearr_x[i];
258 ly=y+freearr_y[i]; 308 ly = y + freearr_y[i];
259 /* boundscheck */ 309 /* boundscheck */
260 if(lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize) 310 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)
261 /* don't bother searching this square unless the map says life exists.*/ 311 /* don't bother searching this square unless the map says life exists. */
262 if(GET_MAP_FLAGS(map,lx,ly) & P_IS_ALIVE) { 312 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
313 {
263 object *the_monster=get_map_ob(map,lx,ly); 314 object *the_monster = GET_MAP_OB (map, lx, ly);
315
264 for(;the_monster!=NULL&&(!QUERY_FLAG(the_monster,FLAG_MONSTER));the_monster=the_monster->above); 316 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);
265 if(the_monster && QUERY_FLAG(the_monster,FLAG_MONSTER)) 317 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))
266 return the_monster; 318 return the_monster;
319 }
267 } 320 }
268 }
269 return NULL; 321 return NULL;
270} 322}
271 323
272 324
273 325
274/* places keys in the map, preferably in something alive. 326/* places keys in the map, preferably in something alive.
275 keycode is the key's code, 327 keycode is the key's code,
276 door_flag is either PASS_DOORS or NO_PASS_DOORS. 328 door_flag is either PASS_DOORS or NO_PASS_DOORS.
277 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will. 329 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
278 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys: 330 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
279 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1. 331 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
280 332
281 The idea is that you call keyplace on x,y where a door is, and it'll make 333 The idea is that you call keyplace on x,y where a door is, and it'll make
282 sure a key is placed on both sides of the door. 334 sure a key is placed on both sides of the door.
283*/ 335*/
284 336
337int
285int keyplace(mapstruct *map,int x,int y,char *keycode,int door_flag,int n_keys,RMParms *RP) { 338keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
339{
286 int i,j; 340 int i, j;
287 int kx,ky; 341 int kx, ky;
288 object *the_keymaster; /* the monster that gets the key. */ 342 object *the_keymaster; /* the monster that gets the key. */
289 object *the_key; 343 object *the_key;
290 344
291 /* get a key and set its keycode */ 345 /* get a key and set its keycode */
292 the_key = get_archetype("key2"); 346 the_key = get_archetype ("key2");
293 the_key->slaying = add_string(keycode); 347 the_key->slaying = keycode;
294 348
295
296 if(door_flag==PASS_DOORS) { 349 if (door_flag == PASS_DOORS)
350 {
297 int tries=0; 351 int tries = 0;
352
298 the_keymaster=NULL; 353 the_keymaster = NULL;
299 while(tries<15&&the_keymaster==NULL) { 354 while (tries < 15 && the_keymaster == NULL)
355 {
300 i = (RANDOM()%(RP->Xsize-2))+1; 356 i = (RANDOM () % (RP->Xsize - 2)) + 1;
301 j = (RANDOM()%(RP->Ysize-2))+1; 357 j = (RANDOM () % (RP->Ysize - 2)) + 1;
302 tries++; 358 tries++;
303 the_keymaster=find_closest_monster(map,i,j,RP); 359 the_keymaster = find_closest_monster (map, i, j, RP);
304 } 360 }
305 /* if we don't find a good keymaster, drop the key on the ground. */ 361 /* if we don't find a good keymaster, drop the key on the ground. */
306 if(the_keymaster==NULL) { 362 if (the_keymaster == NULL)
363 {
307 int freeindex; 364 int freeindex;
308 365
309 freeindex = -1; 366 freeindex = -1;
310 for(tries = 0; tries < 15 && freeindex == -1; tries++) { 367 for (tries = 0; tries < 15 && freeindex == -1; tries++)
311 kx = (RANDOM()%(RP->Xsize-2))+1; 368 {
312 ky = (RANDOM()%(RP->Ysize-2))+1; 369 kx = (RANDOM () % (RP->Xsize - 2)) + 1;
370 ky = (RANDOM () % (RP->Ysize - 2)) + 1;
313 freeindex = find_first_free_spot(the_key,map,kx,ky); 371 freeindex = find_first_free_spot (the_key, map, kx, ky);
314 } 372 }
315 if(freeindex != -1) { 373 if (freeindex != -1)
374 {
316 kx += freearr_x[freeindex]; 375 kx += freearr_x[freeindex];
317 ky += freearr_y[freeindex]; 376 ky += freearr_y[freeindex];
377 }
318 } 378 }
319 }
320 } 379 }
380 else
321 else { /* NO_PASS_DOORS --we have to work harder.*/ 381 { /* NO_PASS_DOORS --we have to work harder. */
322 /* don't try to keyplace if we're sitting on a blocked square and 382 /* don't try to keyplace if we're sitting on a blocked square and
323 NO_PASS_DOORS is set. */ 383 NO_PASS_DOORS is set. */
324 if(n_keys==1) { 384 if (n_keys == 1)
385 {
325 if(wall_blocked(map,x,y)) return 0; 386 if (wall_blocked (map, x, y))
387 return 0;
326 the_keymaster=find_monster_in_room(map,x,y,RP); 388 the_keymaster = find_monster_in_room (map, x, y, RP);
327 if(the_keymaster==NULL) /* if fail, find a spot to drop the key. */ 389 if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */
328 find_spot_in_room(map,x,y,&kx,&ky,RP); 390 find_spot_in_room (map, x, y, &kx, &ky, RP);
329 } 391 }
330 else { 392 else
393 {
331 int sum=0; /* count how many keys we actually place */ 394 int sum = 0; /* count how many keys we actually place */
395
332 /* I'm lazy, so just try to place in all 4 directions. */ 396 /* I'm lazy, so just try to place in all 4 directions. */
333 sum +=keyplace(map,x+1,y,keycode,NO_PASS_DOORS,1,RP); 397 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
334 sum +=keyplace(map,x,y+1,keycode,NO_PASS_DOORS,1,RP); 398 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
335 sum +=keyplace(map,x-1,y,keycode,NO_PASS_DOORS,1,RP); 399 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
336 sum +=keyplace(map,x,y-1,keycode,NO_PASS_DOORS,1,RP); 400 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
337 if(sum < 2) /* we might have made a disconnected map-place more keys. */ 401 if (sum < 2) /* we might have made a disconnected map-place more keys. */
338 { /* diagnoally this time. */ 402 { /* diagnoally this time. */
339 keyplace(map,x+1,y+1,keycode,NO_PASS_DOORS,1,RP); 403 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
340 keyplace(map,x+1,y-1,keycode,NO_PASS_DOORS,1,RP); 404 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
341 keyplace(map,x-1,y+1,keycode,NO_PASS_DOORS,1,RP); 405 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
342 keyplace(map,x-1,y-1,keycode,NO_PASS_DOORS,1,RP); 406 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
343 } 407 }
408 return 1;
409 }
410 }
411
412 if (the_keymaster == NULL)
413 {
414 the_key->x = kx;
415 the_key->y = ky;
416 insert_ob_in_map (the_key, map, NULL, 0);
344 return 1; 417 return 1;
345 }
346 } 418 }
347 419
348 if(the_keymaster==NULL) {
349 the_key->x = kx;
350 the_key->y = ky;
351 insert_ob_in_map(the_key,map,NULL,0);
352 return 1;
353 }
354
355 insert_ob_in_ob(the_key,the_keymaster); 420 insert_ob_in_ob (the_key, the_keymaster);
356 return 1; 421 return 1;
357} 422}
358 423
359 424
360 425
361/* both find_monster_in_room routines need to have access to this. */ 426/* both find_monster_in_room routines need to have access to this. */
362 427
363object *theMonsterToFind; 428object *theMonsterToFind;
364 429
365/* a recursive routine which will return a monster, eventually,if there is one. 430/* a recursive routine which will return a monster, eventually,if there is one.
366 it does a check-off on the layout, converting 0's to 1's */ 431 it does a check-off on the layout, converting 0's to 1's */
367 432
433object *
368object *find_monster_in_room_recursive(char **layout, mapstruct *map, int x, int y, RMParms *RP) { 434find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP)
435{
369 int i,j; 436 int i, j;
437
370 /* if we've found a monster already, leave */ 438 /* if we've found a monster already, leave */
371 if(theMonsterToFind!=NULL) return theMonsterToFind; 439 if (theMonsterToFind != NULL)
440 return theMonsterToFind;
372 441
373 /* bounds check x and y */ 442 /* bounds check x and y */
374 if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return theMonsterToFind; 443 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
444 return theMonsterToFind;
375 445
376 /* if the square is blocked or searched already, leave */ 446 /* if the square is blocked or searched already, leave */
447 if (layout[x][y] != 0)
377 if(layout[x][y]!=0) return theMonsterToFind; /* might be NULL, that's fine.*/ 448 return theMonsterToFind; /* might be NULL, that's fine. */
378 449
379 /* check the current square for a monster. If there is one, 450 /* check the current square for a monster. If there is one,
380 set theMonsterToFind and return it. */ 451 set theMonsterToFind and return it. */
381 layout[x][y]=1; 452 layout[x][y] = 1;
382 if(GET_MAP_FLAGS(map,x,y) & P_IS_ALIVE) { 453 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
454 {
383 object *the_monster = get_map_ob(map,x,y); 455 object *the_monster = GET_MAP_OB (map, x, y);
456
384 /* check off this point */ 457 /* check off this point */
385 for(;the_monster!=NULL&&(!QUERY_FLAG(the_monster,FLAG_ALIVE));the_monster=the_monster->above); 458 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);
386 if(the_monster && QUERY_FLAG(the_monster,FLAG_ALIVE)) { 459 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
460 {
387 theMonsterToFind=the_monster; 461 theMonsterToFind = the_monster;
388 return theMonsterToFind; 462 return theMonsterToFind;
389 } 463 }
390 } 464 }
391 465
392 /* now search all the 8 squares around recursively for a monster,in random order */ 466 /* now search all the 8 squares around recursively for a monster,in random order */
393 for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) { 467 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
468 {
394 theMonsterToFind = find_monster_in_room_recursive(layout,map,x+freearr_x[i%8+1],y+freearr_y[i%8+1],RP); 469 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
395 if(theMonsterToFind!=NULL) return theMonsterToFind; 470 if (theMonsterToFind != NULL)
471 return theMonsterToFind;
396 } 472 }
397 return theMonsterToFind; 473 return theMonsterToFind;
398} 474}
399 475
400 476
401/* sets up some data structures: the _recursive form does the 477/* sets up some data structures: the _recursive form does the
402 real work. */ 478 real work. */
403 479
404object *find_monster_in_room(mapstruct *map,int x,int y,RMParms *RP) { 480object *
481find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
482{
405 char **layout2; 483 char **layout2;
406 int i,j; 484 int i, j;
485
407 theMonsterToFind=0; 486 theMonsterToFind = 0;
408 layout2 = (char **) calloc(sizeof(char *),RP->Xsize); 487 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
409 /* allocate and copy the layout, converting C to 0. */ 488 /* allocate and copy the layout, converting C to 0. */
410 for(i=0;i<RP->Xsize;i++) { 489 for (i = 0; i < RP->Xsize; i++)
490 {
411 layout2[i]=(char *)calloc(sizeof(char),RP->Ysize); 491 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
412 for(j=0;j<RP->Ysize;j++) { 492 for (j = 0; j < RP->Ysize; j++)
413 if(wall_blocked(map,i,j)) layout2[i][j] = '#'; 493 {
414 } 494 if (wall_blocked (map, i, j))
495 layout2[i][j] = '#';
496 }
415 } 497 }
416 theMonsterToFind = find_monster_in_room_recursive(layout2,map,x,y,RP); 498 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
417 499
418 /* deallocate the temp. layout */ 500 /* deallocate the temp. layout */
419 for(i=0;i<RP->Xsize;i++) { 501 for (i = 0; i < RP->Xsize; i++)
502 {
420 free(layout2[i]); 503 free (layout2[i]);
421 } 504 }
422 free(layout2); 505 free (layout2);
423 506
424 return theMonsterToFind; 507 return theMonsterToFind;
425} 508}
426
427 509
428
429 510
511
512
430/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */ 513/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
431int *room_free_spots_x; 514int *room_free_spots_x;
432int *room_free_spots_y; 515int *room_free_spots_y;
433int number_of_free_spots_in_room; 516int number_of_free_spots_in_room;
434 517
435/* the workhorse routine, which finds the free spots in a room: 518/* the workhorse routine, which finds the free spots in a room:
436a datastructure of free points is set up, and a position chosen from 519a datastructure of free points is set up, and a position chosen from
437that datastructure. */ 520that datastructure. */
438 521
522void
439void find_spot_in_room_recursive(char **layout,int x,int y,RMParms *RP) { 523find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
524{
440 int i,j; 525 int i, j;
441 526
442 /* bounds check x and y */ 527 /* bounds check x and y */
443 if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return; 528 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
529 return;
444 530
445 /* if the square is blocked or searched already, leave */ 531 /* if the square is blocked or searched already, leave */
446 if(layout[x][y]!=0) return; 532 if (layout[x][y] != 0)
533 return;
447 534
448 /* set the current square as checked, and add it to the list. 535 /* set the current square as checked, and add it to the list.
449 set theMonsterToFind and return it. */ 536 set theMonsterToFind and return it. */
450 /* check off this point */ 537 /* check off this point */
451 layout[x][y]=1; 538 layout[x][y] = 1;
452 room_free_spots_x[number_of_free_spots_in_room]=x; 539 room_free_spots_x[number_of_free_spots_in_room] = x;
453 room_free_spots_y[number_of_free_spots_in_room]=y; 540 room_free_spots_y[number_of_free_spots_in_room] = y;
454 number_of_free_spots_in_room++; 541 number_of_free_spots_in_room++;
455 /* now search all the 8 squares around recursively for free spots,in random order */ 542 /* now search all the 8 squares around recursively for free spots,in random order */
456 for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) { 543 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
544 {
457 find_spot_in_room_recursive(layout,x+freearr_x[i%8+1],y+freearr_y[i%8+1],RP); 545 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
458 } 546 }
459 547
460} 548}
461 549
462/* find a random non-blocked spot in this room to drop a key. */ 550/* find a random non-blocked spot in this room to drop a key. */
551void
463void find_spot_in_room(mapstruct *map,int x,int y,int *kx,int *ky,RMParms *RP) { 552find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP)
553{
464 char **layout2; 554 char **layout2;
465 int i,j; 555 int i, j;
556
466 number_of_free_spots_in_room=0; 557 number_of_free_spots_in_room = 0;
467 room_free_spots_x = (int *)calloc(sizeof(int),RP->Xsize * RP->Ysize); 558 room_free_spots_x = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
468 room_free_spots_y = (int *)calloc(sizeof(int),RP->Xsize * RP->Ysize); 559 room_free_spots_y = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
469 560
470 layout2 = (char **) calloc(sizeof(char *),RP->Xsize); 561 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
471 /* allocate and copy the layout, converting C to 0. */ 562 /* allocate and copy the layout, converting C to 0. */
472 for(i=0;i<RP->Xsize;i++) { 563 for (i = 0; i < RP->Xsize; i++)
564 {
473 layout2[i]=(char *)calloc(sizeof(char),RP->Ysize); 565 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
474 for(j=0;j<RP->Ysize;j++) { 566 for (j = 0; j < RP->Ysize; j++)
475 if(wall_blocked(map,i,j)) layout2[i][j] = '#'; 567 {
476 } 568 if (wall_blocked (map, i, j))
569 layout2[i][j] = '#';
570 }
477 } 571 }
478 572
479 /* setup num_free_spots and room_free_spots */ 573 /* setup num_free_spots and room_free_spots */
480 find_spot_in_room_recursive(layout2,x,y,RP); 574 find_spot_in_room_recursive (layout2, x, y, RP);
481 575
482 if(number_of_free_spots_in_room > 0) { 576 if (number_of_free_spots_in_room > 0)
577 {
483 i = RANDOM()%number_of_free_spots_in_room; 578 i = RANDOM () % number_of_free_spots_in_room;
484 *kx = room_free_spots_x[i]; 579 *kx = room_free_spots_x[i];
485 *ky = room_free_spots_y[i]; 580 *ky = room_free_spots_y[i];
486 } 581 }
487 582
488 /* deallocate the temp. layout */ 583 /* deallocate the temp. layout */
489 for(i=0;i<RP->Xsize;i++) { 584 for (i = 0; i < RP->Xsize; i++)
585 {
490 free(layout2[i]); 586 free (layout2[i]);
491 } 587 }
492 free(layout2); 588 free (layout2);
493 free(room_free_spots_x); 589 free (room_free_spots_x);
494 free(room_free_spots_y); 590 free (room_free_spots_y);
495} 591}
496 592
497 593
498/* searches the map for a spot with walls around it. The more 594/* searches the map for a spot with walls around it. The more
499 walls the better, but it'll settle for 1 wall, or even 0, but 595 walls the better, but it'll settle for 1 wall, or even 0, but
500 it'll return 0 if no FREE spots are found.*/ 596 it'll return 0 if no FREE spots are found.*/
501 597
598void
502void find_enclosed_spot(mapstruct *map, int *cx, int *cy,RMParms *RP) { 599find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
600{
503 int x,y; 601 int x, y;
504 int i; 602 int i;
603
505 x = *cx;y=*cy; 604 x = *cx;
605 y = *cy;
506 606
507 for(i=0;i<=SIZEOFFREE1;i++) { 607 for (i = 0; i <= SIZEOFFREE1; i++)
608 {
508 int lx,ly,sindex; 609 int lx, ly, sindex;
610
509 lx = x +freearr_x[i]; 611 lx = x + freearr_x[i];
510 ly = y +freearr_y[i]; 612 ly = y + freearr_y[i];
511 sindex = surround_flag3(map,lx,ly,RP); 613 sindex = surround_flag3 (map, lx, ly, RP);
512 /* if it's blocked on 3 sides, it's enclosed */ 614 /* if it's blocked on 3 sides, it's enclosed */
513 if(sindex==7 || sindex == 11 || sindex == 13 || sindex == 14) { 615 if (sindex == 7 || sindex == 11 || sindex == 13 || sindex == 14)
514 *cx= lx;*cy= ly; 616 {
617 *cx = lx;
618 *cy = ly;
515 return; 619 return;
516 } 620 }
517 } 621 }
518 622
519 /* OK, if we got here, we're obviously someplace where there's no enclosed 623 /* OK, if we got here, we're obviously someplace where there's no enclosed
520 spots--try to find someplace which is 2x enclosed. */ 624 spots--try to find someplace which is 2x enclosed. */
521 for(i=0;i<=SIZEOFFREE1;i++) { 625 for (i = 0; i <= SIZEOFFREE1; i++)
626 {
522 int lx,ly,sindex; 627 int lx, ly, sindex;
628
523 lx = x +freearr_x[i]; 629 lx = x + freearr_x[i];
524 ly = y +freearr_y[i]; 630 ly = y + freearr_y[i];
525 sindex = surround_flag3(map,lx,ly,RP); 631 sindex = surround_flag3 (map, lx, ly, RP);
526 /* if it's blocked on 3 sides, it's enclosed */ 632 /* if it's blocked on 3 sides, it's enclosed */
527 if(sindex==3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex==10 || sindex==12) { 633 if (sindex == 3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex == 10 || sindex == 12)
528 *cx= lx;*cy= ly; 634 {
635 *cx = lx;
636 *cy = ly;
637 return;
638 }
639 }
640
641 /* settle for one surround point */
642 for (i = 0; i <= SIZEOFFREE1; i++)
643 {
644 int lx, ly, sindex;
645
646 lx = x + freearr_x[i];
647 ly = y + freearr_y[i];
648 sindex = surround_flag3 (map, lx, ly, RP);
649 /* if it's blocked on 3 sides, it's enclosed */
650 if (sindex)
651 {
652 *cx = lx;
653 *cy = ly;
654 return;
655 }
656 }
657 /* give up and return the closest free spot. */
658 i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y);
659 if (i != -1 && i <= SIZEOFFREE1)
660 {
661 *cx = x + freearr_x[i];
662 *cy = y + freearr_y[i];
529 return; 663 return;
530 } 664 }
531 }
532
533 /* settle for one surround point */
534 for(i=0;i<=SIZEOFFREE1;i++) {
535 int lx,ly,sindex;
536 lx = x +freearr_x[i];
537 ly = y +freearr_y[i];
538 sindex = surround_flag3(map,lx,ly,RP);
539 /* if it's blocked on 3 sides, it's enclosed */
540 if(sindex) {
541 *cx= lx;*cy= ly;
542 return;
543 }
544 }
545 /* give up and return the closest free spot. */
546 i = find_first_free_spot(&find_archetype("chest")->clone,map,x,y);
547 if(i!=-1&&i<=SIZEOFFREE1) {
548 *cx = x +freearr_x[i];
549 *cy = y +freearr_y[i];
550 return;
551 }
552 /* indicate failure */ 665 /* indicate failure */
553 *cx=*cy=-1; 666 *cx = *cy = -1;
554} 667}
555 668
556 669
670void
557void remove_monsters(int x,int y,mapstruct *map) { 671remove_monsters (int x, int y, maptile *map)
672{
558 object *tmp; 673 object *tmp;
559 674
560 for(tmp=get_map_ob(map,x,y);tmp!=NULL;tmp=tmp->above) 675 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
561 if(QUERY_FLAG(tmp,FLAG_ALIVE)) { 676 if (QUERY_FLAG (tmp, FLAG_ALIVE))
562 if(tmp->head) tmp=tmp->head; 677 {
563 remove_ob(tmp); 678 if (tmp->head)
564 free_object(tmp); 679 tmp = tmp->head;
565 tmp=get_map_ob(map,x,y); 680 tmp->remove ();
681 tmp->destroy ();
682 tmp = GET_MAP_OB (map, x, y);
566 if(tmp==NULL) break; 683 if (tmp == NULL)
684 break;
567 }; 685 };
568} 686}
569 687
570 688
571/* surrounds the point x,y by doors, so as to enclose something, like 689/* surrounds the point x,y by doors, so as to enclose something, like
572 a chest. It only goes as far as the 8 squares surrounding, and 690 a chest. It only goes as far as the 8 squares surrounding, and
573 it'll remove any monsters it finds.*/ 691 it'll remove any monsters it finds.*/
574 692
693object **
575object ** surround_by_doors(mapstruct *map,char **layout,int x,int y,int opts) { 694surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
695{
576 int i; 696 int i;
577 char *doors[2]; 697 char *doors[2];
578 object **doorlist; 698 object **doorlist;
579 int ndoors_made=0; 699 int ndoors_made = 0;
580 doorlist = (object **) calloc(9, sizeof(object *)); /* 9 doors so we can hold termination null */ 700 doorlist = (object **) calloc (9, sizeof (object *)); /* 9 doors so we can hold termination null */
581 701
582 /* this is a list we pick from, for horizontal and vertical doors */ 702 /* this is a list we pick from, for horizontal and vertical doors */
583 if(opts&DOORED) { 703 if (opts & DOORED)
704 {
584 doors[0]="locked_door2"; 705 doors[0] = "locked_door2";
585 doors[1]="locked_door1"; 706 doors[1] = "locked_door1";
586 } 707 }
587 else { 708 else
709 {
588 doors[0]="door_1"; 710 doors[0] = "door_1";
589 doors[1]="door_2"; 711 doors[1] = "door_2";
590 } 712 }
591 713
592 /* place doors in all the 8 adjacent unblocked squares. */ 714 /* place doors in all the 8 adjacent unblocked squares. */
593 for(i=1;i<9;i++) { 715 for (i = 1; i < 9; i++)
716 {
594 int x1 = x + freearr_x[i], y1 = y+freearr_y[i]; 717 int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
595 718
596 if(!wall_blocked(map,x1,y1) 719 if (!wall_blocked (map, x1, y1) || layout[x1][y1] == '>')
597 || layout[x1][y1]=='>') {/* place a door */ 720 { /* place a door */
598 object * new_door=get_archetype( (freearr_x[i]==0)?doors[1]:doors[0]); 721 object *new_door = get_archetype ((freearr_x[i] == 0) ? doors[1] : doors[0]);
722
599 new_door->x = x + freearr_x[i]; 723 new_door->x = x + freearr_x[i];
600 new_door->y = y + freearr_y[i]; 724 new_door->y = y + freearr_y[i];
601 remove_monsters(new_door->x,new_door->y,map); 725 remove_monsters (new_door->x, new_door->y, map);
602 insert_ob_in_map(new_door,map,NULL,0); 726 insert_ob_in_map (new_door, map, NULL, 0);
603 doorlist[ndoors_made]=new_door; 727 doorlist[ndoors_made] = new_door;
604 ndoors_made++; 728 ndoors_made++;
605 } 729 }
606 } 730 }
607 return doorlist; 731 return doorlist;
608} 732}
609 733
610 734
611/* returns the first door in this square, or NULL if there isn't a door. */ 735/* returns the first door in this square, or NULL if there isn't a door. */
736object *
612object *door_in_square(mapstruct *map,int x,int y) { 737door_in_square (maptile *map, int x, int y)
738{
613 object *tmp; 739 object *tmp;
740
614 for(tmp=get_map_ob(map,x,y);tmp!=NULL;tmp=tmp->above) 741 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
615 if(tmp->type == DOOR || tmp->type== LOCKED_DOOR) return tmp; 742 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
743 return tmp;
616 return NULL; 744 return NULL;
617} 745}
618 746
619 747
620/* the workhorse routine, which finds the doors in a room */ 748/* the workhorse routine, which finds the doors in a room */
749void
621void find_doors_in_room_recursive(char **layout,mapstruct *map,int x,int y,object **doorlist,int *ndoors,RMParms *RP) { 750find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
751{
622 int i,j; 752 int i, j;
623 object *door; 753 object *door;
624 754
625 /* bounds check x and y */ 755 /* bounds check x and y */
626 if(!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) return; 756 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
757 return;
627 758
628 /* if the square is blocked or searched already, leave */ 759 /* if the square is blocked or searched already, leave */
629 if(layout[x][y]==1) return; 760 if (layout[x][y] == 1)
761 return;
630 762
631 /* check off this point */ 763 /* check off this point */
632 if(layout[x][y]=='#') { /* there could be a door here */ 764 if (layout[x][y] == '#')
765 { /* there could be a door here */
633 layout[x][y]=1; 766 layout[x][y] = 1;
634 door=door_in_square(map,x,y); 767 door = door_in_square (map, x, y);
635 if(door!=NULL) { 768 if (door != NULL)
769 {
636 doorlist[*ndoors]=door; 770 doorlist[*ndoors] = door;
637 if(*ndoors>254) /* eek! out of memory */ 771 if (*ndoors > 254) /* eek! out of memory */
638 { 772 {
639 LOG(llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 773 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
640 return; 774 return;
641 } 775 }
642 *ndoors=*ndoors+1; 776 *ndoors = *ndoors + 1;
643 } 777 }
644 } 778 }
645 else { 779 else
780 {
646 layout[x][y]=1; 781 layout[x][y] = 1;
647 /* now search all the 8 squares around recursively for free spots,in random order */ 782 /* now search all the 8 squares around recursively for free spots,in random order */
648 for(i=RANDOM()%8,j=0; j<8 && theMonsterToFind==NULL;i++,j++) { 783 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
784 {
649 find_doors_in_room_recursive(layout,map,x+freearr_x[i%8+1],y+freearr_y[i%8+1],doorlist,ndoors,RP); 785 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
650 } 786 }
651 } 787 }
652} 788}
653 789
654/* find a random non-blocked spot in this room to drop a key. */ 790/* find a random non-blocked spot in this room to drop a key. */
655object** find_doors_in_room(mapstruct *map,int x,int y,RMParms *RP) { 791object **
792find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
793{
656 char **layout2; 794 char **layout2;
657 object **doorlist; 795 object **doorlist;
658 int i,j; 796 int i, j;
659 int ndoors=0; 797 int ndoors = 0;
660 798
661 doorlist = (object **)calloc(sizeof(int),256); 799 doorlist = (object **) calloc (sizeof (int), 256);
662 800
663 801
664 layout2 = (char **) calloc(sizeof(char *),RP->Xsize); 802 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
665 /* allocate and copy the layout, converting C to 0. */ 803 /* allocate and copy the layout, converting C to 0. */
666 for(i=0;i<RP->Xsize;i++) { 804 for (i = 0; i < RP->Xsize; i++)
805 {
667 layout2[i]=(char *)calloc(sizeof(char),RP->Ysize); 806 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
668 for(j=0;j<RP->Ysize;j++) { 807 for (j = 0; j < RP->Ysize; j++)
669 if(wall_blocked(map,i,j)) layout2[i][j] = '#'; 808 {
670 } 809 if (wall_blocked (map, i, j))
810 layout2[i][j] = '#';
811 }
671 } 812 }
672 813
673 /* setup num_free_spots and room_free_spots */ 814 /* setup num_free_spots and room_free_spots */
674 find_doors_in_room_recursive(layout2,map,x,y,doorlist,&ndoors,RP); 815 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
675 816
676 /* deallocate the temp. layout */ 817 /* deallocate the temp. layout */
677 for(i=0;i<RP->Xsize;i++) { 818 for (i = 0; i < RP->Xsize; i++)
819 {
678 free(layout2[i]); 820 free (layout2[i]);
679 } 821 }
680 free(layout2); 822 free (layout2);
681 return doorlist; 823 return doorlist;
682} 824}
683 825
684 826
685 827
686/* locks and/or hides all the doors in doorlist, or does nothing if 828/* locks and/or hides all the doors in doorlist, or does nothing if
687 opts doesn't say to lock/hide doors. */ 829 opts doesn't say to lock/hide doors. */
688 830
831void
689void lock_and_hide_doors(object **doorlist,mapstruct *map,int opts,RMParms *RP) { 832lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
833{
690 object *door; 834 object *door;
691 int i; 835 int i;
836
692 /* lock the doors and hide the keys. */ 837 /* lock the doors and hide the keys. */
693 838
694 if(opts & DOORED) { 839 if (opts & DOORED)
840 {
695 for(i=0,door=doorlist[0];doorlist[i]!=NULL;i++) { 841 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
842 {
696 object *new_door=get_archetype("locked_door1"); 843 object *new_door = get_archetype ("locked_door1");
697 char keybuf[256]; 844 char keybuf[256];
845
698 door=doorlist[i]; 846 door = doorlist[i];
699 new_door->face = door->face; 847 new_door->face = door->face;
700 new_door->x = door->x; 848 new_door->x = door->x;
701 new_door->y = door->y; 849 new_door->y = door->y;
702 remove_ob(door); 850 door->remove ();
703 free_object(door); 851 door->destroy ();
704 doorlist[i]=new_door; 852 doorlist[i] = new_door;
705 insert_ob_in_map(new_door,map,NULL,0); 853 insert_ob_in_map (new_door, map, NULL, 0);
706 sprintf(keybuf,"%d",(int)RANDOM()); 854 sprintf (keybuf, "%d", (int) RANDOM ());
707 new_door->slaying = add_string(keybuf); 855 new_door->slaying = keybuf;
708 keyplace(map,new_door->x,new_door->y,keybuf,NO_PASS_DOORS,2,RP); 856 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);
709 } 857 }
710 } 858 }
711 859
712 /* change the faces of the doors and surrounding walls to hide them. */ 860 /* change the faces of the doors and surrounding walls to hide them. */
713 if(opts & HIDDEN) { 861 if (opts & HIDDEN)
862 {
714 for(i=0,door=doorlist[0];doorlist[i]!=NULL;i++) { 863 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
864 {
715 object *wallface; 865 object *wallface;
866
716 door=doorlist[i]; 867 door = doorlist[i];
717 wallface=retrofit_joined_wall(map,door->x,door->y,1,RP); 868 wallface = retrofit_joined_wall (map, door->x, door->y, 1, RP);
718 if(wallface!=NULL) { 869 if (wallface != NULL)
870 {
719 retrofit_joined_wall(map,door->x-1,door->y,0,RP); 871 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
720 retrofit_joined_wall(map,door->x+1,door->y,0,RP); 872 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
721 retrofit_joined_wall(map,door->x,door->y-1,0,RP); 873 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
722 retrofit_joined_wall(map,door->x,door->y+1,0,RP); 874 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
723 door->face = wallface->face; 875 door->face = wallface->face;
724 if(!QUERY_FLAG(wallface,FLAG_REMOVED)) remove_ob(wallface); 876 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
725 free_object(wallface); 877 wallface->remove ();
878 wallface->destroy ();
879 }
726 } 880 }
727 }
728 } 881 }
729} 882}

Diff Legend

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