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.41 by root, Thu Jul 24 20:35:37 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 LOG(llevError, "key %d,%d %p\n", the_keymaster ? the_keymaster->x : x, the_keymaster ? the_keymaster->y : y, the_keymaster+0);//D
154 if (the_keymaster)
155 the_keymaster->head_ ()->insert (the_key);
156 else
157 {
158 the_key->x = kx;
159 the_key->y = ky;
160 insert_ob_in_map (the_key, map, NULL, 0);
161 }
162
163 return 1;
51} 164}
52 165
53/* returns true if square x,y has P_NO_PASS set, which is true for walls 166/* returns true if square x,y has P_NO_PASS set, which is true for walls
54 * and doors but not monsters. 167 * and doors but not monsters.
55 * This function is not map tile aware. 168 * This function is not map tile aware.
… …
82 if (treasure_style) 195 if (treasure_style)
83 if (!strcmp (treasure_style, "none")) 196 if (!strcmp (treasure_style, "none"))
84 return; 197 return;
85 198
86 if (treasureoptions <= 0) 199 if (treasureoptions <= 0)
87 treasureoptions = rndm (2 * LAST_OPTION); 200 treasureoptions = rmg_rndm (2 * LAST_OPTION);
88 201
89 /* filter out the mutually exclusive options */ 202 /* filter out the mutually exclusive options */
90 if ((treasureoptions & RICH) && (treasureoptions & SPARSE)) 203 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
91 { 204 {
92 if (rndm (2)) 205 if (rmg_rndm (2))
93 treasureoptions -= 1; 206 treasureoptions -= 1;
94 else 207 else
95 treasureoptions -= 2; 208 treasureoptions -= 2;
96 } 209 }
97 210
… …
118 } 231 }
119 232
120 /* all the treasure at one spot in the map. */ 233 /* all the treasure at one spot in the map. */
121 if (treasureoptions & CONCENTRATED) 234 if (treasureoptions & CONCENTRATED)
122 { 235 {
123
124 /* map_layout_style global, and is previously set */ 236 /* map_layout_style global, and is previously set */
125 switch (RP->map_layout_style) 237 switch (RP->map_layout_style)
126 { 238 {
127 case LAYOUT_ONION: 239 case LAYOUT_ONION:
128 case LAYOUT_SPIRAL: 240 case LAYOUT_SPIRAL:
… …
136 for (j = 0; j < RP->Ysize; j++) 248 for (j = 0; j < RP->Ysize; j++)
137 { 249 {
138 if (layout[i][j] == 'C' || layout[i][j] == '>') 250 if (layout[i][j] == 'C' || layout[i][j] == '>')
139 { 251 {
140 int tdiv = RP->symmetry_used; 252 int tdiv = RP->symmetry_used;
141 object **doorlist;
142 object *chest; 253 object *chest;
143 254
144 if (tdiv == 3) 255 if (tdiv == 3)
145 tdiv = 2; /* this symmetry uses a divisor of 2 */ 256 tdiv = 2; /* this symmetry uses a divisor of 2 */
257
146 /* don't put a chest on an exit. */ 258 /* don't put a chest on an exit. */
147 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP); 259 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
260
148 if (!chest) 261 if (!chest)
149 continue; /* if no chest was placed NEXT */ 262 continue; /* if no chest was placed NEXT */
263
150 if (treasureoptions & (DOORED | HIDDEN)) 264 if (treasureoptions & (DOORED | HIDDEN))
151 { 265 {
152 doorlist = find_doors_in_room (map, i, j, RP); 266 object **doorlist = find_doors_in_room (map, i, j, RP);
153 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 267 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
154 free (doorlist); 268 free (doorlist);
155 } 269 }
156 } 270 }
157 } 271 }
158 } 272 }
159 break; 273 break;
160 } 274 }
275
161 default: 276 default:
162 { 277 {
163 int i, j, tries; 278 int i, j, tries;
164 object *chest; 279 object *chest;
165 object **doorlist; 280 object **doorlist;
166 281
167 i = j = -1; 282 i = j = -1;
168 tries = 0; 283 tries = 0;
169 while (i == -1 && tries < 100) 284 while (i == -1 && tries < 100)
170 { 285 {
171 i = rndm (RP->Xsize - 2) + 1; 286 i = rmg_rndm (RP->Xsize - 2) + 1;
172 j = rndm (RP->Ysize - 2) + 1; 287 j = rmg_rndm (RP->Ysize - 2) + 1;
173 find_enclosed_spot (map, &i, &j, RP); 288 find_enclosed_spot (map, &i, &j, RP);
289
174 if (wall_blocked (map, i, j)) 290 if (wall_blocked (map, i, j))
175 i = -1; 291 i = -1;
292
176 tries++; 293 tries++;
177 } 294 }
295
178 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP); 296 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
297
179 if (!chest) 298 if (!chest)
180 return; 299 return;
300
181 i = chest->x; 301 i = chest->x;
182 j = chest->y; 302 j = chest->y;
183 if (treasureoptions & (DOORED | HIDDEN)) 303 if (treasureoptions & (DOORED | HIDDEN))
184 { 304 {
185 doorlist = surround_by_doors (map, layout, i, j, treasureoptions); 305 doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
… …
193 { /* DIFFUSE treasure layout */ 313 { /* DIFFUSE treasure layout */
194 int ti, i, j; 314 int ti, i, j;
195 315
196 for (ti = 0; ti < num_treasures; ti++) 316 for (ti = 0; ti < num_treasures; ti++)
197 { 317 {
198 i = rndm (RP->Xsize - 2) + 1; 318 i = rmg_rndm (RP->Xsize - 2) + 1;
199 j = rndm (RP->Ysize - 2) + 1; 319 j = rmg_rndm (RP->Ysize - 2) + 1;
200 place_chest (treasureoptions, i, j, map, style_map, 1, RP); 320 place_chest (treasureoptions, i, j, map, style_map, 1, RP);
201 } 321 }
202 } 322 }
203} 323}
204 324
205/* put a chest into the map, near x and y, with the treasure style 325/* 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, 326 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 */ 327 if the global variable "treasurestyle" is set to that treasure list's name */
208
209object * 328object *
210place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP) 329place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
211{ 330{
212 object *the_chest;
213 int i, xl, yl;
214
215 the_chest = get_archetype ("chest"); /* was "chest_2" */ 331 object *the_chest = archetype::get (shstr_chest); /* was "chest_2" */
216 332
217 /* first, find a place to put the chest. */ 333 /* first, find a place to put the chest. */
218 i = find_first_free_spot (the_chest, map, x, y); 334 int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
219 if (i == -1) 335 if (i == -1)
220 { 336 {
221 the_chest->destroy (); 337 the_chest->destroy ();
222 return NULL; 338 return NULL;
223 } 339 }
224 340
225 xl = x + freearr_x[i]; 341 int xl = x + freearr_x[i];
226 yl = y + freearr_y[i]; 342 int yl = y + freearr_y[i];
227 343
228 /* if the placement is blocked, return a fail. */ 344 /* if the placement is blocked, return a fail. */
229 if (wall_blocked (map, xl, yl)) 345 if (wall_blocked (map, xl, yl))
230 return 0; 346 return 0;
231 347
… …
238 treasurelist *tlist = find_treasurelist (RP->treasurestyle); 354 treasurelist *tlist = find_treasurelist (RP->treasurestyle);
239 355
240 if (tlist != NULL) 356 if (tlist != NULL)
241 for (ti = 0; ti < n_treasures; ti++) 357 for (ti = 0; ti < n_treasures; ti++)
242 { /* use the treasure list */ 358 { /* use the treasure list */
243 object *new_treasure = style_map->pick_random_object (); 359 object *new_treasure = style_map->pick_random_object (rmg_rndm);
244 360
245 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest); 361 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
246 } 362 }
247 else 363 else
248 { /* use the style map */ 364 { /* use the style map */
… …
259 375
260 /* stick a trap in the chest if required */ 376 /* stick a trap in the chest if required */
261 if (treasureoptions & TRAPPED) 377 if (treasureoptions & TRAPPED)
262 { 378 {
263 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1); 379 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
264 object *the_trap;
265 380
266 if (trap_map) 381 if (trap_map)
267 { 382 {
268 the_trap = trap_map->pick_random_object (); 383 object *the_trap = trap_map->pick_random_object (rmg_rndm);
384
269 the_trap->stats.Cha = 10 + RP->difficulty; 385 the_trap->stats.Cha = 10 + RP->difficulty;
270 the_trap->level = bc_random ((3 * RP->difficulty) / 2); 386 the_trap->level = bc_random ((3 * RP->difficulty) / 2);
387
271 if (the_trap) 388 if (the_trap)
272 { 389 {
273 object *new_trap; 390 object *new_trap = the_trap->arch->instance ();//TODO: why not clone?
274 391
275 new_trap = arch_to_object (the_trap->arch);
276 new_trap->copy_to (the_trap);
277 new_trap->x = x; 392 new_trap->x = x;
278 new_trap->y = y; 393 new_trap->y = y;
279 insert_ob_in_ob (new_trap, the_chest); 394 insert_ob_in_ob (new_trap, the_chest);
280 } 395 }
281 } 396 }
… …
284 /* set the chest lock code, and call the keyplacer routine with 399 /* set the chest lock code, and call the keyplacer routine with
285 the lockcode. It's not worth bothering to lock the chest if 400 the lockcode. It's not worth bothering to lock the chest if
286 there's only 1 treasure.... */ 401 there's only 1 treasure.... */
287 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 402 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
288 { 403 {
289 char keybuf[1024]; 404 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); 405 keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
294 } 406 }
295 407
296 /* actually place the chest. */ 408 /* actually place the chest. */
297 the_chest->x = xl; 409 the_chest->x = xl;
298 the_chest->y = yl; 410 the_chest->y = yl;
… …
327 } 439 }
328 } 440 }
329 return NULL; 441 return NULL;
330} 442}
331 443
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. */ 444/* both find_monster_in_room routines need to have access to this. */
440 445
441object *theMonsterToFind; 446object *theMonsterToFind;
442 447
443/* a recursive routine which will return a monster, eventually,if there is one. 448/* a recursive routine which will return a monster, eventually,if there is one.
… …
475 return theMonsterToFind; 480 return theMonsterToFind;
476 } 481 }
477 } 482 }
478 483
479 /* now search all the 8 squares around recursively for a monster,in random order */ 484 /* 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++) 485 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
481 { 486 {
482 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 487 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) 488 if (theMonsterToFind != NULL)
484 return theMonsterToFind; 489 return theMonsterToFind;
485 } 490 }
491
486 return theMonsterToFind; 492 return theMonsterToFind;
487} 493}
488
489 494
490/* sets up some data structures: the _recursive form does the 495/* sets up some data structures: the _recursive form does the
491 real work. */ 496 real work. */
492
493object * 497object *
494find_monster_in_room (maptile *map, int x, int y, random_map_params *RP) 498find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
495{ 499{
496 char **layout2; 500 Layout layout2 (RP);
497 int i, j; 501
502 layout2->clear ();
503
504 /* allocate and copy the layout, converting C to 0. */
505 for (int i = 0; i < layout2->w; i++)
506 for (int j = 0; j < layout2->h; j++)
507 if (wall_blocked (map, i, j))
508 layout2[i][j] = '#';
498 509
499 theMonsterToFind = 0; 510 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); 511 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
512 512
513 /* deallocate the temp. layout */ 513 layout2.free ();
514 for (i = 0; i < RP->Xsize; i++)
515 {
516 free (layout2[i]);
517 }
518 free (layout2);
519 514
520 return theMonsterToFind; 515 return theMonsterToFind;
521} 516}
522 517
523/* 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 */
… …
548 room_free_spots_x[number_of_free_spots_in_room] = x; 543 room_free_spots_x[number_of_free_spots_in_room] = x;
549 room_free_spots_y[number_of_free_spots_in_room] = y; 544 room_free_spots_y[number_of_free_spots_in_room] = y;
550 number_of_free_spots_in_room++; 545 number_of_free_spots_in_room++;
551 546
552 /* 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 */
553 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 548 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); 549 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
555 550
556} 551}
557 552
558/* 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. */
… …
579 /* setup num_free_spots and room_free_spots */ 574 /* setup num_free_spots and room_free_spots */
580 find_spot_in_room_recursive (layout2, x, y, RP); 575 find_spot_in_room_recursive (layout2, x, y, RP);
581 576
582 if (number_of_free_spots_in_room > 0) 577 if (number_of_free_spots_in_room > 0)
583 { 578 {
584 i = rndm (number_of_free_spots_in_room); 579 i = rmg_rndm (number_of_free_spots_in_room);
585 *kx = room_free_spots_x[i]; 580 *kx = room_free_spots_x[i];
586 *ky = room_free_spots_y[i]; 581 *ky = room_free_spots_y[i];
587 } 582 }
588 583
589 /* deallocate the temp. layout */ 584 /* deallocate the temp. layout */
… …
657 *cy = ly; 652 *cy = ly;
658 return; 653 return;
659 } 654 }
660 } 655 }
661 /* give up and return the closest free spot. */ 656 /* give up and return the closest free spot. */
662 i = find_free_spot (archetype::find ("chest"), map, x, y, 1, SIZEOFFREE1 + 1); 657 i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
663 658
664 if (i != -1) 659 if (i != -1)
665 { 660 {
666 *cx = x + freearr_x[i]; 661 *cx = x + freearr_x[i];
667 *cy = y + freearr_y[i]; 662 *cy = y + freearr_y[i];
… …
746 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 741 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
747 return tmp; 742 return tmp;
748 return NULL; 743 return NULL;
749} 744}
750 745
751
752/* the workhorse routine, which finds the doors in a room */ 746/* the workhorse routine, which finds the doors in a room */
753void 747void
754find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 748find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
755{ 749{
756 int i, j; 750 int i, j;
… …
770 layout[x][y] = 1; 764 layout[x][y] = 1;
771 door = door_in_square (map, x, y); 765 door = door_in_square (map, x, y);
772 if (door) 766 if (door)
773 { 767 {
774 doorlist[*ndoors] = door; 768 doorlist[*ndoors] = door;
769
775 if (*ndoors > 1022) /* eek! out of memory */ 770 if (*ndoors > 1022) /* eek! out of memory */
776 { 771 {
777 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");
778 return; 773 return;
779 } 774 }
… …
784 else 779 else
785 { 780 {
786 layout[x][y] = 1; 781 layout[x][y] = 1;
787 782
788 /* now search all the 8 squares around recursively for free spots,in random order */ 783 /* 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++) 784 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
790 find_doors_in_room_recursive (layout, map, 785 find_doors_in_room_recursive (layout, map,
791 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 786 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
792 doorlist, ndoors, RP); 787 doorlist, ndoors, RP);
793 } 788 }
794} 789}
795 790
796/* find a random non-blocked spot in this room to drop a key. */ 791/* find a random non-blocked spot in this room to drop a key. */
797object ** 792object **
798find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 793find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
799{ 794{
800 char **layout2;
801 object **doorlist;
802 int i, j; 795 int i, j;
803 int ndoors = 0; 796 int ndoors = 0;
804 797
805 doorlist = (object **) calloc (sizeof (int), 1024); 798 object **doorlist = (object **)calloc (sizeof (int), 1024);
806 799
807 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 800 LayoutData layout2 (RP->Xsize, RP->Ysize);
801 layout2.clear ();
802
808 /* allocate and copy the layout, converting C to 0. */ 803 /* allocate and copy the layout, converting C to 0. */
809 for (i = 0; i < RP->Xsize; i++) 804 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++) 805 for (j = 0; j < RP->Ysize; j++)
813 { 806 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
814 if (wall_blocked (map, i, j))
815 layout2[i][j] = '#';
816 }
817 }
818 807
819 /* setup num_free_spots and room_free_spots */ 808 /* setup num_free_spots and room_free_spots */
820 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 809 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
821 810
822 /* deallocate the temp. layout */
823 for (i = 0; i < RP->Xsize; i++)
824 free (layout2[i]);
825
826 free (layout2);
827 return doorlist; 811 return doorlist;
828} 812}
829
830
831 813
832/* locks and/or hides all the doors in doorlist, or does nothing if 814/* locks and/or hides all the doors in doorlist, or does nothing if
833 opts doesn't say to lock/hide doors. */ 815 opts doesn't say to lock/hide doors. */
834
835void 816void
836lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP) 817lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
837{ 818{
838 object *door; 819 object *door;
839 int i; 820 int i;
… …
842 823
843 if (opts & DOORED) 824 if (opts & DOORED)
844 { 825 {
845 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 826 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
846 { 827 {
847 object *new_door = get_archetype ("locked_door1"); 828 object *new_door = get_archetype (shstr_locked_door1);
848 char keybuf[1024];
849 829
850 door = doorlist[i]; 830 door = doorlist[i];
851 new_door->face = door->face; 831 new_door->face = door->face;
852 new_door->x = door->x; 832 new_door->x = door->x;
853 new_door->y = door->y; 833 new_door->y = door->y;
854 door->remove (); 834 door->remove ();
855 door->destroy (); 835 door->destroy ();
856 doorlist[i] = new_door; 836 doorlist[i] = new_door;
857 insert_ob_in_map (new_door, map, NULL, 0); 837 insert_ob_in_map (new_door, map, NULL, 0);
858 sprintf (keybuf, "%d", rndm (1000000000)); 838 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); 839 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
861 } 840 }
862 } 841 }
863 842
864 /* change the faces of the doors and surrounding walls to hide them. */ 843 /* change the faces of the doors and surrounding walls to hide them. */
865 if (opts & HIDDEN) 844 if (opts & HIDDEN)
… …
874 { 853 {
875 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP); 854 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
876 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 855 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
877 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 856 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
878 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 857 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
858
879 door->face = wallface->face; 859 door->face = wallface->face;
860
880 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 861 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
881 wallface->remove (); 862 wallface->remove ();
863
882 wallface->destroy (); 864 wallface->destroy ();
883 } 865 }
884 } 866 }
885 } 867 }
886} 868}

Diff Legend

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