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.37 by root, Fri May 2 21:01:53 2008 UTC vs.
Revision 1.39 by root, Thu May 8 11:39:24 2008 UTC

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_key2);
58
59 key->slaying = keycode;
60 key->stats.food = 100;
61 key->speed_left = -1.f;
62 key->flag [FLAG_IS_USED_UP] = true;
63 key->set_speed (1.f / 300.f);
64
65 return key;
66}
67
68/* places keys in the map, preferably in something alive.
69 keycode is the key's code,
70 door_flag is either PASS_DOORS or NO_PASS_DOORS.
71 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
72 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
73 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
74
75 The idea is that you call keyplace on x,y where a door is, and it'll make
76 sure a key is placed on both sides of the door.
77*/
78static int
79keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params *RP)
80{
81 int i, j;
82 int kx = 0, ky = 0;
83 object *the_keymaster; /* the monster that gets the key. */
84
85 if (door_flag == PASS_DOORS)
86 {
87 int tries = 0;
88
89 the_keymaster = 0;
90 while (tries < 15 && !the_keymaster)
91 {
92 i = rmg_rndm (RP->Xsize - 2) + 1;
93 j = rmg_rndm (RP->Ysize - 2) + 1;
94 tries++;
95 the_keymaster = find_closest_monster (map, i, j, RP);
96 }
97
98 /* if we don't find a good keymaster, drop the key on the ground. */
99 if (!the_keymaster)
100 {
101 int freeindex;
102
103 freeindex = -1;
104 for (tries = 0; tries < 15 && freeindex == -1; tries++)
105 {
106 kx = rmg_rndm (RP->Xsize - 2) + 1;
107 ky = rmg_rndm (RP->Ysize - 2) + 1;
108 freeindex = find_free_spot (gen_key (keycode), map, kx, ky, 1, SIZEOFFREE1 + 1);
109 }
110
111 // can freeindex ever be < 0?
112 if (freeindex >= 0)
113 {
114 kx += freearr_x [freeindex];
115 ky += freearr_y [freeindex];
116 }
117 }
118 }
119 else
120 { /* NO_PASS_DOORS --we have to work harder. */
121 /* don't try to keyplace if we're sitting on a blocked square and
122 NO_PASS_DOORS is set. */
123 if (n_keys == 1)
124 {
125 if (wall_blocked (map, x, y))
126 return 0;
127
128 the_keymaster = find_monster_in_room (map, x, y, RP);
129 if (!the_keymaster) /* if fail, find a spot to drop the key. */
130 find_spot_in_room (map, x, y, &kx, &ky, RP);
131 }
132 else
133 {
134 int sum = 0; /* count how many keys we actually place */
135
136 /* I'm lazy, so just try to place in all 4 directions. */
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 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
140 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
141
142 if (sum < 2) /* we might have made a disconnected map-place more keys. */
143 { /* diagonally this time. */
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 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
148 }
149
150 return 1;
151 }
152 }
153
154 object *the_key = gen_key (keycode);
155
156 if (the_keymaster)
157 the_keymaster->head_ ()->insert (the_key);
158 else
159 {
160 the_key->x = kx;
161 the_key->y = ky;
162 insert_ob_in_map (the_key, map, NULL, 0);
163 }
164
165 return 1;
51} 166}
52 167
53/* returns true if square x,y has P_NO_PASS set, which is true for walls 168/* returns true if square x,y has P_NO_PASS set, which is true for walls
54 * and doors but not monsters. 169 * and doors but not monsters.
55 * This function is not map tile aware. 170 * This function is not map tile aware.
82 if (treasure_style) 197 if (treasure_style)
83 if (!strcmp (treasure_style, "none")) 198 if (!strcmp (treasure_style, "none"))
84 return; 199 return;
85 200
86 if (treasureoptions <= 0) 201 if (treasureoptions <= 0)
87 treasureoptions = rndm (2 * LAST_OPTION); 202 treasureoptions = rmg_rndm (2 * LAST_OPTION);
88 203
89 /* filter out the mutually exclusive options */ 204 /* filter out the mutually exclusive options */
90 if ((treasureoptions & RICH) && (treasureoptions & SPARSE)) 205 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
91 { 206 {
92 if (rndm (2)) 207 if (rmg_rndm (2))
93 treasureoptions -= 1; 208 treasureoptions -= 1;
94 else 209 else
95 treasureoptions -= 2; 210 treasureoptions -= 2;
96 } 211 }
97 212
168 283
169 i = j = -1; 284 i = j = -1;
170 tries = 0; 285 tries = 0;
171 while (i == -1 && tries < 100) 286 while (i == -1 && tries < 100)
172 { 287 {
173 i = rndm (RP->Xsize - 2) + 1; 288 i = rmg_rndm (RP->Xsize - 2) + 1;
174 j = rndm (RP->Ysize - 2) + 1; 289 j = rmg_rndm (RP->Ysize - 2) + 1;
175 find_enclosed_spot (map, &i, &j, RP); 290 find_enclosed_spot (map, &i, &j, RP);
176 291
177 if (wall_blocked (map, i, j)) 292 if (wall_blocked (map, i, j))
178 i = -1; 293 i = -1;
179 294
200 { /* DIFFUSE treasure layout */ 315 { /* DIFFUSE treasure layout */
201 int ti, i, j; 316 int ti, i, j;
202 317
203 for (ti = 0; ti < num_treasures; ti++) 318 for (ti = 0; ti < num_treasures; ti++)
204 { 319 {
205 i = rndm (RP->Xsize - 2) + 1; 320 i = rmg_rndm (RP->Xsize - 2) + 1;
206 j = rndm (RP->Ysize - 2) + 1; 321 j = rmg_rndm (RP->Ysize - 2) + 1;
207 place_chest (treasureoptions, i, j, map, style_map, 1, RP); 322 place_chest (treasureoptions, i, j, map, style_map, 1, RP);
208 } 323 }
209 } 324 }
210} 325}
211 326
213 determined (may be null, or may be a treasure list from lib/treasures, 328 determined (may be null, or may be a treasure list from lib/treasures,
214 if the global variable "treasurestyle" is set to that treasure list's name */ 329 if the global variable "treasurestyle" is set to that treasure list's name */
215object * 330object *
216place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP) 331place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
217{ 332{
218 object *the_chest;
219 int i, xl, yl;
220
221 the_chest = get_archetype ("chest"); /* was "chest_2" */ 333 object *the_chest = archetype::get (shstr_chest); /* was "chest_2" */
222 334
223 /* first, find a place to put the chest. */ 335 /* first, find a place to put the chest. */
224 i = find_first_free_spot (the_chest, map, x, y); 336 int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
225 if (i == -1) 337 if (i == -1)
226 { 338 {
227 the_chest->destroy (); 339 the_chest->destroy ();
228 return NULL; 340 return NULL;
229 } 341 }
230 342
231 xl = x + freearr_x[i]; 343 int xl = x + freearr_x[i];
232 yl = y + freearr_y[i]; 344 int yl = y + freearr_y[i];
233 345
234 /* if the placement is blocked, return a fail. */ 346 /* if the placement is blocked, return a fail. */
235 if (wall_blocked (map, xl, yl)) 347 if (wall_blocked (map, xl, yl))
236 return 0; 348 return 0;
237 349
244 treasurelist *tlist = find_treasurelist (RP->treasurestyle); 356 treasurelist *tlist = find_treasurelist (RP->treasurestyle);
245 357
246 if (tlist != NULL) 358 if (tlist != NULL)
247 for (ti = 0; ti < n_treasures; ti++) 359 for (ti = 0; ti < n_treasures; ti++)
248 { /* use the treasure list */ 360 { /* use the treasure list */
249 object *new_treasure = style_map->pick_random_object (); 361 object *new_treasure = style_map->pick_random_object (rmg_rndm);
250 362
251 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest); 363 insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
252 } 364 }
253 else 365 else
254 { /* use the style map */ 366 { /* use the style map */
268 { 380 {
269 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1); 381 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
270 382
271 if (trap_map) 383 if (trap_map)
272 { 384 {
273 object *the_trap = trap_map->pick_random_object (); 385 object *the_trap = trap_map->pick_random_object (rmg_rndm);
274 386
275 the_trap->stats.Cha = 10 + RP->difficulty; 387 the_trap->stats.Cha = 10 + RP->difficulty;
276 the_trap->level = bc_random ((3 * RP->difficulty) / 2); 388 the_trap->level = bc_random ((3 * RP->difficulty) / 2);
277 389
278 if (the_trap) 390 if (the_trap)
289 /* set the chest lock code, and call the keyplacer routine with 401 /* set the chest lock code, and call the keyplacer routine with
290 the lockcode. It's not worth bothering to lock the chest if 402 the lockcode. It's not worth bothering to lock the chest if
291 there's only 1 treasure.... */ 403 there's only 1 treasure.... */
292 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 404 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
293 { 405 {
294 char keybuf[1024]; 406 the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
295
296 sprintf (keybuf, "%d", rndm (1000000000));
297 the_chest->slaying = keybuf;
298 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP); 407 keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
299 } 408 }
300 409
301 /* actually place the chest. */ 410 /* actually place the chest. */
302 the_chest->x = xl; 411 the_chest->x = xl;
303 the_chest->y = yl; 412 the_chest->y = yl;
332 } 441 }
333 } 442 }
334 return NULL; 443 return NULL;
335} 444}
336 445
337
338
339/* places keys in the map, preferably in something alive.
340 keycode is the key's code,
341 door_flag is either PASS_DOORS or NO_PASS_DOORS.
342 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
343 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
344 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
345
346 The idea is that you call keyplace on x,y where a door is, and it'll make
347 sure a key is placed on both sides of the door.
348*/
349int
350keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
351{
352 int i, j;
353 int kx = 0, ky = 0;
354 object *the_keymaster; /* the monster that gets the key. */
355 object *the_key;
356
357 /* get a key and set its keycode */
358 the_key = get_archetype ("key2");
359 the_key->slaying = keycode;
360
361 if (door_flag == PASS_DOORS)
362 {
363 int tries = 0;
364
365 the_keymaster = 0;
366 while (tries < 15 && !the_keymaster)
367 {
368 i = rndm (RP->Xsize - 2) + 1;
369 j = rndm (RP->Ysize - 2) + 1;
370 tries++;
371 the_keymaster = find_closest_monster (map, i, j, RP);
372 }
373
374 /* if we don't find a good keymaster, drop the key on the ground. */
375 if (!the_keymaster)
376 {
377 int freeindex;
378
379 freeindex = -1;
380 for (tries = 0; tries < 15 && freeindex == -1; tries++)
381 {
382 kx = rndm (RP->Xsize - 2) + 1;
383 ky = rndm (RP->Ysize - 2) + 1;
384 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
385 }
386
387 // can freeindex ever be < 0?
388 if (freeindex >= 0)
389 {
390 kx += freearr_x [freeindex];
391 ky += freearr_y [freeindex];
392 }
393 }
394 }
395 else
396 { /* NO_PASS_DOORS --we have to work harder. */
397 /* don't try to keyplace if we're sitting on a blocked square and
398 NO_PASS_DOORS is set. */
399 if (n_keys == 1)
400 {
401 if (wall_blocked (map, x, y))
402 return 0;
403
404 the_keymaster = find_monster_in_room (map, x, y, RP);
405 if (!the_keymaster) /* if fail, find a spot to drop the key. */
406 find_spot_in_room (map, x, y, &kx, &ky, RP);
407 }
408 else
409 {
410 int sum = 0; /* count how many keys we actually place */
411
412 /* I'm lazy, so just try to place in all 4 directions. */
413 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
414 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
415 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
416 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
417
418 if (sum < 2) /* we might have made a disconnected map-place more keys. */
419 { /* diagonally this time. */
420 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
421 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
422 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
423 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
424 }
425
426 return 1;
427 }
428 }
429
430 if (!the_keymaster)
431 {
432 the_key->x = kx;
433 the_key->y = ky;
434 insert_ob_in_map (the_key, map, NULL, 0);
435 return 1;
436 }
437
438 insert_ob_in_ob (the_key, the_keymaster->head_ ());
439 return 1;
440}
441
442
443
444/* both find_monster_in_room routines need to have access to this. */ 446/* both find_monster_in_room routines need to have access to this. */
445 447
446object *theMonsterToFind; 448object *theMonsterToFind;
447 449
448/* a recursive routine which will return a monster, eventually,if there is one. 450/* a recursive routine which will return a monster, eventually,if there is one.
480 return theMonsterToFind; 482 return theMonsterToFind;
481 } 483 }
482 } 484 }
483 485
484 /* now search all the 8 squares around recursively for a monster,in random order */ 486 /* now search all the 8 squares around recursively for a monster,in random order */
485 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 487 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
486 { 488 {
487 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 489 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
488 if (theMonsterToFind != NULL) 490 if (theMonsterToFind != NULL)
489 return theMonsterToFind; 491 return theMonsterToFind;
490 } 492 }
543 room_free_spots_x[number_of_free_spots_in_room] = x; 545 room_free_spots_x[number_of_free_spots_in_room] = x;
544 room_free_spots_y[number_of_free_spots_in_room] = y; 546 room_free_spots_y[number_of_free_spots_in_room] = y;
545 number_of_free_spots_in_room++; 547 number_of_free_spots_in_room++;
546 548
547 /* now search all the 8 squares around recursively for free spots,in random order */ 549 /* now search all the 8 squares around recursively for free spots,in random order */
548 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 550 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
549 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 551 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
550 552
551} 553}
552 554
553/* find a random non-blocked spot in this room to drop a key. */ 555/* find a random non-blocked spot in this room to drop a key. */
574 /* setup num_free_spots and room_free_spots */ 576 /* setup num_free_spots and room_free_spots */
575 find_spot_in_room_recursive (layout2, x, y, RP); 577 find_spot_in_room_recursive (layout2, x, y, RP);
576 578
577 if (number_of_free_spots_in_room > 0) 579 if (number_of_free_spots_in_room > 0)
578 { 580 {
579 i = rndm (number_of_free_spots_in_room); 581 i = rmg_rndm (number_of_free_spots_in_room);
580 *kx = room_free_spots_x[i]; 582 *kx = room_free_spots_x[i];
581 *ky = room_free_spots_y[i]; 583 *ky = room_free_spots_y[i];
582 } 584 }
583 585
584 /* deallocate the temp. layout */ 586 /* deallocate the temp. layout */
652 *cy = ly; 654 *cy = ly;
653 return; 655 return;
654 } 656 }
655 } 657 }
656 /* give up and return the closest free spot. */ 658 /* give up and return the closest free spot. */
657 i = find_free_spot (archetype::find ("chest"), map, x, y, 1, SIZEOFFREE1 + 1); 659 i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
658 660
659 if (i != -1) 661 if (i != -1)
660 { 662 {
661 *cx = x + freearr_x[i]; 663 *cx = x + freearr_x[i];
662 *cy = y + freearr_y[i]; 664 *cy = y + freearr_y[i];
779 else 781 else
780 { 782 {
781 layout[x][y] = 1; 783 layout[x][y] = 1;
782 784
783 /* now search all the 8 squares around recursively for free spots,in random order */ 785 /* now search all the 8 squares around recursively for free spots,in random order */
784 for (i = rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++) 786 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
785 find_doors_in_room_recursive (layout, map, 787 find_doors_in_room_recursive (layout, map,
786 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 788 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
787 doorlist, ndoors, RP); 789 doorlist, ndoors, RP);
788 } 790 }
789} 791}
824 if (opts & DOORED) 826 if (opts & DOORED)
825 { 827 {
826 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 828 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
827 { 829 {
828 object *new_door = get_archetype ("locked_door1"); 830 object *new_door = get_archetype ("locked_door1");
829 char keybuf[1024];
830 831
831 door = doorlist[i]; 832 door = doorlist[i];
832 new_door->face = door->face; 833 new_door->face = door->face;
833 new_door->x = door->x; 834 new_door->x = door->x;
834 new_door->y = door->y; 835 new_door->y = door->y;
835 door->remove (); 836 door->remove ();
836 door->destroy (); 837 door->destroy ();
837 doorlist[i] = new_door; 838 doorlist[i] = new_door;
838 insert_ob_in_map (new_door, map, NULL, 0); 839 insert_ob_in_map (new_door, map, NULL, 0);
839 sprintf (keybuf, "%d", rndm (1000000000)); 840 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
840 new_door->slaying = keybuf;
841 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP); 841 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
842 } 842 }
843 } 843 }
844 844
845 /* change the faces of the doors and surrounding walls to hide them. */ 845 /* change the faces of the doors and surrounding walls to hide them. */
846 if (opts & HIDDEN) 846 if (opts & HIDDEN)

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines