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.32 by root, Thu Nov 8 19:43:25 2007 UTC vs.
Revision 1.42 by root, Thu Sep 25 04:35:50 2008 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * 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
… …
45/* a macro to get a strongly centered random distribution, 45/* a macro to get a strongly centered random distribution,
46 from 0 to x, centered at x/2 */ 46 from 0 to x, centered at x/2 */
47static int 47static int
48bc_random (int x) 48bc_random (int x)
49{ 49{
50 return (rndm (x) + rndm (x) + rndm (x)) / 3; 50 return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
51}
52
53static object *
54gen_key (const shstr &keycode)
55{
56 /* get a key and set its keycode */
57 object *key = archetype::get (shstr_key_random_map);
58 key->slaying = keycode;
59 return key;
60}
61
62/* places keys in the map, preferably in something alive.
63 keycode is the key's code,
64 door_flag is either PASS_DOORS or NO_PASS_DOORS.
65 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
66 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
67 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
68
69 The idea is that you call keyplace on x,y where a door is, and it'll make
70 sure a key is placed on both sides of the door.
71*/
72static int
73keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params *RP)
74{
75 int i, j;
76 int kx = 0, ky = 0;
77 object *the_keymaster; /* the monster that gets the key. */
78 object *the_key = gen_key (keycode);
79
80 if (door_flag == PASS_DOORS)
81 {
82 int tries = 0;
83
84 the_keymaster = 0;
85 while (tries < 15 && !the_keymaster)
86 {
87 i = rmg_rndm (RP->Xsize - 2) + 1;
88 j = rmg_rndm (RP->Ysize - 2) + 1;
89 tries++;
90 the_keymaster = find_closest_monster (map, i, j, RP);
91 }
92
93 /* if we don't find a good keymaster, drop the key on the ground. */
94 if (!the_keymaster)
95 {
96 int freeindex;
97
98 freeindex = -1;
99 for (tries = 0; tries < 15 && freeindex == -1; tries++)
100 {
101 kx = rmg_rndm (RP->Xsize - 2) + 1;
102 ky = rmg_rndm (RP->Ysize - 2) + 1;
103 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
104 }
105
106 // can freeindex ever be < 0?
107 if (freeindex >= 0)
108 {
109 kx += freearr_x [freeindex];
110 ky += freearr_y [freeindex];
111 }
112 }
113 }
114 else
115 { /* NO_PASS_DOORS --we have to work harder. */
116 /* don't try to keyplace if we're sitting on a blocked square and
117 NO_PASS_DOORS is set. */
118 if (n_keys == 1)
119 {
120 if (wall_blocked (map, x, y))
121 {
122 the_key->destroy ();
123 return 0;
124 }
125
126 the_keymaster = find_monster_in_room (map, x, y, RP);
127 if (!the_keymaster) /* if fail, find a spot to drop the key. */
128 find_spot_in_room (map, x, y, &kx, &ky, RP);
129 }
130 else
131 {
132 int sum = 0; /* count how many keys we actually place */
133
134 /* I'm lazy, so just try to place in all 4 directions. */
135 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
136 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
137 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
138 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
139
140 if (sum < 2) /* we might have made a disconnected map-place more keys. */
141 { /* diagonally this time. */
142 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
143 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
144 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
145 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
146 }
147
148 the_key->destroy ();
149 return 1;
150 }
151 }
152
153 if (the_keymaster)
154 the_keymaster->head_ ()->insert (the_key);
155 else
156 {
157 the_key->x = kx;
158 the_key->y = ky;
159 insert_ob_in_map (the_key, map, NULL, 0);
160 }
161
162 return 1;
51} 163}
52 164
53/* returns true if square x,y has P_NO_PASS set, which is true for walls 165/* returns true if square x,y has P_NO_PASS set, which is true for walls
54 * and doors but not monsters. 166 * and doors but not monsters.
55 * This function is not map tile aware. 167 * This function is not map tile aware.
… …
82 if (treasure_style) 194 if (treasure_style)
83 if (!strcmp (treasure_style, "none")) 195 if (!strcmp (treasure_style, "none"))
84 return; 196 return;
85 197
86 if (treasureoptions <= 0) 198 if (treasureoptions <= 0)
87 treasureoptions = rndm (2 * LAST_OPTION); 199 treasureoptions = rmg_rndm (2 * LAST_OPTION);
88 200
89 /* filter out the mutually exclusive options */ 201 /* filter out the mutually exclusive options */
90 if ((treasureoptions & RICH) && (treasureoptions & SPARSE)) 202 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
91 { 203 {
92 if (rndm (2)) 204 if (rmg_rndm (2))
93 treasureoptions -= 1; 205 treasureoptions -= 1;
94 else 206 else
95 treasureoptions -= 2; 207 treasureoptions -= 2;
96 } 208 }
97 209
… …
118 } 230 }
119 231
120 /* all the treasure at one spot in the map. */ 232 /* all the treasure at one spot in the map. */
121 if (treasureoptions & CONCENTRATED) 233 if (treasureoptions & CONCENTRATED)
122 { 234 {
123
124 /* map_layout_style global, and is previously set */ 235 /* map_layout_style global, and is previously set */
125 switch (RP->map_layout_style) 236 switch (RP->map_layout_style)
126 { 237 {
127 case LAYOUT_ONION: 238 case LAYOUT_ONION:
128 case LAYOUT_SPIRAL: 239 case LAYOUT_SPIRAL:
… …
136 for (j = 0; j < RP->Ysize; j++) 247 for (j = 0; j < RP->Ysize; j++)
137 { 248 {
138 if (layout[i][j] == 'C' || layout[i][j] == '>') 249 if (layout[i][j] == 'C' || layout[i][j] == '>')
139 { 250 {
140 int tdiv = RP->symmetry_used; 251 int tdiv = RP->symmetry_used;
141 object **doorlist;
142 object *chest; 252 object *chest;
143 253
144 if (tdiv == 3) 254 if (tdiv == 3)
145 tdiv = 2; /* this symmetry uses a divisor of 2 */ 255 tdiv = 2; /* this symmetry uses a divisor of 2 */
256
146 /* don't put a chest on an exit. */ 257 /* don't put a chest on an exit. */
147 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP); 258 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
259
148 if (!chest) 260 if (!chest)
149 continue; /* if no chest was placed NEXT */ 261 continue; /* if no chest was placed NEXT */
262
150 if (treasureoptions & (DOORED | HIDDEN)) 263 if (treasureoptions & (DOORED | HIDDEN))
151 { 264 {
152 doorlist = find_doors_in_room (map, i, j, RP); 265 object **doorlist = find_doors_in_room (map, i, j, RP);
153 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 266 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
154 free (doorlist); 267 free (doorlist);
155 } 268 }
156 } 269 }
157 } 270 }
158 } 271 }
159 break; 272 break;
160 } 273 }
274
161 default: 275 default:
162 { 276 {
163 int i, j, tries; 277 int i, j, tries;
164 object *chest; 278 object *chest;
165 object **doorlist; 279 object **doorlist;
166 280
167 i = j = -1; 281 i = j = -1;
168 tries = 0; 282 tries = 0;
169 while (i == -1 && tries < 100) 283 while (i == -1 && tries < 100)
170 { 284 {
171 i = rndm (RP->Xsize - 2) + 1; 285 i = rmg_rndm (RP->Xsize - 2) + 1;
172 j = rndm (RP->Ysize - 2) + 1; 286 j = rmg_rndm (RP->Ysize - 2) + 1;
173 find_enclosed_spot (map, &i, &j, RP); 287 find_enclosed_spot (map, &i, &j, RP);
288
174 if (wall_blocked (map, i, j)) 289 if (wall_blocked (map, i, j))
175 i = -1; 290 i = -1;
291
176 tries++; 292 tries++;
177 } 293 }
294
178 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP); 295 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
296
179 if (!chest) 297 if (!chest)
180 return; 298 return;
299
181 i = chest->x; 300 i = chest->x;
182 j = chest->y; 301 j = chest->y;
183 if (treasureoptions & (DOORED | HIDDEN)) 302 if (treasureoptions & (DOORED | HIDDEN))
184 { 303 {
185 doorlist = surround_by_doors (map, layout, i, j, treasureoptions); 304 doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
… …
193 { /* DIFFUSE treasure layout */ 312 { /* DIFFUSE treasure layout */
194 int ti, i, j; 313 int ti, i, j;
195 314
196 for (ti = 0; ti < num_treasures; ti++) 315 for (ti = 0; ti < num_treasures; ti++)
197 { 316 {
198 i = rndm (RP->Xsize - 2) + 1; 317 i = rmg_rndm (RP->Xsize - 2) + 1;
199 j = rndm (RP->Ysize - 2) + 1; 318 j = rmg_rndm (RP->Ysize - 2) + 1;
200 place_chest (treasureoptions, i, j, map, style_map, 1, RP); 319 place_chest (treasureoptions, i, j, map, style_map, 1, RP);
201 } 320 }
202 } 321 }
203} 322}
204 323
205/* put a chest into the map, near x and y, with the treasure style 324/* put a chest into the map, near x and y, with the treasure style
206 determined (may be null, or may be a treasure list from lib/treasures, 325 determined (may be null, or may be a treasure list from lib/treasures,
207 if the global variable "treasurestyle" is set to that treasure list's name */ 326 if the global variable "treasurestyle" is set to that treasure list's name */
208
209object * 327object *
210place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP) 328place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
211{ 329{
212 object *the_chest;
213 int i, xl, yl;
214
215 the_chest = get_archetype ("chest"); /* was "chest_2" */ 330 object *the_chest = archetype::get (shstr_chest); /* was "chest_2" */
216 331
217 /* first, find a place to put the chest. */ 332 /* first, find a place to put the chest. */
218 i = find_first_free_spot (the_chest, map, x, y); 333 int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
219 if (i == -1) 334 if (i == -1)
220 { 335 {
221 the_chest->destroy (); 336 the_chest->destroy ();
222 return NULL; 337 return NULL;
223 } 338 }
224 339
225 xl = x + freearr_x[i]; 340 int xl = x + freearr_x[i];
226 yl = y + freearr_y[i]; 341 int yl = y + freearr_y[i];
227 342
228 /* if the placement is blocked, return a fail. */ 343 /* if the placement is blocked, return a fail. */
229 if (wall_blocked (map, xl, yl)) 344 if (wall_blocked (map, xl, yl))
230 return 0; 345 return 0;
231 346
… …
238 treasurelist *tlist = find_treasurelist (RP->treasurestyle); 353 treasurelist *tlist = find_treasurelist (RP->treasurestyle);
239 354
240 if (tlist != NULL) 355 if (tlist != NULL)
241 for (ti = 0; ti < n_treasures; ti++) 356 for (ti = 0; ti < n_treasures; ti++)
242 { /* use the treasure list */ 357 { /* use the treasure list */
243 object *new_treasure = style_map->pick_random_object (); 358 object *new_treasure = style_map->pick_random_object (rmg_rndm);
244 359
245 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest); 360 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
246 } 361 }
247 else 362 else
248 { /* use the style map */ 363 { /* use the style map */
… …
259 374
260 /* stick a trap in the chest if required */ 375 /* stick a trap in the chest if required */
261 if (treasureoptions & TRAPPED) 376 if (treasureoptions & TRAPPED)
262 { 377 {
263 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1); 378 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
264 object *the_trap;
265 379
266 if (trap_map) 380 if (trap_map)
267 { 381 {
268 the_trap = trap_map->pick_random_object (); 382 object *the_trap = trap_map->pick_random_object (rmg_rndm);
383
269 the_trap->stats.Cha = 10 + RP->difficulty; 384 the_trap->stats.Cha = 10 + RP->difficulty;
270 the_trap->level = bc_random ((3 * RP->difficulty) / 2); 385 the_trap->level = bc_random ((3 * RP->difficulty) / 2);
386
271 if (the_trap) 387 if (the_trap)
272 { 388 {
273 object *new_trap; 389 object *new_trap = the_trap->arch->instance ();//TODO: why not clone?
274 390
275 new_trap = arch_to_object (the_trap->arch);
276 new_trap->copy_to (the_trap);
277 new_trap->x = x; 391 new_trap->x = x;
278 new_trap->y = y; 392 new_trap->y = y;
279 insert_ob_in_ob (new_trap, the_chest); 393 insert_ob_in_ob (new_trap, the_chest);
280 } 394 }
281 } 395 }
… …
284 /* set the chest lock code, and call the keyplacer routine with 398 /* set the chest lock code, and call the keyplacer routine with
285 the lockcode. It's not worth bothering to lock the chest if 399 the lockcode. It's not worth bothering to lock the chest if
286 there's only 1 treasure.... */ 400 there's only 1 treasure.... */
287 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 401 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
288 { 402 {
289 char keybuf[1024]; 403 the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
290
291 sprintf (keybuf, "%d", rndm (1000000000));
292 the_chest->slaying = keybuf;
293 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP); 404 keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
294 } 405 }
295 406
296 /* actually place the chest. */ 407 /* actually place the chest. */
297 the_chest->x = xl; 408 the_chest->x = xl;
298 the_chest->y = yl; 409 the_chest->y = yl;
… …
327 } 438 }
328 } 439 }
329 return NULL; 440 return NULL;
330} 441}
331 442
332
333
334/* places keys in the map, preferably in something alive.
335 keycode is the key's code,
336 door_flag is either PASS_DOORS or NO_PASS_DOORS.
337 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
338 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
339 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
340
341 The idea is that you call keyplace on x,y where a door is, and it'll make
342 sure a key is placed on both sides of the door.
343*/
344int
345keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
346{
347 int i, j;
348 int kx = 0, ky = 0;
349 object *the_keymaster; /* the monster that gets the key. */
350 object *the_key;
351
352 /* get a key and set its keycode */
353 the_key = get_archetype ("key2");
354 the_key->slaying = keycode;
355
356 if (door_flag == PASS_DOORS)
357 {
358 int tries = 0;
359
360 the_keymaster = 0;
361 while (tries < 15 && !the_keymaster)
362 {
363 i = rndm (RP->Xsize - 2) + 1;
364 j = rndm (RP->Ysize - 2) + 1;
365 tries++;
366 the_keymaster = find_closest_monster (map, i, j, RP);
367 }
368
369 /* if we don't find a good keymaster, drop the key on the ground. */
370 if (!the_keymaster)
371 {
372 int freeindex;
373
374 freeindex = -1;
375 for (tries = 0; tries < 15 && freeindex == -1; tries++)
376 {
377 kx = rndm (RP->Xsize - 2) + 1;
378 ky = rndm (RP->Ysize - 2) + 1;
379 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
380 }
381
382 // can freeindex ever be < 0?
383 if (freeindex >= 0)
384 {
385 kx += freearr_x [freeindex];
386 ky += freearr_y [freeindex];
387 }
388 }
389 }
390 else
391 { /* NO_PASS_DOORS --we have to work harder. */
392 /* don't try to keyplace if we're sitting on a blocked square and
393 NO_PASS_DOORS is set. */
394 if (n_keys == 1)
395 {
396 if (wall_blocked (map, x, y))
397 return 0;
398
399 the_keymaster = find_monster_in_room (map, x, y, RP);
400 if (!the_keymaster) /* if fail, find a spot to drop the key. */
401 find_spot_in_room (map, x, y, &kx, &ky, RP);
402 }
403 else
404 {
405 int sum = 0; /* count how many keys we actually place */
406
407 /* I'm lazy, so just try to place in all 4 directions. */
408 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
409 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
410 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
411 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
412
413 if (sum < 2) /* we might have made a disconnected map-place more keys. */
414 { /* diagonally this time. */
415 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
416 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
417 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
418 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
419 }
420
421 return 1;
422 }
423 }
424
425 if (!the_keymaster)
426 {
427 the_key->x = kx;
428 the_key->y = ky;
429 insert_ob_in_map (the_key, map, NULL, 0);
430 return 1;
431 }
432
433 insert_ob_in_ob (the_key, the_keymaster->head_ ());
434 return 1;
435}
436
437
438
439/* both find_monster_in_room routines need to have access to this. */ 443/* both find_monster_in_room routines need to have access to this. */
440 444
441object *theMonsterToFind; 445object *theMonsterToFind;
442 446
443/* a recursive routine which will return a monster, eventually,if there is one. 447/* a recursive routine which will return a monster, eventually,if there is one.
… …
475 return theMonsterToFind; 479 return theMonsterToFind;
476 } 480 }
477 } 481 }
478 482
479 /* now search all the 8 squares around recursively for a monster,in random order */ 483 /* now search all the 8 squares around recursively for a monster,in random order */
480 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 484 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
481 { 485 {
482 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 486 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
483 if (theMonsterToFind != NULL) 487 if (theMonsterToFind != NULL)
484 return theMonsterToFind; 488 return theMonsterToFind;
485 } 489 }
490
486 return theMonsterToFind; 491 return theMonsterToFind;
487} 492}
488
489 493
490/* sets up some data structures: the _recursive form does the 494/* sets up some data structures: the _recursive form does the
491 real work. */ 495 real work. */
492
493object * 496object *
494find_monster_in_room (maptile *map, int x, int y, random_map_params *RP) 497find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
495{ 498{
496 char **layout2; 499 Layout layout2 (RP);
497 int i, j; 500
501 layout2->clear ();
502
503 /* allocate and copy the layout, converting C to 0. */
504 for (int i = 0; i < layout2->w; i++)
505 for (int j = 0; j < layout2->h; j++)
506 if (wall_blocked (map, i, j))
507 layout2[i][j] = '#';
498 508
499 theMonsterToFind = 0; 509 theMonsterToFind = 0;
500 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
501 /* allocate and copy the layout, converting C to 0. */
502 for (i = 0; i < RP->Xsize; i++)
503 {
504 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
505 for (j = 0; j < RP->Ysize; j++)
506 {
507 if (wall_blocked (map, i, j))
508 layout2[i][j] = '#';
509 }
510 }
511 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP); 510 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
512 511
513 /* deallocate the temp. layout */ 512 layout2.free ();
514 for (i = 0; i < RP->Xsize; i++)
515 {
516 free (layout2[i]);
517 }
518 free (layout2);
519 513
520 return theMonsterToFind; 514 return theMonsterToFind;
521} 515}
522 516
523/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */ 517/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
… …
548 room_free_spots_x[number_of_free_spots_in_room] = x; 542 room_free_spots_x[number_of_free_spots_in_room] = x;
549 room_free_spots_y[number_of_free_spots_in_room] = y; 543 room_free_spots_y[number_of_free_spots_in_room] = y;
550 number_of_free_spots_in_room++; 544 number_of_free_spots_in_room++;
551 545
552 /* now search all the 8 squares around recursively for free spots,in random order */ 546 /* now search all the 8 squares around recursively for free spots,in random order */
553 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 547 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
554 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 548 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
555 549
556} 550}
557 551
558/* find a random non-blocked spot in this room to drop a key. */ 552/* find a random non-blocked spot in this room to drop a key. */
… …
579 /* setup num_free_spots and room_free_spots */ 573 /* setup num_free_spots and room_free_spots */
580 find_spot_in_room_recursive (layout2, x, y, RP); 574 find_spot_in_room_recursive (layout2, x, y, RP);
581 575
582 if (number_of_free_spots_in_room > 0) 576 if (number_of_free_spots_in_room > 0)
583 { 577 {
584 i = rndm (number_of_free_spots_in_room); 578 i = rmg_rndm (number_of_free_spots_in_room);
585 *kx = room_free_spots_x[i]; 579 *kx = room_free_spots_x[i];
586 *ky = room_free_spots_y[i]; 580 *ky = room_free_spots_y[i];
587 } 581 }
588 582
589 /* deallocate the temp. layout */ 583 /* deallocate the temp. layout */
… …
657 *cy = ly; 651 *cy = ly;
658 return; 652 return;
659 } 653 }
660 } 654 }
661 /* give up and return the closest free spot. */ 655 /* give up and return the closest free spot. */
662 i = find_free_spot (archetype::find ("chest"), map, x, y, 1, SIZEOFFREE1 + 1); 656 i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
663 657
664 if (i != -1) 658 if (i != -1)
665 { 659 {
666 *cx = x + freearr_x[i]; 660 *cx = x + freearr_x[i];
667 *cy = y + freearr_y[i]; 661 *cy = y + freearr_y[i];
… …
746 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 740 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
747 return tmp; 741 return tmp;
748 return NULL; 742 return NULL;
749} 743}
750 744
751
752/* the workhorse routine, which finds the doors in a room */ 745/* the workhorse routine, which finds the doors in a room */
753void 746void
754find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 747find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
755{ 748{
756 int i, j; 749 int i, j;
… …
770 layout[x][y] = 1; 763 layout[x][y] = 1;
771 door = door_in_square (map, x, y); 764 door = door_in_square (map, x, y);
772 if (door) 765 if (door)
773 { 766 {
774 doorlist[*ndoors] = door; 767 doorlist[*ndoors] = door;
768
775 if (*ndoors > 1022) /* eek! out of memory */ 769 if (*ndoors > 1022) /* eek! out of memory */
776 { 770 {
777 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 771 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
778 return; 772 return;
779 } 773 }
… …
784 else 778 else
785 { 779 {
786 layout[x][y] = 1; 780 layout[x][y] = 1;
787 781
788 /* 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 */
789 for (i = rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++) 783 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
790 find_doors_in_room_recursive (layout, map, 784 find_doors_in_room_recursive (layout, map,
791 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 785 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
792 doorlist, ndoors, RP); 786 doorlist, ndoors, RP);
793 } 787 }
794} 788}
795 789
796/* 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. */
797object ** 791object **
798find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 792find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
799{ 793{
800 char **layout2;
801 object **doorlist;
802 int i, j; 794 int i, j;
803 int ndoors = 0; 795 int ndoors = 0;
804 796
805 doorlist = (object **) calloc (sizeof (int), 1024); 797 object **doorlist = (object **)calloc (sizeof (int), 1024);
806 798
807 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 799 LayoutData layout2 (RP->Xsize, RP->Ysize);
800 layout2.clear ();
801
808 /* allocate and copy the layout, converting C to 0. */ 802 /* allocate and copy the layout, converting C to 0. */
809 for (i = 0; i < RP->Xsize; i++) 803 for (i = 0; i < RP->Xsize; i++)
810 {
811 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
812 for (j = 0; j < RP->Ysize; j++) 804 for (j = 0; j < RP->Ysize; j++)
813 { 805 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
814 if (wall_blocked (map, i, j))
815 layout2[i][j] = '#';
816 }
817 }
818 806
819 /* setup num_free_spots and room_free_spots */ 807 /* setup num_free_spots and room_free_spots */
820 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 808 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
821 809
822 /* deallocate the temp. layout */
823 for (i = 0; i < RP->Xsize; i++)
824 free (layout2[i]);
825
826 free (layout2);
827 return doorlist; 810 return doorlist;
828} 811}
829
830
831 812
832/* locks and/or hides all the doors in doorlist, or does nothing if 813/* locks and/or hides all the doors in doorlist, or does nothing if
833 opts doesn't say to lock/hide doors. */ 814 opts doesn't say to lock/hide doors. */
834
835void 815void
836lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP) 816lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
837{ 817{
838 object *door; 818 object *door;
839 int i; 819 int i;
… …
842 822
843 if (opts & DOORED) 823 if (opts & DOORED)
844 { 824 {
845 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 825 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
846 { 826 {
847 object *new_door = get_archetype ("locked_door1"); 827 object *new_door = get_archetype (shstr_locked_door1);
848 char keybuf[1024];
849 828
850 door = doorlist[i]; 829 door = doorlist[i];
851 new_door->face = door->face; 830 new_door->face = door->face;
852 new_door->x = door->x; 831 new_door->x = door->x;
853 new_door->y = door->y; 832 new_door->y = door->y;
854 door->remove (); 833 door->remove ();
855 door->destroy (); 834 door->destroy ();
856 doorlist[i] = new_door; 835 doorlist[i] = new_door;
857 insert_ob_in_map (new_door, map, NULL, 0); 836 insert_ob_in_map (new_door, map, NULL, 0);
858 sprintf (keybuf, "%d", rndm (1000000000)); 837 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
859 new_door->slaying = keybuf;
860 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP); 838 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
861 } 839 }
862 } 840 }
863 841
864 /* change the faces of the doors and surrounding walls to hide them. */ 842 /* change the faces of the doors and surrounding walls to hide them. */
865 if (opts & HIDDEN) 843 if (opts & HIDDEN)
… …
874 { 852 {
875 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP); 853 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
876 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 854 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
877 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 855 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
878 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 856 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
857
879 door->face = wallface->face; 858 door->face = wallface->face;
859
880 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 860 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
881 wallface->remove (); 861 wallface->remove ();
862
882 wallface->destroy (); 863 wallface->destroy ();
883 } 864 }
884 } 865 }
885 } 866 }
886} 867}

Diff Legend

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