src/rooms-vault.c

   1 #include "angband.h"\r
   2 #include "grid.h"\r
   3 #include "rooms.h"\r
   4 #include "generate.h"\r
   5 #include "trap.h"\r
   6 \r
   7 /*\r
   8 * This function creates a random vault that looks like a collection of bubbles.\r
   9 * It works by getting a set of coordinates that represent the center of each\r
  10 * bubble.  The entire room is made by seeing which bubble center is closest. If\r
  11 * two centers are equidistant then the square is a wall, otherwise it is a floor.\r
  12 * The only exception is for squares really near a center, these are always floor.\r
  13 * (It looks better than without this check.)\r
  14 *\r
  15 * Note: If two centers are on the same point then this algorithm will create a\r
  16 *       blank bubble filled with walls. - This is prevented from happening.\r
  17 */\r
  18 static void build_bubble_vault(int x0, int y0, int xsize, int ysize)\r
  19 {\r
  20 #define BUBBLENUM 10            /* number of bubbles */\r
  21 \r
  22         /* array of center points of bubbles */\r
  23         coord center[BUBBLENUM];\r
  24 \r
  25         int i, j, x, y;\r
  26         u16b min1, min2, temp;\r
  27         bool done;\r
  28 \r
  29         /* Offset from center to top left hand corner */\r
  30         int xhsize = xsize / 2;\r
  31         int yhsize = ysize / 2;\r
  32 \r
  33         msg_print_wizard(CHEAT_DUNGEON, _("\96A\8c^\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Room Vault."));\r
  34 \r
  35         /* Allocate center of bubbles */\r
  36         center[0].x = (byte)randint1(xsize - 3) + 1;\r
  37         center[0].y = (byte)randint1(ysize - 3) + 1;\r
  38 \r
  39         for (i = 1; i < BUBBLENUM; i++)\r
  40         {\r
  41                 done = FALSE;\r
  42 \r
  43                 /* get center and check to see if it is unique */\r
  44                 while (!done)\r
  45                 {\r
  46                         done = TRUE;\r
  47 \r
  48                         x = randint1(xsize - 3) + 1;\r
  49                         y = randint1(ysize - 3) + 1;\r
  50 \r
  51                         for (j = 0; j < i; j++)\r
  52                         {\r
  53                                 /* rough test to see if there is an overlap */\r
  54                                 if ((x == center[j].x) && (y == center[j].y)) done = FALSE;\r
  55                         }\r
  56                 }\r
  57 \r
  58                 center[i].x = (byte_hack)x;\r
  59                 center[i].y = (byte_hack)y;\r
  60         }\r
  61 \r
  62 \r
  63         /* Top and bottom boundaries */\r
  64         for (i = 0; i < xsize; i++)\r
  65         {\r
  66                 int side_x = x0 - xhsize + i;\r
  67 \r
  68                 place_outer_noperm_bold(y0 - yhsize + 0, side_x);\r
  69                 cave[y0 - yhsize + 0][side_x].info |= (CAVE_ROOM | CAVE_ICKY);\r
  70                 place_outer_noperm_bold(y0 - yhsize + ysize - 1, side_x);\r
  71                 cave[y0 - yhsize + ysize - 1][side_x].info |= (CAVE_ROOM | CAVE_ICKY);\r
  72         }\r
  73 \r
  74         /* Left and right boundaries */\r
  75         for (i = 1; i < ysize - 1; i++)\r
  76         {\r
  77                 int side_y = y0 - yhsize + i;\r
  78 \r
  79                 place_outer_noperm_bold(side_y, x0 - xhsize + 0);\r
  80                 cave[side_y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY);\r
  81                 place_outer_noperm_bold(side_y, x0 - xhsize + xsize - 1);\r
  82                 cave[side_y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY);\r
  83         }\r
  84 \r
  85         /* Fill in middle with bubbles */\r
  86         for (x = 1; x < xsize - 1; x++)\r
  87         {\r
  88                 for (y = 1; y < ysize - 1; y++)\r
  89                 {\r
  90                         /* Get distances to two closest centers */\r
  91 \r
  92                         /* initialize */\r
  93                         min1 = (u16b)distance(x, y, center[0].x, center[0].y);\r
  94                         min2 = (u16b)distance(x, y, center[1].x, center[1].y);\r
  95 \r
  96                         if (min1 > min2)\r
  97                         {\r
  98                                 /* swap if in wrong order */\r
  99                                 temp = min1;\r
 100                                 min1 = min2;\r
 101                                 min2 = temp;\r
 102                         }\r
 103 \r
 104                         /* Scan the rest */\r
 105                         for (i = 2; i < BUBBLENUM; i++)\r
 106                         {\r
 107                                 temp = (u16b)distance(x, y, center[i].x, center[i].y);\r
 108 \r
 109                                 if (temp < min1)\r
 110                                 {\r
 111                                         /* smallest */\r
 112                                         min2 = min1;\r
 113                                         min1 = temp;\r
 114                                 }\r
 115                                 else if (temp < min2)\r
 116                                 {\r
 117                                         /* second smallest */\r
 118                                         min2 = temp;\r
 119                                 }\r
 120                         }\r
 121                         if (((min2 - min1) <= 2) && (!(min1 < 3)))\r
 122                         {\r
 123                                 /* Boundary at midpoint+ not at inner region of bubble */\r
 124                                 place_outer_noperm_bold(y0 - yhsize + y, x0 - xhsize + x);\r
 125                         }\r
 126                         else\r
 127                         {\r
 128                                 /* middle of a bubble */\r
 129                                 place_floor_bold(y0 - yhsize + y, x0 - xhsize + x);\r
 130                         }\r
 131 \r
 132                         /* clean up rest of flags */\r
 133                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= (CAVE_ROOM | CAVE_ICKY);\r
 134                 }\r
 135         }\r
 136 \r
 137         /* Try to add some random doors */\r
 138         for (i = 0; i < 500; i++)\r
 139         {\r
 140                 x = randint1(xsize - 3) - xhsize + x0 + 1;\r
 141                 y = randint1(ysize - 3) - yhsize + y0 + 1;\r
 142                 add_door(x, y);\r
 143         }\r
 144 \r
 145         /* Fill with monsters and treasure, low difficulty */\r
 146         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5));\r
 147 }\r
 148 \r
 149 /* Create a random vault that looks like a collection of overlapping rooms */\r
 150 static void build_room_vault(int x0, int y0, int xsize, int ysize)\r
 151 {\r
 152         int i, x1, x2, y1, y2, xhsize, yhsize;\r
 153 \r
 154         /* get offset from center */\r
 155         xhsize = xsize / 2;\r
 156         yhsize = ysize / 2;\r
 157 \r
 158         msg_print_wizard(CHEAT_DUNGEON, _("\95\94\89®\8c^\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Room Vault."));\r
 159 \r
 160         /* fill area so don't get problems with arena levels */\r
 161         for (x1 = 0; x1 < xsize; x1++)\r
 162         {\r
 163                 int x = x0 - xhsize + x1;\r
 164 \r
 165                 for (y1 = 0; y1 < ysize; y1++)\r
 166                 {\r
 167                         int y = y0 - yhsize + y1;\r
 168 \r
 169                         place_extra_bold(y, x);\r
 170                         cave[y][x].info &= (~CAVE_ICKY);\r
 171                 }\r
 172         }\r
 173 \r
 174         /* add ten random rooms */\r
 175         for (i = 0; i < 10; i++)\r
 176         {\r
 177                 x1 = randint1(xhsize) * 2 + x0 - xhsize;\r
 178                 x2 = randint1(xhsize) * 2 + x0 - xhsize;\r
 179                 y1 = randint1(yhsize) * 2 + y0 - yhsize;\r
 180                 y2 = randint1(yhsize) * 2 + y0 - yhsize;\r
 181                 build_room(x1, x2, y1, y2);\r
 182         }\r
 183 \r
 184         /* Add some random doors */\r
 185         for (i = 0; i < 500; i++)\r
 186         {\r
 187                 x1 = randint1(xsize - 3) - xhsize + x0 + 1;\r
 188                 y1 = randint1(ysize - 3) - yhsize + y0 + 1;\r
 189                 add_door(x1, y1);\r
 190         }\r
 191 \r
 192         /* Fill with monsters and treasure, high difficulty */\r
 193         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5) + 5);\r
 194 }\r
 195 \r
 196 \r
 197 /* Create a random vault out of a fractal cave */\r
 198 static void build_cave_vault(int x0, int y0, int xsiz, int ysiz)\r
 199 {\r
 200         int grd, roug, cutoff, xhsize, yhsize, xsize, ysize, x, y;\r
 201         bool done, light, room;\r
 202 \r
 203         /* round to make sizes even */\r
 204         xhsize = xsiz / 2;\r
 205         yhsize = ysiz / 2;\r
 206         xsize = xhsize * 2;\r
 207         ysize = yhsize * 2;\r
 208 \r
 209         msg_print_wizard(CHEAT_DUNGEON, _("\93´\8c\8a\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Cave Vault."));\r
 210 \r
 211         light = done = FALSE;\r
 212         room = TRUE;\r
 213 \r
 214         while (!done)\r
 215         {\r
 216                 /* testing values for these parameters feel free to adjust */\r
 217                 grd = 1 << randint0(4);\r
 218 \r
 219                 /* want average of about 16 */\r
 220                 roug = randint1(8) * randint1(4);\r
 221 \r
 222                 /* about size/2 */\r
 223                 cutoff = randint1(xsize / 4) + randint1(ysize / 4) +\r
 224                         randint1(xsize / 4) + randint1(ysize / 4);\r
 225 \r
 226                 /* make it */\r
 227                 generate_hmap(y0, x0, xsize, ysize, grd, roug, cutoff);\r
 228 \r
 229                 /* Convert to normal format+ clean up */\r
 230                 done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room);\r
 231         }\r
 232 \r
 233         /* Set icky flag because is a vault */\r
 234         for (x = 0; x <= xsize; x++)\r
 235         {\r
 236                 for (y = 0; y <= ysize; y++)\r
 237                 {\r
 238                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;\r
 239                 }\r
 240         }\r
 241 \r
 242         /* Fill with monsters and treasure, low difficulty */\r
 243         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1, y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));\r
 244 }\r
 245 \r
 246 \r
 247 \r
 248 /*!\r
 249 * @brief Vault\92n\8c`\82ð\89ñ\93]\81A\8fã\89º\8d¶\89E\94½\93]\82·\82é\82½\82ß\82Ì\8dÀ\95W\95Ï\8a·\82ð\95Ô\82· / coordinate translation code\r
 250 * @param x \95Ï\8a·\82µ\82½\82¢\93_\82ÌX\8dÀ\95W\8eQ\8fÆ\83|\83C\83\93\83^\r
 251 * @param y \95Ï\8a·\82µ\82½\82¢\93_\82ÌY\8dÀ\95W\8eQ\8fÆ\83|\83C\83\93\83^\r
 252 * @param xoffset Vault\90¶\90¬\8e\9e\82Ì\8aî\8f\80X\8dÀ\95W\r
 253 * @param yoffset Vault\90¶\90¬\8e\9e\82Ì\8aî\8f\80Y\8dÀ\95W\r
 254 * @param transno \8f\88\97\9dID\r
 255 * @return \82È\82µ\r
 256 */\r
 257 static void coord_trans(POSITION *x, POSITION *y, POSITION xoffset, POSITION yoffset, int transno)\r
 258 {\r
 259         int i;\r
 260         int temp;\r
 261 \r
 262         /*\r
 263         * transno specifies what transformation is required. (0-7)\r
 264         * The lower two bits indicate by how much the vault is rotated,\r
 265         * and the upper bit indicates a reflection.\r
 266         * This is done by using rotation matrices... however since\r
 267         * these are mostly zeros for rotations by 90 degrees this can\r
 268         * be expressed simply in terms of swapping and inverting the\r
 269         * x and y coordinates.\r
 270         */\r
 271         for (i = 0; i < transno % 4; i++)\r
 272         {\r
 273                 /* rotate by 90 degrees */\r
 274                 temp = *x;\r
 275                 *x = -(*y);\r
 276                 *y = temp;\r
 277         }\r
 278 \r
 279         if (transno / 4)\r
 280         {\r
 281                 /* Reflect depending on status of 3rd bit. */\r
 282                 *x = -(*x);\r
 283         }\r
 284 \r
 285         /* Add offsets so vault stays in the first quadrant */\r
 286         *x += xoffset;\r
 287         *y += yoffset;\r
 288 }\r
 289 \r
 290 \r
 291 /*!\r
 292 * @brief Vault\82ð\83t\83\8d\83A\82É\94z\92u\82·\82é / Hack -- fill in "vault" rooms\r
 293 * @param yval \90¶\90¬\8aî\8f\80Y\8dÀ\95W\r
 294 * @param xval \90¶\90¬\8aî\8f\80X\8dÀ\95W\r
 295 * @param ymax Vault\82ÌY\83T\83C\83Y\r
 296 * @param xmax Vault\82ÌX\83T\83C\83Y\r
 297 * @param data Vault\82Ì\83f\81[\83^\95¶\8e\9a\97ñ\r
 298 * @param xoffset \95Ï\8a·\8aî\8f\80X\8dÀ\95W\r
 299 * @param yoffset \95Ï\8a·\8aî\8f\80Y\8dÀ\95W\r
 300 * @param transno \95Ï\8a·ID\r
 301 * @return \82È\82µ\r
 302 */\r
 303 static void build_vault(POSITION yval, POSITION xval, POSITION ymax, POSITION xmax, cptr data,\r
 304         POSITION xoffset, POSITION yoffset, int transno)\r
 305 {\r
 306         POSITION dx, dy, x, y, i, j;\r
 307         cptr t;\r
 308         cave_type *c_ptr;\r
 309 \r
 310         /* Place dungeon features and objects */\r
 311         for (t = data, dy = 0; dy < ymax; dy++)\r
 312         {\r
 313                 for (dx = 0; dx < xmax; dx++, t++)\r
 314                 {\r
 315                         /* prevent loop counter from being overwritten */\r
 316                         i = dx;\r
 317                         j = dy;\r
 318 \r
 319                         /* Flip / rotate */\r
 320                         coord_trans(&i, &j, xoffset, yoffset, transno);\r
 321 \r
 322                         /* Extract the location */\r
 323                         if (transno % 2 == 0)\r
 324                         {\r
 325                                 /* no swap of x/y */\r
 326                                 x = xval - (xmax / 2) + i;\r
 327                                 y = yval - (ymax / 2) + j;\r
 328                         }\r
 329                         else\r
 330                         {\r
 331                                 /* swap of x/y */\r
 332                                 x = xval - (ymax / 2) + i;\r
 333                                 y = yval - (xmax / 2) + j;\r
 334                         }\r
 335 \r
 336                         /* Hack -- skip "non-grids" */\r
 337                         if (*t == ' ') continue;\r
 338 \r
 339                         /* Access the grid */\r
 340                         c_ptr = &cave[y][x];\r
 341 \r
 342                         /* Lay down a floor */\r
 343                         place_floor_grid(c_ptr);\r
 344 \r
 345                         /* Remove any mimic */\r
 346                         c_ptr->mimic = 0;\r
 347 \r
 348                         /* Part of a vault */\r
 349                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);\r
 350 \r
 351                         /* Analyze the grid */\r
 352                         switch (*t)\r
 353                         {\r
 354                                 /* Granite wall (outer) */\r
 355                         case '%':\r
 356                                 place_outer_noperm_grid(c_ptr);\r
 357                                 break;\r
 358 \r
 359                                 /* Granite wall (inner) */\r
 360                         case '#':\r
 361                                 place_inner_grid(c_ptr);\r
 362                                 break;\r
 363 \r
 364                                 /* Glass wall (inner) */\r
 365                         case '$':\r
 366                                 place_inner_grid(c_ptr);\r
 367                                 c_ptr->feat = feat_glass_wall;\r
 368                                 break;\r
 369 \r
 370                                 /* Permanent wall (inner) */\r
 371                         case 'X':\r
 372                                 place_inner_perm_grid(c_ptr);\r
 373                                 break;\r
 374 \r
 375                                 /* Permanent glass wall (inner) */\r
 376                         case 'Y':\r
 377                                 place_inner_perm_grid(c_ptr);\r
 378                                 c_ptr->feat = feat_permanent_glass_wall;\r
 379                                 break;\r
 380 \r
 381                                 /* Treasure/trap */\r
 382                         case '*':\r
 383                                 if (randint0(100) < 75)\r
 384                                 {\r
 385                                         place_object(y, x, 0L);\r
 386                                 }\r
 387                                 else\r
 388                                 {\r
 389                                         place_trap(y, x);\r
 390                                 }\r
 391                                 break;\r
 392 \r
 393                                 /* Secret doors */\r
 394                         case '+':\r
 395                                 place_secret_door(y, x, DOOR_DEFAULT);\r
 396                                 break;\r
 397 \r
 398                                 /* Secret glass doors */\r
 399                         case '-':\r
 400                                 place_secret_door(y, x, DOOR_GLASS_DOOR);\r
 401                                 if (is_closed_door(c_ptr->feat)) c_ptr->mimic = feat_glass_wall;\r
 402                                 break;\r
 403 \r
 404                                 /* Curtains */\r
 405                         case '\'':\r
 406                                 place_secret_door(y, x, DOOR_CURTAIN);\r
 407                                 break;\r
 408 \r
 409                                 /* Trap */\r
 410                         case '^':\r
 411                                 place_trap(y, x);\r
 412                                 break;\r
 413 \r
 414                                 /* Black market in a dungeon */\r
 415                         case 'S':\r
 416                                 set_cave_feat(y, x, feat_black_market);\r
 417                                 store_init(NO_TOWN, STORE_BLACK);\r
 418                                 break;\r
 419 \r
 420                                 /* The Pattern */\r
 421                         case 'p':\r
 422                                 set_cave_feat(y, x, feat_pattern_start);\r
 423                                 break;\r
 424 \r
 425                         case 'a':\r
 426                                 set_cave_feat(y, x, feat_pattern_1);\r
 427                                 break;\r
 428 \r
 429                         case 'b':\r
 430                                 set_cave_feat(y, x, feat_pattern_2);\r
 431                                 break;\r
 432 \r
 433                         case 'c':\r
 434                                 set_cave_feat(y, x, feat_pattern_3);\r
 435                                 break;\r
 436 \r
 437                         case 'd':\r
 438                                 set_cave_feat(y, x, feat_pattern_4);\r
 439                                 break;\r
 440 \r
 441                         case 'P':\r
 442                                 set_cave_feat(y, x, feat_pattern_end);\r
 443                                 break;\r
 444 \r
 445                         case 'B':\r
 446                                 set_cave_feat(y, x, feat_pattern_exit);\r
 447                                 break;\r
 448 \r
 449                         case 'A':\r
 450                                 /* Reward for Pattern walk */\r
 451                                 object_level = base_level + 12;\r
 452                                 place_object(y, x, AM_GOOD | AM_GREAT);\r
 453                                 object_level = base_level;\r
 454                                 break;\r
 455 \r
 456                         case '~':\r
 457                                 set_cave_feat(y, x, feat_shallow_water);\r
 458                                 break;\r
 459 \r
 460                         case '=':\r
 461                                 set_cave_feat(y, x, feat_deep_water);\r
 462                                 break;\r
 463 \r
 464                         case 'v':\r
 465                                 set_cave_feat(y, x, feat_shallow_lava);\r
 466                                 break;\r
 467 \r
 468                         case 'w':\r
 469                                 set_cave_feat(y, x, feat_deep_lava);\r
 470                                 break;\r
 471 \r
 472                         }\r
 473                 }\r
 474         }\r
 475 \r
 476 \r
 477         /* Place dungeon monsters and objects */\r
 478         for (t = data, dy = 0; dy < ymax; dy++)\r
 479         {\r
 480                 for (dx = 0; dx < xmax; dx++, t++)\r
 481                 {\r
 482                         /* prevent loop counter from being overwritten */\r
 483                         i = dx;\r
 484                         j = dy;\r
 485 \r
 486                         /* Flip / rotate */\r
 487                         coord_trans(&i, &j, xoffset, yoffset, transno);\r
 488 \r
 489                         /* Extract the location */\r
 490                         if (transno % 2 == 0)\r
 491                         {\r
 492                                 /* no swap of x/y */\r
 493                                 x = xval - (xmax / 2) + i;\r
 494                                 y = yval - (ymax / 2) + j;\r
 495                         }\r
 496                         else\r
 497                         {\r
 498                                 /* swap of x/y */\r
 499                                 x = xval - (ymax / 2) + i;\r
 500                                 y = yval - (xmax / 2) + j;\r
 501                         }\r
 502 \r
 503                         /* Hack -- skip "non-grids" */\r
 504                         if (*t == ' ') continue;\r
 505 \r
 506                         /* Analyze the symbol */\r
 507                         switch (*t)\r
 508                         {\r
 509                                 /* Monster */\r
 510                         case '&':\r
 511                         {\r
 512                                 monster_level = base_level + 5;\r
 513                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));\r
 514                                 monster_level = base_level;\r
 515                                 break;\r
 516                         }\r
 517 \r
 518                         /* Meaner monster */\r
 519                         case '@':\r
 520                         {\r
 521                                 monster_level = base_level + 11;\r
 522                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));\r
 523                                 monster_level = base_level;\r
 524                                 break;\r
 525                         }\r
 526 \r
 527                         /* Meaner monster, plus treasure */\r
 528                         case '9':\r
 529                         {\r
 530                                 monster_level = base_level + 9;\r
 531                                 place_monster(y, x, PM_ALLOW_SLEEP);\r
 532                                 monster_level = base_level;\r
 533                                 object_level = base_level + 7;\r
 534                                 place_object(y, x, AM_GOOD);\r
 535                                 object_level = base_level;\r
 536                                 break;\r
 537                         }\r
 538 \r
 539                         /* Nasty monster and treasure */\r
 540                         case '8':\r
 541                         {\r
 542                                 monster_level = base_level + 40;\r
 543                                 place_monster(y, x, PM_ALLOW_SLEEP);\r
 544                                 monster_level = base_level;\r
 545                                 object_level = base_level + 20;\r
 546                                 place_object(y, x, AM_GOOD | AM_GREAT);\r
 547                                 object_level = base_level;\r
 548                                 break;\r
 549                         }\r
 550 \r
 551                         /* Monster and/or object */\r
 552                         case ',':\r
 553                         {\r
 554                                 if (randint0(100) < 50)\r
 555                                 {\r
 556                                         monster_level = base_level + 3;\r
 557                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));\r
 558                                         monster_level = base_level;\r
 559                                 }\r
 560                                 if (randint0(100) < 50)\r
 561                                 {\r
 562                                         object_level = base_level + 7;\r
 563                                         place_object(y, x, 0L);\r
 564                                         object_level = base_level;\r
 565                                 }\r
 566                                 break;\r
 567                         }\r
 568 \r
 569                         }\r
 570                 }\r
 571         }\r
 572 }\r
 573 \r
 574 \r
 575 \r
 576 /*!\r
 577 * @brief \83^\83C\83v7\82Ì\95\94\89®\81cv_info.txt\82æ\82è\8f¬\8c^vault\82ð\90¶\90¬\82·\82é / Type 7 -- simple vaults (see "v_info.txt")\r
 578 * @return \82È\82µ\r
 579 */\r
 580 bool build_type7(void)\r
 581 {\r
 582         vault_type *v_ptr = NULL;\r
 583         int dummy;\r
 584         POSITION x, y;\r
 585         POSITION xval, yval;\r
 586         POSITION xoffset, yoffset;\r
 587         int transno;\r
 588 \r
 589         /* Pick a lesser vault */\r
 590         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)\r
 591         {\r
 592                 /* Access a random vault record */\r
 593                 v_ptr = &v_info[randint0(max_v_idx)];\r
 594 \r
 595                 /* Accept the first lesser vault */\r
 596                 if (v_ptr->typ == 7) break;\r
 597         }\r
 598 \r
 599         /* No lesser vault found */\r
 600         if (dummy >= SAFE_MAX_ATTEMPTS)\r
 601         {\r
 602                 msg_print_wizard(CHEAT_DUNGEON, _("\8f¬\8c^\8cÅ\92èVault\82ð\94z\92u\82Å\82«\82Ü\82¹\82ñ\82Å\82µ\82½\81B", "Could not place lesser vault."));\r
 603                 return FALSE;\r
 604         }\r
 605 \r
 606         /* pick type of transformation (0-7) */\r
 607         transno = randint0(8);\r
 608 \r
 609         /* calculate offsets */\r
 610         x = v_ptr->wid;\r
 611         y = v_ptr->hgt;\r
 612 \r
 613         /* Some huge vault cannot be ratated to fit in the dungeon */\r
 614         if (x + 2 > cur_hgt - 2)\r
 615         {\r
 616                 /* Forbid 90 or 270 degree ratation */\r
 617                 transno &= ~1;\r
 618         }\r
 619 \r
 620         coord_trans(&x, &y, 0, 0, transno);\r
 621 \r
 622         if (x < 0)\r
 623         {\r
 624                 xoffset = -x - 1;\r
 625         }\r
 626         else\r
 627         {\r
 628                 xoffset = 0;\r
 629         }\r
 630 \r
 631         if (y < 0)\r
 632         {\r
 633                 yoffset = -y - 1;\r
 634         }\r
 635         else\r
 636         {\r
 637                 yoffset = 0;\r
 638         }\r
 639 \r
 640         /* Find and reserve some space in the dungeon.  Get center of room. */\r
 641         if (!find_space(&yval, &xval, abs(y), abs(x))) return FALSE;\r
 642 \r
 643 #ifdef FORCE_V_IDX\r
 644         v_ptr = &v_info[2];\r
 645 #endif\r
 646 \r
 647         /* Message */\r
 648         msg_format_wizard(CHEAT_DUNGEON, _("\8f¬\8c^Vault(%s)\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Lesser vault (%s)."), v_name + v_ptr->name);\r
 649 \r
 650         /* Hack -- Build the vault */\r
 651         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,\r
 652                 v_text + v_ptr->text, xoffset, yoffset, transno);\r
 653 \r
 654         return TRUE;\r
 655 }\r
 656 \r
 657 /*!\r
 658 * @brief \83^\83C\83v8\82Ì\95\94\89®\81cv_info.txt\82æ\82è\91å\8c^vault\82ð\90¶\90¬\82·\82é / Type 8 -- greater vaults (see "v_info.txt")\r
 659 * @return \82È\82µ\r
 660 */\r
 661 bool build_type8(void)\r
 662 {\r
 663         vault_type *v_ptr;\r
 664         int dummy;\r
 665         POSITION xval, yval;\r
 666         POSITION x, y;\r
 667         int transno;\r
 668         int xoffset, yoffset;\r
 669 \r
 670         /* Pick a greater vault */\r
 671         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)\r
 672         {\r
 673                 /* Access a random vault record */\r
 674                 v_ptr = &v_info[randint0(max_v_idx)];\r
 675 \r
 676                 /* Accept the first greater vault */\r
 677                 if (v_ptr->typ == 8) break;\r
 678         }\r
 679 \r
 680         /* No greater vault found */\r
 681         if (dummy >= SAFE_MAX_ATTEMPTS)\r
 682         {\r
 683                 msg_print_wizard(CHEAT_DUNGEON, _("\91å\8c^\8cÅ\92èVault\82ð\94z\92u\82Å\82«\82Ü\82¹\82ñ\82Å\82µ\82½\81B", "Could not place greater vault."));\r
 684                 return FALSE;\r
 685         }\r
 686 \r
 687         /* pick type of transformation (0-7) */\r
 688         transno = randint0(8);\r
 689 \r
 690         /* calculate offsets */\r
 691         x = v_ptr->wid;\r
 692         y = v_ptr->hgt;\r
 693 \r
 694         /* Some huge vault cannot be ratated to fit in the dungeon */\r
 695         if (x + 2 > cur_hgt - 2)\r
 696         {\r
 697                 /* Forbid 90 or 270 degree ratation */\r
 698                 transno &= ~1;\r
 699         }\r
 700 \r
 701         coord_trans(&x, &y, 0, 0, transno);\r
 702 \r
 703         if (x < 0)\r
 704         {\r
 705                 xoffset = -x - 1;\r
 706         }\r
 707         else\r
 708         {\r
 709                 xoffset = 0;\r
 710         }\r
 711 \r
 712         if (y < 0)\r
 713         {\r
 714                 yoffset = -y - 1;\r
 715         }\r
 716         else\r
 717         {\r
 718                 yoffset = 0;\r
 719         }\r
 720 \r
 721         /*\r
 722         * Try to allocate space for room.  If fails, exit\r
 723         *\r
 724         * Hack -- Prepare a bit larger space (+2, +2) to\r
 725         * prevent generation of vaults with no-entrance.\r
 726         */\r
 727         /* Find and reserve some space in the dungeon.  Get center of room. */\r
 728         if (!find_space(&yval, &xval, (POSITION)(abs(y) + 2), (POSITION)(abs(x) + 2))) return FALSE;\r
 729 \r
 730 #ifdef FORCE_V_IDX\r
 731         v_ptr = &v_info[76 + randint1(3)];\r
 732 #endif\r
 733 \r
 734         msg_format_wizard(CHEAT_DUNGEON, _("\91å\8c^\8cÅ\92èVault(%s)\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Greater vault (%s)."), v_name + v_ptr->name);\r
 735 \r
 736         /* Hack -- Build the vault */\r
 737         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,\r
 738                 v_text + v_ptr->text, xoffset, yoffset, transno);\r
 739 \r
 740         return TRUE;\r
 741 }\r
 742 \r
 743 \r
 744 /*\r
 745 * Build target vault.\r
 746 * This is made by two concentric "crypts" with perpendicular\r
 747 * walls creating the cross-hairs.\r
 748 */\r
 749 static void build_target_vault(int x0, int y0, int xsize, int ysize)\r
 750 {\r
 751         int rad, x, y;\r
 752 \r
 753         /* Make a random metric */\r
 754         int h1, h2, h3, h4;\r
 755         h1 = randint1(32) - 16;\r
 756         h2 = randint1(16);\r
 757         h3 = randint1(32);\r
 758         h4 = randint1(32) - 16;\r
 759 \r
 760         msg_print_wizard(CHEAT_DUNGEON, _("\91Î\8fÌ\8c`\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Elemental Vault"));\r
 761 \r
 762         /* work out outer radius */\r
 763         if (xsize > ysize)\r
 764         {\r
 765                 rad = ysize / 2;\r
 766         }\r
 767         else\r
 768         {\r
 769                 rad = xsize / 2;\r
 770         }\r
 771 \r
 772         /* Make floor */\r
 773         for (x = x0 - rad; x <= x0 + rad; x++)\r
 774         {\r
 775                 for (y = y0 - rad; y <= y0 + rad; y++)\r
 776                 {\r
 777                         /* clear room flag */\r
 778                         cave[y][x].info &= ~(CAVE_ROOM);\r
 779 \r
 780                         /* Vault - so is "icky" */\r
 781                         cave[y][x].info |= CAVE_ICKY;\r
 782 \r
 783                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)\r
 784                         {\r
 785                                 /* inside- so is floor */\r
 786                                 place_floor_bold(y, x);\r
 787                         }\r
 788                         else\r
 789                         {\r
 790                                 /* make granite outside so arena works */\r
 791                                 place_extra_bold(y, x);\r
 792                         }\r
 793 \r
 794                         /* proper boundary for arena */\r
 795                         if (((y + rad) == y0) || ((y - rad) == y0) ||\r
 796                                 ((x + rad) == x0) || ((x - rad) == x0))\r
 797                         {\r
 798                                 place_extra_bold(y, x);\r
 799                         }\r
 800                 }\r
 801         }\r
 802 \r
 803         /* Find visible outer walls and set to be FEAT_OUTER */\r
 804         add_outer_wall(x0, y0, FALSE, x0 - rad - 1, y0 - rad - 1,\r
 805                 x0 + rad + 1, y0 + rad + 1);\r
 806 \r
 807         /* Add inner wall */\r
 808         for (x = x0 - rad / 2; x <= x0 + rad / 2; x++)\r
 809         {\r
 810                 for (y = y0 - rad / 2; y <= y0 + rad / 2; y++)\r
 811                 {\r
 812                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) == rad / 2)\r
 813                         {\r
 814                                 /* Make an internal wall */\r
 815                                 place_inner_bold(y, x);\r
 816                         }\r
 817                 }\r
 818         }\r
 819 \r
 820         /* Add perpendicular walls */\r
 821         for (x = x0 - rad; x <= x0 + rad; x++)\r
 822         {\r
 823                 place_inner_bold(y0, x);\r
 824         }\r
 825 \r
 826         for (y = y0 - rad; y <= y0 + rad; y++)\r
 827         {\r
 828                 place_inner_bold(y, x0);\r
 829         }\r
 830 \r
 831         /* Make inner vault */\r
 832         for (y = y0 - 1; y <= y0 + 1; y++)\r
 833         {\r
 834                 place_inner_bold(y, x0 - 1);\r
 835                 place_inner_bold(y, x0 + 1);\r
 836         }\r
 837         for (x = x0 - 1; x <= x0 + 1; x++)\r
 838         {\r
 839                 place_inner_bold(y0 - 1, x);\r
 840                 place_inner_bold(y0 + 1, x);\r
 841         }\r
 842 \r
 843         place_floor_bold(y0, x0);\r
 844 \r
 845 \r
 846         /* Add doors to vault */\r
 847         /* get two distances so can place doors relative to centre */\r
 848         x = (rad - 2) / 4 + 1;\r
 849         y = rad / 2 + x;\r
 850 \r
 851         add_door(x0 + x, y0);\r
 852         add_door(x0 + y, y0);\r
 853         add_door(x0 - x, y0);\r
 854         add_door(x0 - y, y0);\r
 855         add_door(x0, y0 + x);\r
 856         add_door(x0, y0 + y);\r
 857         add_door(x0, y0 - x);\r
 858         add_door(x0, y0 - y);\r
 859 \r
 860         /* Fill with stuff - medium difficulty */\r
 861         fill_treasure(x0 - rad, x0 + rad, y0 - rad, y0 + rad, randint1(3) + 3);\r
 862 }\r
 863 \r
 864 \r
 865 #ifdef ALLOW_CAVERNS_AND_LAKES\r
 866 /*\r
 867 * This routine uses a modified version of the lake code to make a\r
 868 * distribution of some terrain type over the vault.  This type\r
 869 * depends on the dungeon depth.\r
 870 *\r
 871 * Miniture rooms are then scattered across the vault.\r
 872 */\r
 873 static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz)\r
 874 {\r
 875         int grd, roug;\r
 876         int c1, c2, c3;\r
 877         bool done = FALSE;\r
 878         int xsize, ysize, xhsize, yhsize, x, y, i;\r
 879         int type;\r
 880 \r
 881         msg_print_wizard(CHEAT_DUNGEON, _("\90¸\97ì\8aE\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Elemental Vault"));\r
 882 \r
 883         /* round to make sizes even */\r
 884         xhsize = xsiz / 2;\r
 885         yhsize = ysiz / 2;\r
 886         xsize = xhsize * 2;\r
 887         ysize = yhsize * 2;\r
 888 \r
 889         if (dun_level < 25)\r
 890         {\r
 891                 /* Earth vault  (Rubble) */\r
 892                 type = LAKE_T_EARTH_VAULT;\r
 893         }\r
 894         else if (dun_level < 50)\r
 895         {\r
 896                 /* Air vault (Trees) */\r
 897                 type = LAKE_T_AIR_VAULT;\r
 898         }\r
 899         else if (dun_level < 75)\r
 900         {\r
 901                 /* Water vault (shallow water) */\r
 902                 type = LAKE_T_WATER_VAULT;\r
 903         }\r
 904         else\r
 905         {\r
 906                 /* Fire vault (shallow lava) */\r
 907                 type = LAKE_T_FIRE_VAULT;\r
 908         }\r
 909 \r
 910         while (!done)\r
 911         {\r
 912                 /* testing values for these parameters: feel free to adjust */\r
 913                 grd = 1 << (randint0(3));\r
 914 \r
 915                 /* want average of about 16 */\r
 916                 roug = randint1(8) * randint1(4);\r
 917 \r
 918                 /* Make up size of various componants */\r
 919                 /* Floor */\r
 920                 c3 = 2 * xsize / 3;\r
 921 \r
 922                 /* Deep water/lava */\r
 923                 c1 = randint0(c3 / 2) + randint0(c3 / 2) - 5;\r
 924 \r
 925                 /* Shallow boundary */\r
 926                 c2 = (c1 + c3) / 2;\r
 927 \r
 928                 /* make it */\r
 929                 generate_hmap(y0, x0, xsize, ysize, grd, roug, c3);\r
 930 \r
 931                 /* Convert to normal format+ clean up */\r
 932                 done = generate_lake(y0, x0, xsize, ysize, c1, c2, c3, type);\r
 933         }\r
 934 \r
 935         /* Set icky flag because is a vault */\r
 936         for (x = 0; x <= xsize; x++)\r
 937         {\r
 938                 for (y = 0; y <= ysize; y++)\r
 939                 {\r
 940                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;\r
 941                 }\r
 942         }\r
 943 \r
 944         /* make a few rooms in the vault */\r
 945         for (i = 1; i <= (xsize * ysize) / 50; i++)\r
 946         {\r
 947                 build_small_room(x0 + randint0(xsize - 4) - xsize / 2 + 2,\r
 948                         y0 + randint0(ysize - 4) - ysize / 2 + 2);\r
 949         }\r
 950 \r
 951         /* Fill with monsters and treasure, low difficulty */\r
 952         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1,\r
 953                 y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));\r
 954 }\r
 955 #endif /* ALLOW_CAVERNS_AND_LAKES */\r
 956 \r
 957 \r
 958 /* Build a "mini" checkerboard vault\r
 959 *\r
 960 * This is done by making a permanent wall maze and setting\r
 961 * the diagonal sqaures of the checker board to be granite.\r
 962 * The vault has two entrances on opposite sides to guarantee\r
 963 * a way to get in even if the vault abuts a side of the dungeon.\r
 964 */\r
 965 static void build_mini_c_vault(int x0, int y0, int xsize, int ysize)\r
 966 {\r
 967         int dy, dx;\r
 968         int y1, x1, y2, x2, y, x, total;\r
 969         int m, n, num_vertices;\r
 970         int *visited;\r
 971 \r
 972         msg_print_wizard(CHEAT_DUNGEON, _("\8f¬\8c^\83`\83F\83b\83J\81[\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Mini Checker Board Vault."));\r
 973 \r
 974         /* Pick a random room size */\r
 975         dy = ysize / 2 - 1;\r
 976         dx = xsize / 2 - 1;\r
 977 \r
 978         y1 = y0 - dy;\r
 979         x1 = x0 - dx;\r
 980         y2 = y0 + dy;\r
 981         x2 = x0 + dx;\r
 982 \r
 983 \r
 984         /* generate the room */\r
 985         for (x = x1 - 2; x <= x2 + 2; x++)\r
 986         {\r
 987                 if (!in_bounds(y1 - 2, x)) break;\r
 988 \r
 989                 cave[y1 - 2][x].info |= (CAVE_ROOM | CAVE_ICKY);\r
 990 \r
 991                 place_outer_noperm_bold(y1 - 2, x);\r
 992         }\r
 993 \r
 994         for (x = x1 - 2; x <= x2 + 2; x++)\r
 995         {\r
 996                 if (!in_bounds(y2 + 2, x)) break;\r
 997 \r
 998                 cave[y2 + 2][x].info |= (CAVE_ROOM | CAVE_ICKY);\r
 999 \r
1000                 place_outer_noperm_bold(y2 + 2, x);\r
1001         }\r
1002 \r
1003         for (y = y1 - 2; y <= y2 + 2; y++)\r
1004         {\r
1005                 if (!in_bounds(y, x1 - 2)) break;\r
1006 \r
1007                 cave[y][x1 - 2].info |= (CAVE_ROOM | CAVE_ICKY);\r
1008 \r
1009                 place_outer_noperm_bold(y, x1 - 2);\r
1010         }\r
1011 \r
1012         for (y = y1 - 2; y <= y2 + 2; y++)\r
1013         {\r
1014                 if (!in_bounds(y, x2 + 2)) break;\r
1015 \r
1016                 cave[y][x2 + 2].info |= (CAVE_ROOM | CAVE_ICKY);\r
1017 \r
1018                 place_outer_noperm_bold(y, x2 + 2);\r
1019         }\r
1020 \r
1021         for (y = y1 - 1; y <= y2 + 1; y++)\r
1022         {\r
1023                 for (x = x1 - 1; x <= x2 + 1; x++)\r
1024                 {\r
1025                         cave_type *c_ptr = &cave[y][x];\r
1026 \r
1027                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);\r
1028 \r
1029                         /* Permanent walls */\r
1030                         place_inner_perm_grid(c_ptr);\r
1031                 }\r
1032         }\r
1033 \r
1034 \r
1035         /* dimensions of vertex array */\r
1036         m = dx + 1;\r
1037         n = dy + 1;\r
1038         num_vertices = m * n;\r
1039 \r
1040         /* initialize array of visited vertices */\r
1041         C_MAKE(visited, num_vertices, int);\r
1042 \r
1043         /* traverse the graph to create a spannng tree, pick a random root */\r
1044         r_visit(y1, x1, y2, x2, randint0(num_vertices), 0, visited);\r
1045 \r
1046         /* Make it look like a checker board vault */\r
1047         for (x = x1; x <= x2; x++)\r
1048         {\r
1049                 for (y = y1; y <= y2; y++)\r
1050                 {\r
1051                         total = x - x1 + y - y1;\r
1052                         /* If total is odd- and is a floor then make a wall */\r
1053                         if ((total % 2 == 1) && is_floor_bold(y, x))\r
1054                         {\r
1055                                 place_inner_bold(y, x);\r
1056                         }\r
1057                 }\r
1058         }\r
1059 \r
1060         /* Make a couple of entrances */\r
1061         if (one_in_(2))\r
1062         {\r
1063                 /* left and right */\r
1064                 y = randint1(dy) + dy / 2;\r
1065                 place_inner_bold(y1 + y, x1 - 1);\r
1066                 place_inner_bold(y1 + y, x2 + 1);\r
1067         }\r
1068         else\r
1069         {\r
1070                 /* top and bottom */\r
1071                 x = randint1(dx) + dx / 2;\r
1072                 place_inner_bold(y1 - 1, x1 + x);\r
1073                 place_inner_bold(y2 + 1, x1 + x);\r
1074         }\r
1075 \r
1076         /* Fill with monsters and treasure, highest difficulty */\r
1077         fill_treasure(x1, x2, y1, y2, 10);\r
1078 \r
1079         C_KILL(visited, num_vertices, int);\r
1080 }\r
1081 \r
1082 /* Build a castle */\r
1083 /* Driver routine: clear the region and call the recursive\r
1084 * room routine.\r
1085 *\r
1086 *This makes a vault that looks like a castle/ city in the dungeon.\r
1087 */\r
1088 static void build_castle_vault(int x0, int y0, int xsize, int ysize)\r
1089 {\r
1090         int dy, dx;\r
1091         int y1, x1, y2, x2;\r
1092         int y, x;\r
1093 \r
1094         /* Pick a random room size */\r
1095         dy = ysize / 2 - 1;\r
1096         dx = xsize / 2 - 1;\r
1097 \r
1098         y1 = y0 - dy;\r
1099         x1 = x0 - dx;\r
1100         y2 = y0 + dy;\r
1101         x2 = x0 + dx;\r
1102 \r
1103         msg_print_wizard(CHEAT_DUNGEON, _("\8fé\8c^\83\89\83\93\83_\83\80Vault\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Castle Vault"));\r
1104 \r
1105         /* generate the room */\r
1106         for (y = y1 - 1; y <= y2 + 1; y++)\r
1107         {\r
1108                 for (x = x1 - 1; x <= x2 + 1; x++)\r
1109                 {\r
1110                         cave[y][x].info |= (CAVE_ROOM | CAVE_ICKY);\r
1111                         /* Make everything a floor */\r
1112                         place_floor_bold(y, x);\r
1113                 }\r
1114         }\r
1115 \r
1116         /* Make the castle */\r
1117         build_recursive_room(x1, y1, x2, y2, randint1(5));\r
1118 \r
1119         /* Fill with monsters and treasure, low difficulty */\r
1120         fill_treasure(x1, x2, y1, y2, randint1(3));\r
1121 }\r
1122 \r
1123 \r
1124 \r
1125 /*!\r
1126 * @brief \83^\83C\83v10\82Ì\95\94\89®\81c\83\89\83\93\83_\83\80\90¶\90¬vault / Type 10 -- Random vaults\r
1127 * @return \82È\82µ\r
1128 */\r
1129 bool build_type10(void)\r
1130 {\r
1131         POSITION y0, x0, xsize, ysize, vtype;\r
1132 \r
1133         /* Get size */\r
1134         /* big enough to look good, small enough to be fairly common. */\r
1135         xsize = randint1(22) + 22;\r
1136         ysize = randint1(11) + 11;\r
1137 \r
1138         /* Find and reserve some space in the dungeon.  Get center of room. */\r
1139         if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) return FALSE;\r
1140 \r
1141         /* Select type of vault */\r
1142 #ifdef ALLOW_CAVERNS_AND_LAKES\r
1143         do\r
1144         {\r
1145                 vtype = randint1(15);\r
1146         } while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) &&\r
1147                 ((vtype == 1) || (vtype == 3) || (vtype == 8) || (vtype == 9) || (vtype == 11)));\r
1148 #else /* ALLOW_CAVERNS_AND_LAKES */\r
1149         do\r
1150         {\r
1151                 vtype = randint1(7);\r
1152         } while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) &&\r
1153                 ((vtype == 1) || (vtype == 3)));\r
1154 #endif /* ALLOW_CAVERNS_AND_LAKES */\r
1155 \r
1156         switch (vtype)\r
1157         {\r
1158                 /* Build an appropriate room */\r
1159         case 1: case  9: build_bubble_vault(x0, y0, xsize, ysize); break;\r
1160         case 2: case 10: build_room_vault(x0, y0, xsize, ysize); break;\r
1161         case 3: case 11: build_cave_vault(x0, y0, xsize, ysize); break;\r
1162         case 4: case 12: build_maze_vault(x0, y0, xsize, ysize, TRUE); break;\r
1163         case 5: case 13: build_mini_c_vault(x0, y0, xsize, ysize); break;\r
1164         case 6: case 14: build_castle_vault(x0, y0, xsize, ysize); break;\r
1165         case 7: case 15: build_target_vault(x0, y0, xsize, ysize); break;\r
1166 #ifdef ALLOW_CAVERNS_AND_LAKES\r
1167         case 8: build_elemental_vault(x0, y0, xsize, ysize); break;\r
1168 #endif /* ALLOW_CAVERNS_AND_LAKES */\r
1169                 /* I know how to add a few more... give me some time. */\r
1170 \r
1171                 /* Paranoia */\r
1172         default: return FALSE;\r
1173         }\r
1174 \r
1175         return TRUE;\r
1176 }\r
1177 \r
1178 \r
1179 /*!\r
1180 * @brief \83^\83C\83v16\82Ì\95\94\89®\81cv_info.txt\82æ\82è\8cÅ\92è\93Á\8eê\95\94\89®\82ð\90¶\90¬\82·\82é / Type 16 -- fixed special room (see "v_info.txt")\r
1181 * @return \82È\82µ\r
1182 */\r
1183 bool build_type17(void)\r
1184 {\r
1185         vault_type *v_ptr = NULL;\r
1186         int dummy;\r
1187         POSITION x, y;\r
1188         POSITION xval, yval;\r
1189         POSITION xoffset, yoffset;\r
1190         int transno;\r
1191 \r
1192         /* Pick a lesser vault */\r
1193         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)\r
1194         {\r
1195                 /* Access a random vault record */\r
1196                 v_ptr = &v_info[randint0(max_v_idx)];\r
1197 \r
1198                 /* Accept the first lesser vault */\r
1199                 if (v_ptr->typ == 16) break;\r
1200         }\r
1201 \r
1202         /* No lesser vault found */\r
1203         if (dummy >= SAFE_MAX_ATTEMPTS)\r
1204         {\r
1205                 msg_print_wizard(CHEAT_DUNGEON, _("\8cÅ\92è\93Á\8eê\95\94\89®\82ð\94z\92u\82Å\82«\82Ü\82¹\82ñ\82Å\82µ\82½\81B", "Could not place fixed special room."));\r
1206                 return FALSE;\r
1207         }\r
1208 \r
1209         /* pick type of transformation (0-7) */\r
1210         transno = randint0(8);\r
1211 \r
1212         /* calculate offsets */\r
1213         x = v_ptr->wid;\r
1214         y = v_ptr->hgt;\r
1215 \r
1216         /* Some huge vault cannot be ratated to fit in the dungeon */\r
1217         if (x + 2 > cur_hgt - 2)\r
1218         {\r
1219                 /* Forbid 90 or 270 degree ratation */\r
1220                 transno &= ~1;\r
1221         }\r
1222 \r
1223         coord_trans(&x, &y, 0, 0, transno);\r
1224 \r
1225         if (x < 0)\r
1226         {\r
1227                 xoffset = -x - 1;\r
1228         }\r
1229         else\r
1230         {\r
1231                 xoffset = 0;\r
1232         }\r
1233 \r
1234         if (y < 0)\r
1235         {\r
1236                 yoffset = -y - 1;\r
1237         }\r
1238         else\r
1239         {\r
1240                 yoffset = 0;\r
1241         }\r
1242 \r
1243         /* Find and reserve some space in the dungeon.  Get center of room. */\r
1244         if (!find_space(&yval, &xval, abs(y), abs(x))) return FALSE;\r
1245 \r
1246 #ifdef FORCE_V_IDX\r
1247         v_ptr = &v_info[2];\r
1248 #endif\r
1249 \r
1250         /* Message */\r
1251         msg_format_wizard(CHEAT_DUNGEON, _("\93Á\8eê\8cÅ\92è\95\94\89®(%s)\82ð\90¶\90¬\82µ\82Ü\82µ\82½\81B", "Special Fix room (%s)."), v_name + v_ptr->name);\r
1252 \r
1253         /* Hack -- Build the vault */\r
1254         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,\r
1255                 v_text + v_ptr->text, xoffset, yoffset, transno);\r
1256 \r
1257         return TRUE;\r
1258 }\r
1259 \r