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.45 by root, Mon Oct 12 14:00:58 2009 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 it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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 Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24/* placing treasure in maps, where appropriate. */ 25/* placing treasure in maps, where appropriate. */
25 26
26#include <global.h> 27#include <global.h>
… …
45/* a macro to get a strongly centered random distribution, 46/* a macro to get a strongly centered random distribution,
46 from 0 to x, centered at x/2 */ 47 from 0 to x, centered at x/2 */
47static int 48static int
48bc_random (int x) 49bc_random (int x)
49{ 50{
50 return (rndm (x) + rndm (x) + rndm (x)) / 3; 51 return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
52}
53
54static object *
55gen_key (const shstr &keycode)
56{
57 /* get a key and set its keycode */
58 object *key = archetype::get (shstr_key_random_map);
59 key->slaying = keycode;
60 return key;
61}
62
63/* places keys in the map, preferably in something alive.
64 keycode is the key's code,
65 door_flag is either PASS_DOORS or NO_PASS_DOORS.
66 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
67 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
68 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
69
70 The idea is that you call keyplace on x,y where a door is, and it'll make
71 sure a key is placed on both sides of the door.
72*/
73static int
74keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params *RP)
75{
76 int i, j;
77 int kx = 0, ky = 0;
78 object *the_keymaster; /* the monster that gets the key. */
79 object *the_key = gen_key (keycode);
80
81 if (door_flag == PASS_DOORS)
82 {
83 int tries = 0;
84
85 the_keymaster = 0;
86 while (tries < 15 && !the_keymaster)
87 {
88 i = rmg_rndm (RP->Xsize - 2) + 1;
89 j = rmg_rndm (RP->Ysize - 2) + 1;
90 tries++;
91 the_keymaster = find_closest_monster (map, i, j, RP);
92 }
93
94 /* if we don't find a good keymaster, drop the key on the ground. */
95 if (!the_keymaster)
96 {
97 int freeindex;
98
99 freeindex = -1;
100 for (tries = 0; tries < 15 && freeindex == -1; tries++)
101 {
102 kx = rmg_rndm (RP->Xsize - 2) + 1;
103 ky = rmg_rndm (RP->Ysize - 2) + 1;
104 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
105 }
106
107 // can freeindex ever be < 0?
108 if (freeindex >= 0)
109 {
110 kx += freearr_x [freeindex];
111 ky += freearr_y [freeindex];
112 }
113 }
114 }
115 else
116 { /* NO_PASS_DOORS --we have to work harder. */
117 /* don't try to keyplace if we're sitting on a blocked square and
118 NO_PASS_DOORS is set. */
119 if (n_keys == 1)
120 {
121 if (wall_blocked (map, x, y))
122 {
123 the_key->destroy ();
124 return 0;
125 }
126
127 the_keymaster = find_monster_in_room (map, x, y, RP);
128 if (!the_keymaster) /* if fail, find a spot to drop the key. */
129 find_spot_in_room (map, x, y, &kx, &ky, RP);
130 }
131 else
132 {
133 int sum = 0; /* count how many keys we actually place */
134
135 /* I'm lazy, so just try to place in all 4 directions. */
136 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
137 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
138 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
139 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
140
141 if (sum < 2) /* we might have made a disconnected map-place more keys. */
142 { /* diagonally this time. */
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 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
147 }
148
149 the_key->destroy ();
150 return 1;
151 }
152 }
153
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];
… …
675} 670}
676 671
677void 672void
678remove_monsters (int x, int y, maptile *map) 673remove_monsters (int x, int y, maptile *map)
679{ 674{
680 object *tmp;
681
682 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above) 675 for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
683 if (QUERY_FLAG (tmp, FLAG_ALIVE))
684 { 676 {
685 if (tmp->head) 677 object *next = tmp->above;
686 tmp = tmp->head; 678
687 tmp->remove (); 679 if (tmp->flag [FLAG_ALIVE])
688 tmp->destroy (); 680 tmp->head_ ()->destroy ();
689 tmp = GET_MAP_OB (map, x, y); 681
690 if (tmp == NULL) 682 tmp = next;
691 break;
692 }; 683 }
693} 684}
694 685
695/* surrounds the point x,y by doors, so as to enclose something, like 686/* 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 687 a chest. It only goes as far as the 8 squares surrounding, and
697 it'll remove any monsters it finds.*/ 688 it'll remove any monsters it finds.*/
… …
745 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above) 736 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
746 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 737 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
747 return tmp; 738 return tmp;
748 return NULL; 739 return NULL;
749} 740}
750
751 741
752/* the workhorse routine, which finds the doors in a room */ 742/* the workhorse routine, which finds the doors in a room */
753void 743void
754find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 744find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
755{ 745{
… …
770 layout[x][y] = 1; 760 layout[x][y] = 1;
771 door = door_in_square (map, x, y); 761 door = door_in_square (map, x, y);
772 if (door) 762 if (door)
773 { 763 {
774 doorlist[*ndoors] = door; 764 doorlist[*ndoors] = door;
765
775 if (*ndoors > 1022) /* eek! out of memory */ 766 if (*ndoors > 1022) /* eek! out of memory */
776 { 767 {
777 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 768 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
778 return; 769 return;
779 } 770 }
… …
784 else 775 else
785 { 776 {
786 layout[x][y] = 1; 777 layout[x][y] = 1;
787 778
788 /* now search all the 8 squares around recursively for free spots,in random order */ 779 /* 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++) 780 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
790 find_doors_in_room_recursive (layout, map, 781 find_doors_in_room_recursive (layout, map,
791 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 782 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
792 doorlist, ndoors, RP); 783 doorlist, ndoors, RP);
793 } 784 }
794} 785}
795 786
796/* find a random non-blocked spot in this room to drop a key. */ 787/* find a random non-blocked spot in this room to drop a key. */
797object ** 788object **
798find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 789find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
799{ 790{
800 char **layout2;
801 object **doorlist;
802 int i, j; 791 int i, j;
803 int ndoors = 0; 792 int ndoors = 0;
804 793
805 doorlist = (object **) calloc (sizeof (int), 1024); 794 object **doorlist = (object **)calloc (sizeof (int), 1024);
806 795
807 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 796 LayoutData layout2 (RP->Xsize, RP->Ysize);
797 layout2.clear ();
798
808 /* allocate and copy the layout, converting C to 0. */ 799 /* allocate and copy the layout, converting C to 0. */
809 for (i = 0; i < RP->Xsize; i++) 800 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++) 801 for (j = 0; j < RP->Ysize; j++)
813 { 802 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
814 if (wall_blocked (map, i, j))
815 layout2[i][j] = '#';
816 }
817 }
818 803
819 /* setup num_free_spots and room_free_spots */ 804 /* setup num_free_spots and room_free_spots */
820 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 805 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
821 806
822 /* deallocate the temp. layout */
823 for (i = 0; i < RP->Xsize; i++)
824 free (layout2[i]);
825
826 free (layout2);
827 return doorlist; 807 return doorlist;
828} 808}
829
830
831 809
832/* locks and/or hides all the doors in doorlist, or does nothing if 810/* locks and/or hides all the doors in doorlist, or does nothing if
833 opts doesn't say to lock/hide doors. */ 811 opts doesn't say to lock/hide doors. */
834
835void 812void
836lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP) 813lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
837{ 814{
838 object *door; 815 object *door;
839 int i; 816 int i;
840 817
841 /* lock the doors and hide the keys. */ 818 /* lock the doors and hide the keys. */
842 819
843 if (opts & DOORED) 820 if (opts & DOORED)
844 { 821 {
845 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 822 for (i = 0, door = doorlist[0]; doorlist[i]; i++)
846 { 823 {
847 object *new_door = get_archetype ("locked_door1"); 824 object *new_door = get_archetype (shstr_locked_door1);
848 char keybuf[1024];
849 825
850 door = doorlist[i]; 826 door = doorlist[i];
851 new_door->face = door->face; 827 new_door->face = door->face;
852 new_door->x = door->x; 828 new_door->x = door->x;
853 new_door->y = door->y; 829 new_door->y = door->y;
854 door->remove ();
855 door->destroy (); 830 door->destroy ();
856 doorlist[i] = new_door; 831 doorlist[i] = new_door;
857 insert_ob_in_map (new_door, map, NULL, 0); 832 insert_ob_in_map (new_door, map, NULL, 0);
858 sprintf (keybuf, "%d", rndm (1000000000)); 833 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); 834 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
861 } 835 }
862 } 836 }
863 837
864 /* change the faces of the doors and surrounding walls to hide them. */ 838 /* change the faces of the doors and surrounding walls to hide them. */
865 if (opts & HIDDEN) 839 if (opts & HIDDEN)
… …
874 { 848 {
875 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP); 849 retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
876 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 850 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
877 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 851 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
878 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 852 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
853
879 door->face = wallface->face; 854 door->face = wallface->face;
880 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 855
881 wallface->remove ();
882 wallface->destroy (); 856 wallface->destroy ();
883 } 857 }
884 } 858 }
885 } 859 }
886} 860}

Diff Legend

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