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.6 by root, Thu Sep 14 22:34:03 2006 UTC vs.
Revision 1.23 by root, Sat Jan 27 00:56:48 2007 UTC

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

Diff Legend

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