src/rooms-vault.c

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