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.31 by root, Sun Aug 26 15:31:04 2007 UTC vs.
Revision 1.44 by root, Mon Sep 29 10:32:50 2008 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT 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 * Crossfire TRT 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
10 * the Free Software Foundation, either version 3 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * 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,
… …
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * 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
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24/* placing treasure in maps, where appropriate. */ 24/* placing treasure in maps, where appropriate. */
25 25
26#include <global.h> 26#include <global.h>
… …
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];
… …
675} 669}
676 670
677void 671void
678remove_monsters (int x, int y, maptile *map) 672remove_monsters (int x, int y, maptile *map)
679{ 673{
680 object *tmp;
681
682 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above) 674 for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
683 if (QUERY_FLAG (tmp, FLAG_ALIVE))
684 { 675 {
685 if (tmp->head) 676 object *next = tmp->above;
686 tmp = tmp->head; 677
687 tmp->remove (); 678 if (tmp->flag [FLAG_ALIVE])
688 tmp->destroy (); 679 tmp->head_ ()->destroy ();
689 tmp = GET_MAP_OB (map, x, y); 680
690 if (tmp == NULL) 681 tmp = next;
691 break;
692 }; 682 }
693} 683}
694 684
695/* surrounds the point x,y by doors, so as to enclose something, like 685/* surrounds the point x,y by doors, so as to enclose something, like
696 a chest. It only goes as far as the 8 squares surrounding, and 686 a chest. It only goes as far as the 8 squares surrounding, and
697 it'll remove any monsters it finds.*/ 687 it'll remove any monsters it finds.*/
… …
745 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above) 735 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
746 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 736 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
747 return tmp; 737 return tmp;
748 return NULL; 738 return NULL;
749} 739}
750
751 740
752/* the workhorse routine, which finds the doors in a room */ 741/* the workhorse routine, which finds the doors in a room */
753void 742void
754find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 743find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
755{ 744{
… …
770 layout[x][y] = 1; 759 layout[x][y] = 1;
771 door = door_in_square (map, x, y); 760 door = door_in_square (map, x, y);
772 if (door) 761 if (door)
773 { 762 {
774 doorlist[*ndoors] = door; 763 doorlist[*ndoors] = door;
764
775 if (*ndoors > 1022) /* eek! out of memory */ 765 if (*ndoors > 1022) /* eek! out of memory */
776 { 766 {
777 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 767 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
778 return; 768 return;
779 } 769 }
… …
784 else 774 else
785 { 775 {
786 layout[x][y] = 1; 776 layout[x][y] = 1;
787 777
788 /* now search all the 8 squares around recursively for free spots,in random order */ 778 /* 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++) 779 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
790 find_doors_in_room_recursive (layout, map, 780 find_doors_in_room_recursive (layout, map,
791 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 781 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
792 doorlist, ndoors, RP); 782 doorlist, ndoors, RP);
793 } 783 }
794} 784}
795 785
796/* find a random non-blocked spot in this room to drop a key. */ 786/* find a random non-blocked spot in this room to drop a key. */
797object ** 787object **
798find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 788find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
799{ 789{
800 char **layout2;
801 object **doorlist;
802 int i, j; 790 int i, j;
803 int ndoors = 0; 791 int ndoors = 0;
804 792
805 doorlist = (object **) calloc (sizeof (int), 1024); 793 object **doorlist = (object **)calloc (sizeof (int), 1024);
806 794
807 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 795 LayoutData layout2 (RP->Xsize, RP->Ysize);
796 layout2.clear ();
797
808 /* allocate and copy the layout, converting C to 0. */ 798 /* allocate and copy the layout, converting C to 0. */
809 for (i = 0; i < RP->Xsize; i++) 799 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++) 800 for (j = 0; j < RP->Ysize; j++)
813 { 801 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
814 if (wall_blocked (map, i, j))
815 layout2[i][j] = '#';
816 }
817 }
818 802
819 /* setup num_free_spots and room_free_spots */ 803 /* setup num_free_spots and room_free_spots */
820 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 804 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
821 805
822 /* deallocate the temp. layout */
823 for (i = 0; i < RP->Xsize; i++)
824 free (layout2[i]);
825
826 free (layout2);
827 return doorlist; 806 return doorlist;
828} 807}
829
830
831 808
832/* locks and/or hides all the doors in doorlist, or does nothing if 809/* locks and/or hides all the doors in doorlist, or does nothing if
833 opts doesn't say to lock/hide doors. */ 810 opts doesn't say to lock/hide doors. */
834
835void 811void
836lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP) 812lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
837{ 813{
838 object *door; 814 object *door;
839 int i; 815 int i;
840 816
841 /* lock the doors and hide the keys. */ 817 /* lock the doors and hide the keys. */
842 818
843 if (opts & DOORED) 819 if (opts & DOORED)
844 { 820 {
845 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 821 for (i = 0, door = doorlist[0]; doorlist[i]; i++)
846 { 822 {
847 object *new_door = get_archetype ("locked_door1"); 823 object *new_door = get_archetype (shstr_locked_door1);
848 char keybuf[1024];
849 824
850 door = doorlist[i]; 825 door = doorlist[i];
851 new_door->face = door->face; 826 new_door->face = door->face;
852 new_door->x = door->x; 827 new_door->x = door->x;
853 new_door->y = door->y; 828 new_door->y = door->y;
854 door->remove ();
855 door->destroy (); 829 door->destroy ();
856 doorlist[i] = new_door; 830 doorlist[i] = new_door;
857 insert_ob_in_map (new_door, map, NULL, 0); 831 insert_ob_in_map (new_door, map, NULL, 0);
858 sprintf (keybuf, "%d", rndm (1000000000)); 832 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); 833 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
861 } 834 }
862 } 835 }
863 836
864 /* change the faces of the doors and surrounding walls to hide them. */ 837 /* change the faces of the doors and surrounding walls to hide them. */
865 if (opts & HIDDEN) 838 if (opts & HIDDEN)
… …
874 { 847 {
875 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP); 848 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
876 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 849 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
877 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 850 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
878 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 851 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
852
879 door->face = wallface->face; 853 door->face = wallface->face;
880 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 854
881 wallface->remove ();
882 wallface->destroy (); 855 wallface->destroy ();
883 } 856 }
884 } 857 }
885 } 858 }
886} 859}

Diff Legend

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