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.14 by pippijn, Sat Jan 6 14:42:30 2007 UTC vs.
Revision 1.21 by root, Thu Jan 18 19:42:10 2007 UTC

1
2/* 1/*
3 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
4 3 *
5 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
6 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
7 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
8 7 *
9 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
10 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
11 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version. 11 * (at your option) any later version.
13 12 *
14 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,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details. 16 * GNU General Public License for more details.
18 17 *
19 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
20 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 21 *
23 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
24*/ 23 */
25 24
26/* placing treasure in maps, where appropriate. */ 25/* placing treasure in maps, where appropriate. */
27
28
29 26
30#include <global.h> 27#include <global.h>
31#include <random_map.h> 28#include <random_map.h>
32#include <rproto.h> 29#include <rproto.h>
33 30
… …
49 46
50/* returns true if square x,y has P_NO_PASS set, which is true for walls 47/* returns true if square x,y has P_NO_PASS set, which is true for walls
51 * and doors but not monsters. 48 * and doors but not monsters.
52 * This function is not map tile aware. 49 * This function is not map tile aware.
53 */ 50 */
54
55int 51int
56wall_blocked (maptile *m, int x, int y) 52wall_blocked (maptile *m, int x, int y)
57{ 53{
58 int r;
59
60 if (OUT_OF_REAL_MAP (m, x, y)) 54 if (OUT_OF_REAL_MAP (m, x, y))
61 return 1; 55 return 1;
56
62 r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT; 57 int r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;
63 return r; 58 return r;
64} 59}
65 60
66/* place treasures in the map, given the 61/* place treasures in the map, given the
67map, (required) 62map, (required)
68layout, (required) 63layout, (required)
69treasure style (may be empty or NULL, or "none" to cause no treasure.) 64treasure style (may be empty or NULL, or "none" to cause no treasure.)
70treasureoptions (may be 0 for random choices or positive) 65treasureoptions (may be 0 for random choices or positive)
71*/ 66*/
72
73void 67void
74place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP) 68place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP)
75{ 69{
76 char styledirname[1024]; 70 char styledirname[1024];
77 char stylefilepath[1024]; 71 char stylefilepath[1024];
… …
86 treasureoptions = RANDOM () % (2 * LAST_OPTION); 80 treasureoptions = RANDOM () % (2 * LAST_OPTION);
87 81
88 /* filter out the mutually exclusive options */ 82 /* filter out the mutually exclusive options */
89 if ((treasureoptions & RICH) && (treasureoptions & SPARSE)) 83 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
90 { 84 {
91 if (RANDOM () % 2) 85 if (rndm (2))
92 treasureoptions -= 1; 86 treasureoptions -= 1;
93 else 87 else
94 treasureoptions -= 2; 88 treasureoptions -= 2;
95 } 89 }
96 90
… …
212 if (i == -1) 206 if (i == -1)
213 { 207 {
214 the_chest->destroy (); 208 the_chest->destroy ();
215 return NULL; 209 return NULL;
216 } 210 }
211
217 xl = x + freearr_x[i]; 212 xl = x + freearr_x[i];
218 yl = y + freearr_y[i]; 213 yl = y + freearr_y[i];
219 214
220 /* if the placement is blocked, return a fail. */ 215 /* if the placement is blocked, return a fail. */
221 if (wall_blocked (map, xl, yl)) 216 if (wall_blocked (map, xl, yl))
… …
332 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1. 327 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
333 328
334 The idea is that you call keyplace on x,y where a door is, and it'll make 329 The idea is that you call keyplace on x,y where a door is, and it'll make
335 sure a key is placed on both sides of the door. 330 sure a key is placed on both sides of the door.
336*/ 331*/
337
338int 332int
339keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP) 333keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
340{ 334{
341 int i, j; 335 int i, j;
342 int kx, ky; 336 int kx = 0, ky = 0;
343 object *the_keymaster; /* the monster that gets the key. */ 337 object *the_keymaster; /* the monster that gets the key. */
344 object *the_key; 338 object *the_key;
345 339
346 /* get a key and set its keycode */ 340 /* get a key and set its keycode */
347 the_key = get_archetype ("key2"); 341 the_key = get_archetype ("key2");
… …
349 343
350 if (door_flag == PASS_DOORS) 344 if (door_flag == PASS_DOORS)
351 { 345 {
352 int tries = 0; 346 int tries = 0;
353 347
354 the_keymaster = NULL; 348 the_keymaster = 0;
355 while (tries < 15 && the_keymaster == NULL) 349 while (tries < 15 && !the_keymaster)
356 { 350 {
357 i = (RANDOM () % (RP->Xsize - 2)) + 1; 351 i = (RANDOM () % (RP->Xsize - 2)) + 1;
358 j = (RANDOM () % (RP->Ysize - 2)) + 1; 352 j = (RANDOM () % (RP->Ysize - 2)) + 1;
359 tries++; 353 tries++;
360 the_keymaster = find_closest_monster (map, i, j, RP); 354 the_keymaster = find_closest_monster (map, i, j, RP);
361 } 355 }
356
362 /* if we don't find a good keymaster, drop the key on the ground. */ 357 /* if we don't find a good keymaster, drop the key on the ground. */
363 if (the_keymaster == NULL) 358 if (!the_keymaster)
364 { 359 {
365 int freeindex; 360 int freeindex;
366 361
367 freeindex = -1; 362 freeindex = -1;
368 for (tries = 0; tries < 15 && freeindex == -1; tries++) 363 for (tries = 0; tries < 15 && freeindex == -1; tries++)
369 { 364 {
370 kx = (RANDOM () % (RP->Xsize - 2)) + 1; 365 kx = (RANDOM () % (RP->Xsize - 2)) + 1;
371 ky = (RANDOM () % (RP->Ysize - 2)) + 1; 366 ky = (RANDOM () % (RP->Ysize - 2)) + 1;
372 freeindex = find_first_free_spot (the_key, map, kx, ky); 367 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
373 } 368 }
369
370 // can freeindex ever be < 0?
374 if (freeindex != -1) 371 if (freeindex >= 0)
375 { 372 {
376 kx += freearr_x[freeindex]; 373 kx += freearr_x [freeindex];
377 ky += freearr_y[freeindex]; 374 ky += freearr_y [freeindex];
378 } 375 }
379 } 376 }
380 } 377 }
381 else 378 else
382 { /* NO_PASS_DOORS --we have to work harder. */ 379 { /* NO_PASS_DOORS --we have to work harder. */
… …
384 NO_PASS_DOORS is set. */ 381 NO_PASS_DOORS is set. */
385 if (n_keys == 1) 382 if (n_keys == 1)
386 { 383 {
387 if (wall_blocked (map, x, y)) 384 if (wall_blocked (map, x, y))
388 return 0; 385 return 0;
386
389 the_keymaster = find_monster_in_room (map, x, y, RP); 387 the_keymaster = find_monster_in_room (map, x, y, RP);
390 if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */ 388 if (!the_keymaster) /* if fail, find a spot to drop the key. */
391 find_spot_in_room (map, x, y, &kx, &ky, RP); 389 find_spot_in_room (map, x, y, &kx, &ky, RP);
392 } 390 }
393 else 391 else
394 { 392 {
395 int sum = 0; /* count how many keys we actually place */ 393 int sum = 0; /* count how many keys we actually place */
… …
397 /* I'm lazy, so just try to place in all 4 directions. */ 395 /* I'm lazy, so just try to place in all 4 directions. */
398 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP); 396 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
399 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP); 397 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
400 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP); 398 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
401 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP); 399 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
400
402 if (sum < 2) /* we might have made a disconnected map-place more keys. */ 401 if (sum < 2) /* we might have made a disconnected map-place more keys. */
403 { /* diagnoally this time. */ 402 { /* diagonally this time. */
404 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 403 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
405 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 404 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
406 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 405 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
407 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 406 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
408 } 407 }
408
409 return 1; 409 return 1;
410 } 410 }
411 } 411 }
412 412
413 if (the_keymaster == NULL) 413 if (!the_keymaster)
414 { 414 {
415 the_key->x = kx; 415 the_key->x = kx;
416 the_key->y = ky; 416 the_key->y = ky;
417 insert_ob_in_map (the_key, map, NULL, 0); 417 insert_ob_in_map (the_key, map, NULL, 0);
418 return 1; 418 return 1;
… …
463 return theMonsterToFind; 463 return theMonsterToFind;
464 } 464 }
465 } 465 }
466 466
467 /* now search all the 8 squares around recursively for a monster,in random order */ 467 /* now search all the 8 squares around recursively for a monster,in random order */
468 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 468 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
469 { 469 {
470 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 470 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
471 if (theMonsterToFind != NULL) 471 if (theMonsterToFind != NULL)
472 return theMonsterToFind; 472 return theMonsterToFind;
473 } 473 }
… …
506 free (layout2); 506 free (layout2);
507 507
508 return theMonsterToFind; 508 return theMonsterToFind;
509} 509}
510 510
511
512
513
514/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */ 511/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
515int *room_free_spots_x; 512int *room_free_spots_x;
516int *room_free_spots_y; 513int *room_free_spots_y;
517int number_of_free_spots_in_room; 514int number_of_free_spots_in_room;
518 515
519/* the workhorse routine, which finds the free spots in a room: 516/* the workhorse routine, which finds the free spots in a room:
520a datastructure of free points is set up, and a position chosen from 517a datastructure of free points is set up, and a position chosen from
521that datastructure. */ 518that datastructure. */
522
523void 519void
524find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP) 520find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
525{ 521{
526 int i, j; 522 int i, j;
527 523
… …
538 /* check off this point */ 534 /* check off this point */
539 layout[x][y] = 1; 535 layout[x][y] = 1;
540 room_free_spots_x[number_of_free_spots_in_room] = x; 536 room_free_spots_x[number_of_free_spots_in_room] = x;
541 room_free_spots_y[number_of_free_spots_in_room] = y; 537 room_free_spots_y[number_of_free_spots_in_room] = y;
542 number_of_free_spots_in_room++; 538 number_of_free_spots_in_room++;
539
543 /* now search all the 8 squares around recursively for free spots,in random order */ 540 /* now search all the 8 squares around recursively for free spots,in random order */
544 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 541 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
545 {
546 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 542 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
547 }
548 543
549} 544}
550 545
551/* find a random non-blocked spot in this room to drop a key. */ 546/* find a random non-blocked spot in this room to drop a key. */
552void 547void
… …
563 /* allocate and copy the layout, converting C to 0. */ 558 /* allocate and copy the layout, converting C to 0. */
564 for (i = 0; i < RP->Xsize; i++) 559 for (i = 0; i < RP->Xsize; i++)
565 { 560 {
566 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize); 561 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
567 for (j = 0; j < RP->Ysize; j++) 562 for (j = 0; j < RP->Ysize; j++)
568 {
569 if (wall_blocked (map, i, j)) 563 if (wall_blocked (map, i, j))
570 layout2[i][j] = '#'; 564 layout2[i][j] = '#';
571 }
572 } 565 }
573 566
574 /* setup num_free_spots and room_free_spots */ 567 /* setup num_free_spots and room_free_spots */
575 find_spot_in_room_recursive (layout2, x, y, RP); 568 find_spot_in_room_recursive (layout2, x, y, RP);
576 569
… …
581 *ky = room_free_spots_y[i]; 574 *ky = room_free_spots_y[i];
582 } 575 }
583 576
584 /* deallocate the temp. layout */ 577 /* deallocate the temp. layout */
585 for (i = 0; i < RP->Xsize; i++) 578 for (i = 0; i < RP->Xsize; i++)
586 {
587 free (layout2[i]); 579 free (layout2[i]);
588 } 580
589 free (layout2); 581 free (layout2);
590 free (room_free_spots_x); 582 free (room_free_spots_x);
591 free (room_free_spots_y); 583 free (room_free_spots_y);
592} 584}
593 585
594 586
595/* searches the map for a spot with walls around it. The more 587/* searches the map for a spot with walls around it. The more
596 walls the better, but it'll settle for 1 wall, or even 0, but 588 walls the better, but it'll settle for 1 wall, or even 0, but
597 it'll return 0 if no FREE spots are found.*/ 589 it'll return 0 if no FREE spots are found.*/
598
599void 590void
600find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP) 591find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
601{ 592{
602 int x, y; 593 int x, y;
603 int i; 594 int i;
… …
654 *cy = ly; 645 *cy = ly;
655 return; 646 return;
656 } 647 }
657 } 648 }
658 /* give up and return the closest free spot. */ 649 /* give up and return the closest free spot. */
659 i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y); 650 i = find_free_spot (&archetype::find ("chest")->clone, map, x, y, 1, SIZEOFFREE1 + 1);
660 if (i != -1 && i <= SIZEOFFREE1) 651
652 if (i != -1)
661 { 653 {
662 *cx = x + freearr_x[i]; 654 *cx = x + freearr_x[i];
663 *cy = y + freearr_y[i]; 655 *cy = y + freearr_y[i];
664 return; 656 }
657 else
665 } 658 {
666 /* indicate failure */ 659 /* indicate failure */
660 *cx = -1;
667 *cx = *cy = -1; 661 *cy = -1;
662 }
668} 663}
669 664
670 665
671void 666void
672remove_monsters (int x, int y, maptile *map) 667remove_monsters (int x, int y, maptile *map)
… …
780 } 775 }
781 else 776 else
782 { 777 {
783 layout[x][y] = 1; 778 layout[x][y] = 1;
784 /* 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 */
785 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 780 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
786 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP); 781 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
787 } 782 }
788} 783}
789 784
790/* find a random non-blocked spot in this room to drop a key. */ 785/* find a random non-blocked spot in this room to drop a key. */

Diff Legend

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