X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=src%2Frooms.c;h=d9ae1608b70c0ebde0ea6155721beecaa87ba83b;hb=54ed7e57e4c3f8bb8f4a6b577f4f2c752af6c9fd;hp=5fb9e87707bc7c1e0fef56b2c520ea14ff1c8ff0;hpb=fad8380a2752496ff488e5d4dd86d2e4bb9a5e8f;p=hengband%2Fhengband.git diff --git a/src/rooms.c b/src/rooms.c index 5fb9e8770..d9ae1608b 100644 --- a/src/rooms.c +++ b/src/rooms.c @@ -1,14 +1,39 @@ -/* - * File: rooms.c - * Purpose: make rooms. Used by generate.c when creating dungeons. - */ - -/* - * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke - * - * This software may be copied and distributed for educational, research, and - * not for profit purposes provided that this copyright and statement are - * included in all such copies. +/*! + * @file rooms.c + * @brief ダンジョンフロアの部屋生成処理 / make rooms. Used by generate.c when creating dungeons. + * @date 2014/01/06 + * @author + * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n + * This software may be copied and distributed for educational, research,\n + * and not for profit purposes provided that this copyright and statement\n + * are included in all such copies. Other copyrights may also apply.\n + * 2014 Deskull rearranged comment for Doxygen. \n + * @details + * Room building routines.\n + *\n + * Room types:\n + * 1 -- normal\n + * 2 -- overlapping\n + * 3 -- cross shaped\n + * 4 -- large room with features\n + * 5 -- monster nests\n + * 6 -- monster pits\n + * 7 -- simple vaults\n + * 8 -- greater vaults\n + * 9 -- fractal caves\n + * 10 -- random vaults\n + * 11 -- circular rooms\n + * 12 -- crypts\n + * 13 -- trapped monster pits\n + * 14 -- trapped room\n + * 15 -- glass room\n + * 16 -- underground arcade\n + *\n + * Some functions are used to determine if the given monster\n + * is appropriate for inclusion in a monster nest or monster pit or\n + * the given type.\n + *\n + * None of the pits/nests are allowed to include "unique" monsters.\n */ #include "angband.h" @@ -17,29 +42,72 @@ #include "rooms.h" -/* - * Array of minimum room depths +/*! + * 各部屋タイプの生成比定義 + *[from SAngband (originally from OAngband)]\n + *\n + * Table of values that control how many times each type of room will\n + * appear. Each type of room has its own row, and each column\n + * corresponds to dungeon levels 0, 10, 20, and so on. The final\n + * value is the minimum depth the room can appear at. -LM-\n + *\n + * Level 101 and below use the values for level 100.\n + *\n + * Rooms with lots of monsters or loot may not be generated if the\n + * object or monster lists are already nearly full. Rooms will not\n + * appear above their minimum depth. Tiny levels will not have space\n + * for all the rooms you ask for.\n */ -static s16b roomdep[] = +static room_info_type room_info_normal[ROOM_T_MAX] = { - 0, /* 0 = Nothing */ - 1, /* 1 = Simple (33x11) */ - 1, /* 2 = Overlapping (33x11) */ - 3, /* 3 = Crossed (33x11) */ - 3, /* 4 = Large (33x11) */ - 10, /* 5 = Monster nest (33x11) */ - 10, /* 6 = Monster pit (33x11) */ - 10, /* 7 = Lesser vault (33x22) */ - 20, /* 8 = Greater vault (66x44) */ - 5, /* 9 = Fractal cave (42x24) */ - 10, /* 10 = Random vault (44x22) */ - 3, /* 11 = Circular rooms (22x22) */ - 10, /* 12 = Crypts (22x22) */ - 20, /* 13 = Trapped monster pit */ - 20, /* 14 = Piranha/Armageddon trap room */ + /* Depth */ + /* 0 10 20 30 40 50 60 70 80 90 100 min limit */ + + {{999,900,800,700,600,500,400,300,200,100, 0}, 0}, /*NORMAL */ + {{ 1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100}, 1}, /*OVERLAP */ + {{ 1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100}, 3}, /*CROSS */ + {{ 1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100}, 3}, /*INNER_F */ + {{ 0, 1, 1, 1, 2, 3, 5, 6, 8, 10, 13}, 10}, /*NEST */ + {{ 0, 1, 1, 2, 3, 4, 6, 8, 10, 13, 16}, 10}, /*PIT */ + {{ 0, 1, 1, 1, 2, 2, 3, 5, 6, 8, 10}, 10}, /*LESSER_V */ + {{ 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4}, 20}, /*GREATER_V*/ + {{ 0,100,200,300,400,500,600,700,800,900,999}, 10}, /*FRACAVE */ + {{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2}, 10}, /*RANDOM_V */ + {{ 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40}, 3}, /*OVAL */ + {{ 1, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60}, 10}, /*CRYPT */ + {{ 0, 0, 1, 1, 1, 2, 3, 4, 5, 6, 8}, 20}, /*TRAP_PIT */ + {{ 0, 0, 1, 1, 1, 2, 3, 4, 5, 6, 8}, 20}, /*TRAP */ + {{ 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2}, 40}, /*GLASS */ + {{ 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3}, 1}, /*ARCADE */ }; +/*! 部屋の生成処理順 / Build rooms in descending order of difficulty. */ +static byte room_build_order[ROOM_T_MAX] = { + ROOM_T_GREATER_VAULT, + ROOM_T_ARCADE, + ROOM_T_RANDOM_VAULT, + ROOM_T_LESSER_VAULT, + ROOM_T_TRAP_PIT, + ROOM_T_PIT, + ROOM_T_NEST, + ROOM_T_TRAP, + ROOM_T_GLASS, + ROOM_T_INNER_FEAT, + ROOM_T_OVAL, + ROOM_T_CRYPT, + ROOM_T_OVERLAP, + ROOM_T_CROSS, + ROOM_T_FRACAVE, + ROOM_T_NORMAL, +}; + +/*! + * @brief 鍵のかかったドアを配置する + * @param y 配置したいフロアのY座標 + * @param x 配置したいフロアのX座標 + * @return なし + */ static void place_locked_door(int y, int x) { if (d_info[dungeon_type].flags1 & DF1_NO_DOORS) @@ -48,12 +116,20 @@ static void place_locked_door(int y, int x) } else { - set_cave_feat(y, x, FEAT_DOOR_HEAD+randint1(7)); + set_cave_feat(y, x, feat_locked_door_random((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR)); cave[y][x].info &= ~(CAVE_FLOOR); + delete_monster(y, x); } } -static void place_secret_door(int y, int x) +/*! + * @brief 隠しドアを配置する + * @param y 配置したいフロアのY座標 + * @param x 配置したいフロアのX座標 + * @param type #DOOR_DEFAULT / #DOOR_DOOR / #DOOR_GLASS_DOOR / #DOOR_CURTAIN のいずれか + * @return なし + */ +static void place_secret_door(int y, int x, int type) { if (d_info[dungeon_type].flags1 & DF1_NO_DOORS) { @@ -63,24 +139,42 @@ static void place_secret_door(int y, int x) { cave_type *c_ptr = &cave[y][x]; - /* Create secret door */ - place_closed_door(y, x); + if (type == DOOR_DEFAULT) + { + type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN : + ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR); + } - /* Hide */ - c_ptr->mimic = fill_type[randint0(100)]; + /* Create secret door */ + place_closed_door(y, x, type); - /* Floor type terrain cannot hide a door */ - if (!(c_ptr->mimic & 0x20)) + if (type != DOOR_CURTAIN) { - c_ptr->feat = c_ptr->mimic; - c_ptr->mimic = 0; + /* Hide by inner wall because this is used in rooms only */ + c_ptr->mimic = feat_wall_inner; + + /* Floor type terrain cannot hide a door */ + if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat)) + { + if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE) || have_flag(f_info[c_ptr->mimic].flags, FF_CAN_FLY)) + { + c_ptr->feat = one_in_(2) ? c_ptr->mimic : floor_type[randint0(100)]; + } + c_ptr->mimic = 0; + } } c_ptr->info &= ~(CAVE_FLOOR); + delete_monster(y, x); } } -/* +/*! + * @brief 1マスだけの部屋を作成し、上下左右いずれか一つに隠しドアを配置する。 + * @param y0 配置したい中心のY座標 + * @param x0 配置したい中心のX座標 + * @details * This funtion makes a very small room centred at (x0, y0) * This is used in crypts, and random elemental vaults. * @@ -106,20 +200,28 @@ static void build_small_room(int x0, int y0) /* Place a secret door on one side */ switch (randint0(4)) { - case 0: place_secret_door(y0, x0 - 1); break; - case 1: place_secret_door(y0, x0 + 1); break; - case 2: place_secret_door(y0 - 1, x0); break; - case 3: place_secret_door(y0 + 1, x0); break; + case 0: place_secret_door(y0, x0 - 1, DOOR_DEFAULT); break; + case 1: place_secret_door(y0, x0 + 1, DOOR_DEFAULT); break; + case 2: place_secret_door(y0 - 1, x0, DOOR_DEFAULT); break; + case 3: place_secret_door(y0 + 1, x0, DOOR_DEFAULT); break; } + /* Clear mimic type */ + cave[y0][x0].mimic = 0; + /* Add inner open space */ place_floor_bold(y0, x0); } - -/* - * This function tunnels around a room if - * it will cut off part of a cave system. +/*! + * @brief + * 指定範囲に通路が通っていることを確認した上で床で埋める + * This function tunnels around a room if it will cut off part of a cave system. + * @param x1 範囲の左端 + * @param y1 範囲の上端 + * @param x2 範囲の右端 + * @param y2 範囲の下端 + * @return なし */ static void check_room_boundary(int x1, int y1, int x2, int y2) { @@ -197,118 +299,227 @@ static void check_room_boundary(int x1, int y1, int x2, int y2) } -/* - * This function is used to allocate the space needed by a room in the room_map - * array. - * x, y represent the size of the room (0...x-1) by (0...y-1). - * crowded is used to denote a monset nest. - * by0, bx0 are the positions in the room_map array given to the build_type'x' - * function. - * xx, yy are the returned center of the allocated room in coordinates for - * cave.feat and cave.info etc. +/*! + * @brief + * find_space()の予備処理として部屋の生成が可能かを判定する / + * Helper function for find_space(). Is this a good location? + * @param blocks_high 範囲の高さ + * @param blocks_wide 範囲の幅 + * @param block_y 範囲の上端 + * @param block_x 範囲の左端 + * @return なし */ -static bool room_alloc(int x, int y, bool crowded, int by0, int bx0, int *xx, int *yy) +static bool find_space_aux(int blocks_high, int blocks_wide, int block_y, int block_x) { - int temp, bx1, bx2, by1, by2, by, bx; + int by1, bx1, by2, bx2, by, bx; + + /* Itty-bitty rooms must shift about within their rectangle */ + if (blocks_wide < 3) + { + if ((blocks_wide == 2) && (block_x % 3) == 2) + return FALSE; + } + + /* Rooms with width divisible by 3 must be fitted to a rectangle. */ + else if ((blocks_wide % 3) == 0) + { + /* Must be aligned to the left edge of a 11x33 rectangle. */ + if ((block_x % 3) != 0) + return FALSE; + } + + /* + * Big rooms that do not have a width divisible by 3 must be + * aligned towards the edge of the dungeon closest to them. + */ + else + { + /* Shift towards left edge of dungeon. */ + if (block_x + (blocks_wide / 2) <= dun->col_rooms / 2) + { + if (((block_x % 3) == 2) && ((blocks_wide % 3) == 2)) + return FALSE; + if ((block_x % 3) == 1) + return FALSE; + } - /* Calculate number of room_map squares to allocate */ + /* Shift toward right edge of dungeon. */ + else + { + if (((block_x % 3) == 2) && ((blocks_wide % 3) == 2)) + return FALSE; + if ((block_x % 3) == 1) + return FALSE; + } + } - /* temp is total number along width */ - temp = ((x - 1) / BLOCK_WID) + 1; + /* Extract blocks */ + by1 = block_y + 0; + bx1 = block_x + 0; + by2 = block_y + blocks_high; + bx2 = block_x + blocks_wide; + + /* Never run off the screen */ + if ((by1 < 0) || (by2 > dun->row_rooms)) return FALSE; + if ((bx1 < 0) || (bx2 > dun->col_rooms)) return FALSE; + + /* Verify available space */ + for (by = by1; by < by2; by++) + { + for (bx = bx1; bx < bx2; bx++) + { + if (dun->room_map[by][bx]) + { + return FALSE; + } + } + } - /* bx2 = ending block */ - bx2 = temp / 2 + bx0; + /* This location is okay */ + return TRUE; +} - /* bx1 = starting block (Note: rounding taken care of here.) */ - bx1 = bx2 + 1 - temp; - /* temp is total number along height */ - temp = ((y - 1) / BLOCK_HGT) + 1; +/*! + * @brief 部屋生成が可能なスペースを確保する / Find a good spot for the next room. -LM- + * @param y 部屋の生成が可能な中心Y座標を返す参照ポインタ + * @param x 部屋の生成が可能な中心X座標を返す参照ポインタ + * @param height 確保したい領域の高さ + * @param width 確保したい領域の幅 + * @return 所定の範囲が確保できた場合TRUEを返す + * @details + * Find and allocate a free space in the dungeon large enough to hold\n + * the room calling this function.\n + *\n + * We allocate space in 11x11 blocks, but want to make sure that rooms\n + * align neatly on the standard screen. Therefore, we make them use\n + * blocks in few 11x33 rectangles as possible.\n + *\n + * Be careful to include the edges of the room in height and width!\n + *\n + * Return TRUE and values for the center of the room if all went well.\n + * Otherwise, return FALSE.\n + */ +static bool find_space(int *y, int *x, int height, int width) +{ + int candidates, pick; + int by, bx, by1, bx1, by2, bx2; + int block_y = 0, block_x = 0; - /* by2 = ending block */ - by2 = temp / 2 + by0; - /* by1 = starting block */ - by1 = by2 + 1 - temp; + /* Find out how many blocks we need. */ + int blocks_high = 1 + ((height - 1) / BLOCK_HGT); + int blocks_wide = 1 + ((width - 1) / BLOCK_WID); + /* There are no way to allocate such huge space */ + if (dun->row_rooms < blocks_high) return FALSE; + if (dun->col_rooms < blocks_wide) return FALSE; - /* Never run off the screen */ - if ((by1 < 0) || (by2 >= dun->row_rooms)) return (FALSE); - if ((bx1 < 0) || (bx2 >= dun->col_rooms)) return (FALSE); + /* Initiallize */ + candidates = 0; - /* Verify open space */ - for (by = by1; by <= by2; by++) + /* Count the number of valid places */ + for (block_y = dun->row_rooms - blocks_high; block_y >= 0; block_y--) { - for (bx = bx1; bx <= bx2; bx++) + for (block_x = dun->col_rooms - blocks_wide; block_x >= 0; block_x--) { - if (dun->room_map[by][bx]) return (FALSE); + if (find_space_aux(blocks_high, blocks_wide, block_y, block_x)) + { + /* Find a valid place */ + candidates++; + } } } - /* It is *extremely* important that the following calculation */ - /* be *exactly* correct to prevent memory errors XXX XXX XXX */ + /* No place! */ + if (!candidates) + { + return FALSE; + } - /* Acquire the location of the room */ - *yy = ((by1 + by2 + 1) * BLOCK_HGT) / 2; - *xx = ((bx1 + bx2 + 1) * BLOCK_WID) / 2; + /* Normal dungeon */ + if (!(d_info[dungeon_type].flags1 & DF1_NO_CAVE)) + { + /* Choose a random one */ + pick = randint1(candidates); + } + + /* NO_CAVE dungeon (Castle) */ + else + { + /* Always choose the center one */ + pick = candidates/2 + 1; + } + + /* Pick up the choosen location */ + for (block_y = dun->row_rooms - blocks_high; block_y >= 0; block_y--) + { + for (block_x = dun->col_rooms - blocks_wide; block_x >= 0; block_x--) + { + if (find_space_aux(blocks_high, blocks_wide, block_y, block_x)) + { + pick--; + + /* This one is picked? */ + if (!pick) break; + } + } + + if (!pick) break; + } + + /* Extract blocks */ + by1 = block_y + 0; + bx1 = block_x + 0; + by2 = block_y + blocks_high; + bx2 = block_x + blocks_wide; + /* + * It is *extremely* important that the following calculation + * be *exactly* correct to prevent memory errors + */ + + /* Acquire the location of the room */ + (*y) = ((by1 + by2) * BLOCK_HGT) / 2; + (*x) = ((bx1 + bx2) * BLOCK_WID) / 2; /* Save the room location */ if (dun->cent_n < CENT_MAX) { - dun->cent[dun->cent_n].y = *yy; - dun->cent[dun->cent_n].x = *xx; + dun->cent[dun->cent_n].y = *y; + dun->cent[dun->cent_n].x = *x; dun->cent_n++; } - /* Reserve some blocks */ - for (by = by1; by <= by2; by++) + /* Reserve some blocks. */ + for (by = by1; by < by2; by++) { - for (bx = bx1; bx <= bx2; bx++) + for (bx = bx1; bx < bx2; bx++) { dun->room_map[by][bx] = TRUE; } } - /* Count "crowded" rooms */ - if (crowded) dun->crowded++; /* * Hack- See if room will cut off a cavern. - * If so, fix by tunneling outside the room in such a way as to connect the caves. + * + * If so, fix by tunneling outside the room in such a + * way as to connect the caves. */ - check_room_boundary(*xx - x / 2 - 1, *yy - y / 2 - 1, - *xx + (x - 1) / 2 + 1, *yy + (y - 1) / 2 + 1); + check_room_boundary(*x - width / 2 - 1, *y - height / 2 - 1, *x + (width - 1) / 2 + 1, *y + (height - 1) / 2 + 1); - /* Success */ - return (TRUE); -} -/* - * Room building routines. - * - * Room types: - * 1 -- normal - * 2 -- overlapping - * 3 -- cross shaped - * 4 -- large room with features - * 5 -- monster nests - * 6 -- monster pits - * 7 -- simple vaults - * 8 -- greater vaults - * 9 -- fractal caves - * 10 -- random vaults - * 11 -- circular rooms - * 12 -- crypts - * 13 -- trapped monster pits - * 14 -- trapped room - */ + /* Success. */ + return TRUE; +} -/* - * Type 1 -- normal rectangular rooms +/*! + * @brief タイプ1の部屋…通常可変長方形の部屋を生成する / Type 1 -- normal rectangular rooms + * @return なし */ -static void build_type1(int by0, int bx0) +static bool build_type1(void) { int y, x, y2, x2, yval, xval; int y1, x1, xsize, ysize; @@ -317,6 +528,9 @@ static void build_type1(int by0, int bx0) cave_type *c_ptr; + bool curtain = (d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 48 : 512); + /* Pick a room size */ y1 = randint1(4); x1 = randint1(11); @@ -326,8 +540,21 @@ static void build_type1(int by0, int bx0) xsize = x1 + x2 + 1; ysize = y1 + y2 + 1; - /* Try to allocate space for room. If fails, exit */ - if (!room_alloc(xsize + 2, ysize + 2, FALSE, by0, bx0, &xval, &yval)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) + { + /* Limit to the minimum room size, and retry */ + y1 = 1; + x1 = 1; + y2 = 1; + x2 = 1; + + xsize = x1 + x2 + 1; + ysize = y1 + y2 + 1; + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE; + } /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -369,6 +596,30 @@ static void build_type1(int by0, int bx0) } + /* Hack -- Occasional curtained room */ + if (curtain && (y2 - y1 > 2) && (x2 - x1 > 2)) + { + for (y = y1; y <= y2; y++) + { + c_ptr = &cave[y][x1]; + c_ptr->feat = feat_door[DOOR_CURTAIN].closed; + c_ptr->info &= ~(CAVE_MASK); + c_ptr = &cave[y][x2]; + c_ptr->feat = feat_door[DOOR_CURTAIN].closed; + c_ptr->info &= ~(CAVE_MASK); + } + for (x = x1; x <= x2; x++) + { + c_ptr = &cave[y1][x]; + c_ptr->feat = feat_door[DOOR_CURTAIN].closed; + c_ptr->info &= ~(CAVE_MASK); + c_ptr = &cave[y2][x]; + c_ptr->feat = feat_door[DOOR_CURTAIN].closed; + c_ptr->info &= ~(CAVE_MASK); + } + } + + /* Hack -- Occasional pillar room */ if (one_in_(20)) { @@ -422,12 +673,16 @@ static void build_type1(int by0, int bx0) /* Hack -- Occasional divided room */ else if (one_in_(50)) { + bool curtain2 = (d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 2 : 128); + if (randint1(100) < 50) { /* Horizontal wall */ for (x = x1; x <= x2; x++) { place_inner_bold(yval, x); + if (curtain2) cave[yval][x].feat = feat_door[DOOR_CURTAIN].closed; } /* Prevent edge of wall from being tunneled */ @@ -440,6 +695,7 @@ static void build_type1(int by0, int bx0) for (y = y1; y <= y2; y++) { place_inner_bold(y, xval); + if (curtain2) cave[y][xval].feat = feat_door[DOOR_CURTAIN].closed; } /* Prevent edge of wall from being tunneled */ @@ -447,15 +703,18 @@ static void build_type1(int by0, int bx0) place_solid_bold(y2 + 1, xval); } - place_random_door(yval, xval); + place_random_door(yval, xval, TRUE); + if (curtain2) cave[yval][xval].feat = feat_door[DOOR_CURTAIN].closed; } -} + return TRUE; +} -/* - * Type 2 -- Overlapping rectangular rooms +/*! + * @brief タイプ2の部屋…二重長方形の部屋を生成する / Type 2 -- Overlapping rectangular rooms + * @return なし */ -static void build_type2(int by0, int bx0) +static bool build_type2(void) { int y, x, xval, yval; int y1a, x1a, y2a, x2a; @@ -463,9 +722,8 @@ static void build_type2(int by0, int bx0) bool light; cave_type *c_ptr; - - /* Try to allocate space for room. If fails, exit */ - if (!room_alloc(25, 11, FALSE, by0, bx0, &xval, &yval)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 11, 25)) return FALSE; /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -561,23 +819,26 @@ static void build_type2(int by0, int bx0) place_floor_grid(c_ptr); } } + + return TRUE; } -/* - * Type 3 -- Cross shaped rooms - * - * Builds a room at a row, column coordinate - * - * Room "a" runs north/south, and Room "b" runs east/east - * So the "central pillar" runs from x1a, y1b to x2a, y2b. - * - * Note that currently, the "center" is always 3x3, but I think that - * the code below will work (with "bounds checking") for 5x5, or even - * for unsymetric values like 4x3 or 5x3 or 3x4 or 3x5, or even larger. +/*! + * @brief タイプ2の部屋…十字型の部屋を生成する / Type 3 -- Cross shaped rooms + * @return なし + * @details + * Builds a room at a row, column coordinate\n + *\n + * Room "a" runs north/south, and Room "b" runs east/east\n + * So the "central pillar" runs from x1a, y1b to x2a, y2b.\n + *\n + * Note that currently, the "center" is always 3x3, but I think that\n + * the code below will work (with "bounds checking") for 5x5, or even\n + * for unsymetric values like 4x3 or 5x3 or 3x4 or 3x5, or even larger.\n */ -static void build_type3(int by0, int bx0) +static bool build_type3(void) { int y, x, dy, dx, wy, wx; int y1a, x1a, y2a, x2a; @@ -587,8 +848,9 @@ static void build_type3(int by0, int bx0) cave_type *c_ptr; - /* Try to allocate space for room. */ - if (!room_alloc(25, 11, FALSE, by0, bx0, &xval, &yval)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 11, 25)) return FALSE; + /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -735,14 +997,14 @@ static void build_type3(int by0, int bx0) /* Place a secret door on the inner room */ switch (randint0(4)) { - case 0: place_secret_door(y1b, xval); break; - case 1: place_secret_door(y2b, xval); break; - case 2: place_secret_door(yval, x1a); break; - case 3: place_secret_door(yval, x2a); break; + case 0: place_secret_door(y1b, xval, DOOR_DEFAULT); break; + case 1: place_secret_door(y2b, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(yval, x1a, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x2a, DOOR_DEFAULT); break; } /* Place a treasure in the vault */ - place_object(yval, xval, FALSE, FALSE); + place_object(yval, xval, 0L); /* Let's guard the treasure well */ vault_monsters(yval, xval, randint0(2) + 3); @@ -782,10 +1044,14 @@ static void build_type3(int by0, int bx0) /* Sometimes shut using secret doors */ if (one_in_(3)) { - place_secret_door(yval, x1a - 1); - place_secret_door(yval, x2a + 1); - place_secret_door(y1b - 1, xval); - place_secret_door(y2b + 1, xval); + int door_type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN : + ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR); + + place_secret_door(yval, x1a - 1, door_type); + place_secret_door(yval, x2a + 1, door_type); + place_secret_door(y1b - 1, xval, door_type); + place_secret_door(y2b + 1, xval, door_type); } } @@ -814,20 +1080,23 @@ static void build_type3(int by0, int bx0) break; } } + + return TRUE; } -/* - * Type 4 -- Large room with inner features - * - * Possible sub-types: - * 1 - Just an inner room with one door - * 2 - An inner room within an inner room - * 3 - An inner room with pillar(s) - * 4 - Inner room has a maze - * 5 - A set of four inner rooms +/*! + * @brief タイプ4の部屋…固定サイズの二重構造部屋を生成する / Type 4 -- Large room with inner features + * @return なし + * @details + * Possible sub-types:\n + * 1 - Just an inner room with one door\n + * 2 - An inner room within an inner room\n + * 3 - An inner room with pillar(s)\n + * 4 - Inner room has a maze\n + * 5 - A set of four inner rooms\n */ -static void build_type4(int by0, int bx0) +static bool build_type4(void) { int y, x, y1, x1; int y2, x2, tmp, yval, xval; @@ -835,8 +1104,8 @@ static void build_type4(int by0, int bx0) cave_type *c_ptr; - /* Try to allocate space for room. */ - if (!room_alloc(25, 11, FALSE, by0, bx0, &xval, &yval)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 11, 25)) return FALSE; /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -908,10 +1177,10 @@ static void build_type4(int by0, int bx0) /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } /* Place a monster in the room */ @@ -926,10 +1195,10 @@ static void build_type4(int by0, int bx0) /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } /* Place another inner room */ @@ -958,7 +1227,7 @@ static void build_type4(int by0, int bx0) /* Object (80%) */ if (randint0(100) < 80) { - place_object(yval, xval, FALSE, FALSE); + place_object(yval, xval, 0L); } /* Stairs (20%) */ @@ -979,10 +1248,10 @@ static void build_type4(int by0, int bx0) /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } /* Large Inner Pillar */ @@ -1017,6 +1286,10 @@ static void build_type4(int by0, int bx0) /* Occasionally, some Inner rooms */ if (one_in_(3)) { + int door_type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN : + ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR); + /* Long horizontal walls */ for (x = xval - 5; x <= xval + 5; x++) { @@ -1033,16 +1306,16 @@ static void build_type4(int by0, int bx0) place_inner_grid(c_ptr); /* Secret doors (random top/bottom) */ - place_secret_door(yval - 3 + (randint1(2) * 2), xval - 3); - place_secret_door(yval - 3 + (randint1(2) * 2), xval + 3); + place_secret_door(yval - 3 + (randint1(2) * 2), xval - 3, door_type); + place_secret_door(yval - 3 + (randint1(2) * 2), xval + 3, door_type); /* Monsters */ vault_monsters(yval, xval - 2, randint1(2)); vault_monsters(yval, xval + 2, randint1(2)); /* Objects */ - if (one_in_(3)) place_object(yval, xval - 2, FALSE, FALSE); - if (one_in_(3)) place_object(yval, xval + 2, FALSE, FALSE); + if (one_in_(3)) place_object(yval, xval - 2, 0L); + if (one_in_(3)) place_object(yval, xval + 2, 0L); } break; @@ -1054,10 +1327,10 @@ static void build_type4(int by0, int bx0) /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } /* Maze (really a checkerboard) */ @@ -1090,6 +1363,10 @@ static void build_type4(int by0, int bx0) /* Four small rooms. */ case 5: { + int door_type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) && + one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN : + ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR); + /* Inner "cross" */ for (y = y1; y <= y2; y++) { @@ -1106,18 +1383,18 @@ static void build_type4(int by0, int bx0) if (randint0(100) < 50) { int i = randint1(10); - place_secret_door(y1 - 1, xval - i); - place_secret_door(y1 - 1, xval + i); - place_secret_door(y2 + 1, xval - i); - place_secret_door(y2 + 1, xval + i); + place_secret_door(y1 - 1, xval - i, door_type); + place_secret_door(y1 - 1, xval + i, door_type); + place_secret_door(y2 + 1, xval - i, door_type); + place_secret_door(y2 + 1, xval + i, door_type); } else { int i = randint1(3); - place_secret_door(yval + i, x1 - 1); - place_secret_door(yval - i, x1 - 1); - place_secret_door(yval + i, x2 + 1); - place_secret_door(yval - i, x2 + 1); + place_secret_door(yval + i, x1 - 1, door_type); + place_secret_door(yval - i, x1 - 1, door_type); + place_secret_door(yval + i, x2 + 1, door_type); + place_secret_door(yval - i, x2 + 1, door_type); } /* Treasure, centered at the center of the cross */ @@ -1132,45 +1409,42 @@ static void build_type4(int by0, int bx0) break; } } -} + return TRUE; +} -/* - * The following functions are used to determine if the given monster - * is appropriate for inclusion in a monster nest or monster pit or - * the given type. - * - * None of the pits/nests are allowed to include "unique" monsters. - */ -/* - * Monster validation macro +/*! + * vaultに配置可能なモンスターの条件を指定するマクロ / Monster validation macro * * Line 1 -- forbid town monsters * Line 2 -- forbid uniques * Line 3 -- forbid aquatic monsters */ #define vault_monster_okay(I) \ - (monster_dungeon(I) && \ + (mon_hook_dungeon(I) && \ !(r_info[I].flags1 & RF1_UNIQUE) && \ !(r_info[I].flags7 & RF7_UNIQUE2) && \ - !(r_info[I].flags3 & RF3_RES_ALL) && \ + !(r_info[I].flagsr & RFR_RES_ALL) && \ !(r_info[I].flags7 & RF7_AQUATIC)) -/* Race index for "monster pit (clone)" */ +/*! 通常pit生成時のモンスターの構成条件ID / Race index for "monster pit (clone)" */ static int vault_aux_race; -/* Race index for "monster pit (symbol clone)" */ +/*! 単一シンボルpit生成時の指定シンボル / Race index for "monster pit (symbol clone)" */ static char vault_aux_char; -/* Breath mask for "monster pit (dragon)" */ +/*! ブレス属性に基づくドラゴンpit生成時条件マスク / Breath mask for "monster pit (dragon)" */ static u32b vault_aux_dragon_mask4; -/* +/*! + * @brief モンスターがVault生成の最低必要条件を満たしているかを返す / * Helper monster selection function + * @param r_idx 確認したいモンスター種族ID + * @return Vault生成の最低必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_simple(int r_idx) { @@ -1179,8 +1453,11 @@ static bool vault_aux_simple(int r_idx) } -/* +/*! + * @brief モンスターがゼリーnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (jelly)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_jelly(int r_idx) { @@ -1189,21 +1466,23 @@ static bool vault_aux_jelly(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - if (r_ptr->flags2 & (RF2_KILL_BODY)) return (FALSE); + if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE); /* Also decline evil jellies (like death molds and shoggoths) */ if (r_ptr->flags3 & (RF3_EVIL)) return (FALSE); /* Require icky thing, jelly, mold, or mushroom */ - if (!strchr("ijm,", r_ptr->d_char)) return (FALSE); + if (!my_strchr("ijm,", r_ptr->d_char)) return (FALSE); /* Okay */ return (TRUE); } - -/* +/*! + * @brief モンスターが動物nestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (animal)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_animal(int r_idx) { @@ -1220,8 +1499,11 @@ static bool vault_aux_animal(int r_idx) } -/* +/*! + * @brief モンスターがアンデッドnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (undead)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_undead(int r_idx) { @@ -1237,9 +1519,11 @@ static bool vault_aux_undead(int r_idx) return (TRUE); } - -/* +/*! + * @brief モンスターが聖堂nestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (chapel)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_chapel_g(int r_idx) { @@ -1269,9 +1553,11 @@ static bool vault_aux_chapel_g(int r_idx) return FALSE; } - -/* +/*! + * @brief モンスターが犬小屋nestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (kennel)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_kennel(int r_idx) { @@ -1281,15 +1567,17 @@ static bool vault_aux_kennel(int r_idx) if (!vault_monster_okay(r_idx)) return (FALSE); /* Require a Zephyr Hound or a dog */ - if (!strchr("CZ", r_ptr->d_char)) return (FALSE); + if (!my_strchr("CZ", r_ptr->d_char)) return (FALSE); /* Okay */ return (TRUE); } - -/* +/*! + * @brief モンスターがミミックnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (mimic)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_mimic(int r_idx) { @@ -1297,16 +1585,19 @@ static bool vault_aux_mimic(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - + /* Require mimic */ - if (!strchr("!|$?=", r_ptr->d_char)) return (FALSE); + if (!my_strchr("!$&(/=?[\\|", r_ptr->d_char)) return (FALSE); /* Okay */ return (TRUE); } -/* +/*! + * @brief モンスターが単一クローンnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (clone)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_clone(int r_idx) { @@ -1317,8 +1608,11 @@ static bool vault_aux_clone(int r_idx) } -/* +/*! + * @brief モンスターが邪悪属性シンボルクローンnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (symbol clone)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_symbol_e(int r_idx) { @@ -1327,7 +1621,7 @@ static bool vault_aux_symbol_e(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - if (r_ptr->flags2 & (RF2_KILL_BODY)) return (FALSE); + if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE); if (r_ptr->flags3 & (RF3_GOOD)) return (FALSE); @@ -1339,8 +1633,11 @@ static bool vault_aux_symbol_e(int r_idx) } -/* +/*! + * @brief モンスターが善良属性シンボルクローンnestの生成必要条件を満たしているかを返す / * Helper function for "monster nest (symbol clone)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_symbol_g(int r_idx) { @@ -1349,7 +1646,7 @@ static bool vault_aux_symbol_g(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - if (r_ptr->flags2 & (RF2_KILL_BODY)) return (FALSE); + if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE); if (r_ptr->flags3 & (RF3_EVIL)) return (FALSE); @@ -1361,8 +1658,11 @@ static bool vault_aux_symbol_g(int r_idx) } -/* +/*! + * @brief モンスターがオークpitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (orc)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_orc(int r_idx) { @@ -1382,8 +1682,11 @@ static bool vault_aux_orc(int r_idx) } -/* +/*! + * @brief モンスターがトロルpitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (troll)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_troll(int r_idx) { @@ -1403,8 +1706,11 @@ static bool vault_aux_troll(int r_idx) } -/* +/*! + * @brief モンスターが巨人pitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (giant)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_giant(int r_idx) { @@ -1426,8 +1732,11 @@ static bool vault_aux_giant(int r_idx) } -/* +/*! + * @brief モンスターがドラゴンpitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (dragon)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_dragon(int r_idx) { @@ -1450,8 +1759,11 @@ static bool vault_aux_dragon(int r_idx) } -/* +/*! + * @brief モンスターが悪魔pitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (demon)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_demon(int r_idx) { @@ -1460,7 +1772,7 @@ static bool vault_aux_demon(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - if (r_ptr->flags2 & (RF2_KILL_BODY)) return (FALSE); + if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE); /* Require demon */ if (!(r_ptr->flags3 & RF3_DEMON)) return (FALSE); @@ -1470,8 +1782,11 @@ static bool vault_aux_demon(int r_idx) } -/* +/*! + * @brief モンスターが狂気pitの生成必要条件を満たしているかを返す / * Helper function for "monster pit (lovecraftian)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 */ static bool vault_aux_cthulhu(int r_idx) { @@ -1480,7 +1795,7 @@ static bool vault_aux_cthulhu(int r_idx) /* Validate the monster */ if (!vault_monster_okay(r_idx)) return (FALSE); - if (r_ptr->flags2 & (RF2_KILL_BODY)) return (FALSE); + if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE); /* Require eldritch horror */ if (!(r_ptr->flags2 & (RF2_ELDRITCH_HORROR))) return (FALSE); @@ -1490,8 +1805,9 @@ static bool vault_aux_cthulhu(int r_idx) } -/* - * Helper function for "monster pit (clone)" +/*! + * @brief pit/nestの基準となる単種モンスターを決める / + * @return なし */ static void vault_prep_clone(void) { @@ -1506,8 +1822,9 @@ static void vault_prep_clone(void) } -/* - * Helper function for "monster pit (symbol clone)" +/*! + * @brief pit/nestの基準となるモンスターシンボルを決める / + * @return なし */ static void vault_prep_symbol(void) { @@ -1526,9 +1843,9 @@ static void vault_prep_symbol(void) vault_aux_char = r_info[r_idx].d_char; } - -/* - * Helper function for "monster pit (dragon)" +/*! + * @brief pit/nestの基準となるドラゴンの種類を決める / + * @return なし */ static void vault_prep_dragon(void) { @@ -1600,12 +1917,37 @@ static void vault_prep_dragon(void) } -#define ROOM_PIT 0 -#define ROOM_NEST 1 +/*! + * @brief モンスターがダークエルフpitの生成必要条件を満たしているかを返す / + * Helper function for "monster pit (dark elf)" + * @param r_idx 確認したいモンスター種族ID + * @return 生成必要条件を満たしているならTRUEを返す。 + */ +static bool vault_aux_dark_elf(int r_idx) +{ + int i; + static int dark_elf_list[] = + { + MON_D_ELF, MON_D_ELF_MAGE, MON_D_ELF_WARRIOR, MON_D_ELF_PRIEST, + MON_D_ELF_LORD, MON_D_ELF_WARLOCK, MON_D_ELF_DRUID, MON_NIGHTBLADE, + MON_D_ELF_SORC, MON_D_ELF_SHADE, 0, + }; + + /* Validate the monster */ + if (!vault_monster_okay(r_idx)) return FALSE; + + /* Require dark elves */ + for (i = 0; dark_elf_list[i]; i++) + if (r_idx == dark_elf_list[i]) return TRUE; -typedef struct vault_aux_type vault_aux_type; + /* Assume not */ + return FALSE; +} +/*! pit/nest型情報のtypedef */ +typedef struct vault_aux_type vault_aux_type; +/*! pit/nest型情報の構造体定義 */ struct vault_aux_type { cptr name; @@ -1615,8 +1957,13 @@ struct vault_aux_type int chance; }; - -static vault_aux_type *pick_vault_type(vault_aux_type *l_ptr, int room) +/*! + * @brief ダンジョン毎に指定されたピット配列を基準にランダムなpit/nestタイプを決める + * @param l_ptr 選択されたpit/nest情報を返す参照ポインタ + * @param allow_flag_mask 生成が許されるpit/nestのビット配列 + * @return 選択されたpit/nestのID、選択失敗した場合-1を返す。 + */ +static int pick_vault_type(vault_aux_type *l_ptr, s16b allow_flag_mask) { int tmp, total, count; @@ -1631,14 +1978,8 @@ static vault_aux_type *pick_vault_type(vault_aux_type *l_ptr, int room) /* Ignore excessive depth */ if (n_ptr->level > dun_level) continue; - if (room == ROOM_PIT) - { - if (!(d_info[dungeon_type].pit & (1L << count))) continue; - } - else if (room == ROOM_NEST) - { - if(!(d_info[dungeon_type].nest & (1L << count))) continue; - } + /* Not matched with pit/nest flag */ + if (!(allow_flag_mask & (1L << count))) continue; /* Count this possibility */ total += n_ptr->chance * MAX_DEPTH / (MIN(dun_level, MAX_DEPTH - 1) - n_ptr->level + 5); @@ -1656,14 +1997,8 @@ static vault_aux_type *pick_vault_type(vault_aux_type *l_ptr, int room) /* Ignore excessive depth */ if (n_ptr->level > dun_level) continue; - if (room == ROOM_PIT) - { - if (!(d_info[dungeon_type].pit & (1L << count))) continue; - } - else if (room == ROOM_NEST) - { - if(!(d_info[dungeon_type].nest & (1L << count))) continue; - } + /* Not matched with pit/nest flag */ + if (!(allow_flag_mask & (1L << count))) continue; /* Count this possibility */ total += n_ptr->chance * MAX_DEPTH / (MIN(dun_level, MAX_DEPTH - 1) - n_ptr->level + 5); @@ -1672,94 +2007,324 @@ static vault_aux_type *pick_vault_type(vault_aux_type *l_ptr, int room) if (tmp < total) break; } - return (n_ptr->name ? n_ptr : NULL); + return n_ptr->name ? count : -1; } -static void build_type6(int by0, int bx0, bool nest); -static void build_type5(int by0, int bx0, bool nest); - +/*!nest情報テーブル*/ static vault_aux_type nest_types[] = { #ifdef JP - {"¥¯¥í¡¼¥ó", vault_aux_clone, vault_prep_clone, 5, 3}, - {"¥¼¥ê¡¼", vault_aux_jelly, NULL, 5, 6}, - {"¥·¥ó¥Ü¥ë(Á±)",vault_aux_symbol_g, vault_prep_symbol, 25, 2}, - {"¥·¥ó¥Ü¥ë(°­)",vault_aux_symbol_e, vault_prep_symbol, 25, 2}, - {"¥ß¥ß¥Ã¥¯", vault_aux_mimic, NULL, 30, 4}, - {"¶¸µ¤", vault_aux_cthulhu, NULL, 70, 2}, - {"¸¤¾®²°", vault_aux_kennel, NULL, 45, 4}, - {"ưʪ±à", vault_aux_animal, NULL, 35, 5}, - {"¶µ²ñ", vault_aux_chapel_g, NULL, 75, 4}, - {"¥¢¥ó¥Ç¥Ã¥É", vault_aux_undead, NULL, 75, 5}, - {NULL, NULL, NULL, 0, 0}, + {"クローン", vault_aux_clone, vault_prep_clone, 5, 3}, + {"ゼリー", vault_aux_jelly, NULL, 5, 6}, + {"シンボル(善)", vault_aux_symbol_g, vault_prep_symbol, 25, 2}, + {"シンボル(悪)", vault_aux_symbol_e, vault_prep_symbol, 25, 2}, + {"ミミック", vault_aux_mimic, NULL, 30, 4}, + {"狂気", vault_aux_cthulhu, NULL, 70, 2}, + {"犬小屋", vault_aux_kennel, NULL, 45, 4}, + {"動物園", vault_aux_animal, NULL, 35, 5}, + {"教会", vault_aux_chapel_g, NULL, 75, 4}, + {"アンデッド", vault_aux_undead, NULL, 75, 5}, + {NULL, NULL, NULL, 0, 0}, +#else + {"clone", vault_aux_clone, vault_prep_clone, 5, 3}, + {"jelly", vault_aux_jelly, NULL, 5, 6}, + {"symbol good", vault_aux_symbol_g, vault_prep_symbol, 25, 2}, + {"symbol evil", vault_aux_symbol_e, vault_prep_symbol, 25, 2}, + {"mimic", vault_aux_mimic, NULL, 30, 4}, + {"lovecraftian", vault_aux_cthulhu, NULL, 70, 2}, + {"kennel", vault_aux_kennel, NULL, 45, 4}, + {"animal", vault_aux_animal, NULL, 35, 5}, + {"chapel", vault_aux_chapel_g, NULL, 75, 4}, + {"undead", vault_aux_undead, NULL, 75, 5}, + {NULL, NULL, NULL, 0, 0}, +#endif +}; + +/*!pit情報テーブル*/ +static vault_aux_type pit_types[] = +{ +#ifdef JP + {"オーク", vault_aux_orc, NULL, 5, 6}, + {"トロル", vault_aux_troll, NULL, 20, 6}, + {"ジャイアント", vault_aux_giant, NULL, 50, 6}, + {"狂気", vault_aux_cthulhu, NULL, 80, 2}, + {"シンボル(善)", vault_aux_symbol_g, vault_prep_symbol, 70, 1}, + {"シンボル(悪)", vault_aux_symbol_e, vault_prep_symbol, 70, 1}, + {"教会", vault_aux_chapel_g, NULL, 65, 2}, + {"ドラゴン", vault_aux_dragon, vault_prep_dragon, 70, 6}, + {"デーモン", vault_aux_demon, NULL, 80, 6}, + {"ダークエルフ", vault_aux_dark_elf, NULL, 45, 4}, + {NULL, NULL, NULL, 0, 0}, #else - {"clone", vault_aux_clone, vault_prep_clone, 5, 3}, - {"jelly", vault_aux_jelly, NULL, 5, 6}, - {"symbol good",vault_aux_symbol_g, vault_prep_symbol, 25, 2}, - {"symbol evil",vault_aux_symbol_e, vault_prep_symbol, 25, 2}, - {"mimic", vault_aux_mimic, NULL, 30, 4}, - {"lovecraftian",vault_aux_cthulhu, NULL, 70, 2}, - {"kennel", vault_aux_kennel, NULL, 45, 4}, - {"animal", vault_aux_animal, NULL, 35, 5}, - {"chapel", vault_aux_chapel_g, NULL, 75, 4}, - {"undead", vault_aux_undead, NULL, 75, 5}, - {NULL, NULL, NULL, 0, 0}, + {"orc", vault_aux_orc, NULL, 5, 6}, + {"troll", vault_aux_troll, NULL, 20, 6}, + {"giant", vault_aux_giant, NULL, 50, 6}, + {"lovecraftian", vault_aux_cthulhu, NULL, 80, 2}, + {"symbol good", vault_aux_symbol_g, vault_prep_symbol, 70, 1}, + {"symbol evil", vault_aux_symbol_e, vault_prep_symbol, 70, 1}, + {"chapel", vault_aux_chapel_g, NULL, 65, 2}, + {"dragon", vault_aux_dragon, vault_prep_dragon, 70, 6}, + {"demon", vault_aux_demon, NULL, 80, 6}, + {"dark elf", vault_aux_dark_elf, NULL, 45, 4}, + {NULL, NULL, NULL, 0, 0}, #endif }; +/*! nestのID定義 / Nest types code */ +#define NEST_TYPE_CLONE 0 +#define NEST_TYPE_JELLY 1 +#define NEST_TYPE_SYMBOL_GOOD 2 +#define NEST_TYPE_SYMBOL_EVIL 3 +#define NEST_TYPE_MIMIC 4 +#define NEST_TYPE_LOVECRAFTIAN 5 +#define NEST_TYPE_KENNEL 6 +#define NEST_TYPE_ANIMAL 7 +#define NEST_TYPE_CHAPEL 8 +#define NEST_TYPE_UNDEAD 9 + +/*! pitのID定義 / Pit types code */ +#define PIT_TYPE_ORC 0 +#define PIT_TYPE_TROLL 1 +#define PIT_TYPE_GIANT 2 +#define PIT_TYPE_LOVECRAFTIAN 3 +#define PIT_TYPE_SYMBOL_GOOD 4 +#define PIT_TYPE_SYMBOL_EVIL 5 +#define PIT_TYPE_CHAPEL 6 +#define PIT_TYPE_DRAGON 7 +#define PIT_TYPE_DEMON 8 +#define PIT_TYPE_DARK_ELF 9 + + +/*! + * @brief デバッグ時に生成されたpit/nestの型を出力する処理 + * @param type pit/nestの型ID + * @param nest TRUEならばnest、FALSEならばpit + * @return デバッグ表示文字列の参照ポインタ + * @details + * Hack -- Get the string describing subtype of pit/nest + * Determined in prepare function (some pit/nest only) + */ +static cptr pit_subtype_string(int type, bool nest) +{ + static char inner_buf[256] = ""; + + inner_buf[0] = '\0'; /* Init string */ + + if (nest) /* Nests */ + { + switch (type) + { + case NEST_TYPE_CLONE: + sprintf(inner_buf, "(%s)", r_name + r_info[vault_aux_race].name); + break; + case NEST_TYPE_SYMBOL_GOOD: + case NEST_TYPE_SYMBOL_EVIL: + sprintf(inner_buf, "(%c)", vault_aux_char); + break; + } + } + else /* Pits */ + { + switch (type) + { + case PIT_TYPE_SYMBOL_GOOD: + case PIT_TYPE_SYMBOL_EVIL: + sprintf(inner_buf, "(%c)", vault_aux_char); + break; + case PIT_TYPE_DRAGON: + switch (vault_aux_dragon_mask4) + { +#ifdef JP + case RF4_BR_ACID: strcpy(inner_buf, "(酸)"); break; + case RF4_BR_ELEC: strcpy(inner_buf, "(稲妻)"); break; + case RF4_BR_FIRE: strcpy(inner_buf, "(火炎)"); break; + case RF4_BR_COLD: strcpy(inner_buf, "(冷気)"); break; + case RF4_BR_POIS: strcpy(inner_buf, "(毒)"); break; + case (RF4_BR_ACID | RF4_BR_ELEC | RF4_BR_FIRE | RF4_BR_COLD | RF4_BR_POIS): + strcpy(inner_buf, "(万色)"); break; + default: strcpy(inner_buf, "(未定義)"); break; +#else + case RF4_BR_ACID: strcpy(inner_buf, "(acid)"); break; + case RF4_BR_ELEC: strcpy(inner_buf, "(lightning)"); break; + case RF4_BR_FIRE: strcpy(inner_buf, "(fire)"); break; + case RF4_BR_COLD: strcpy(inner_buf, "(frost)"); break; + case RF4_BR_POIS: strcpy(inner_buf, "(poison)"); break; + case (RF4_BR_ACID | RF4_BR_ELEC | RF4_BR_FIRE | RF4_BR_COLD | RF4_BR_POIS): + strcpy(inner_buf, "(multi-hued)"); break; + default: strcpy(inner_buf, "(undefined)"); break; +#endif + } + break; + } + } + + return inner_buf; +} + + +/*! デバッグ時にnestのモンスター情報を確認するための構造体 / A struct for nest monster information with cheat_hear */ +typedef struct +{ + s16b r_idx; + bool used; +} +nest_mon_info_type; + + /* - * Type 5 -- Monster nests - * - * A monster nest is a "big" room, with an "inner" room, containing - * a "collection" of monsters of a given type strewn about the room. - * - * The monsters are chosen from a set of 64 randomly selected monster - * races, to allow the nest creation to fail instead of having "holes". - * - * Note the use of the "get_mon_num_prep()" function, and the special - * "get_mon_num_hook()" restriction function, to prepare the "monster - * allocation table" in such a way as to optimize the selection of - * "appropriate" non-unique monsters for the nest. - * - * Note that the "get_mon_num()" function may (rarely) fail, in which - * case the nest will be empty, and will not affect the level rating. - * - * Note that "monster nests" will never contain "unique" monsters. + *! @brief nestのモンスターリストをソートするための関数 / + * Comp function for sorting nest monster information + * @param u ソート処理対象配列ポインタ + * @param v 未使用 + * @param a 比較対象参照ID1 + * @param b 比較対象参照ID2 + */ +static bool ang_sort_comp_nest_mon_info(vptr u, vptr v, int a, int b) +{ + nest_mon_info_type *nest_mon_info = (nest_mon_info_type *)u; + int w1 = nest_mon_info[a].r_idx; + int w2 = nest_mon_info[b].r_idx; + monster_race *r1_ptr = &r_info[w1]; + monster_race *r2_ptr = &r_info[w2]; + int z1, z2; + + /* Unused */ + (void)v; + + /* Extract used info */ + z1 = nest_mon_info[a].used; + z2 = nest_mon_info[b].used; + + /* Compare used status */ + if (z1 < z2) return FALSE; + if (z1 > z2) return TRUE; + + /* Compare levels */ + if (r1_ptr->level < r2_ptr->level) return TRUE; + if (r1_ptr->level > r2_ptr->level) return FALSE; + + /* Compare experience */ + if (r1_ptr->mexp < r2_ptr->mexp) return TRUE; + if (r1_ptr->mexp > r2_ptr->mexp) return FALSE; + + /* Compare indexes */ + return w1 <= w2; +} + +/*! + * @brief nestのモンスターリストをスワップするための関数 / + * Swap function for sorting nest monster information + * @param u スワップ処理対象配列ポインタ + * @param v 未使用 + * @param a スワップ対象参照ID1 + * @param b スワップ対象参照ID2 + */ +static void ang_sort_swap_nest_mon_info(vptr u, vptr v, int a, int b) +{ + nest_mon_info_type *nest_mon_info = (nest_mon_info_type *)u; + nest_mon_info_type holder; + + /* Unused */ + (void)v; + + /* Swap */ + holder = nest_mon_info[a]; + nest_mon_info[a] = nest_mon_info[b]; + nest_mon_info[b] = holder; +} + + +#define NUM_NEST_MON_TYPE 64 /*!prep_func) (*(n_ptr->prep_func))(); - /* Large room */ - y1 = yval - 4; - y2 = yval + 4; - x1 = xval - 11; - x2 = xval + 11; + /* Prepare allocation table */ + get_mon_num_prep(n_ptr->hook_func, NULL); - /* Place the floor area */ - for (y = y1 - 1; y <= y2 + 1; y++) + align.sub_align = SUB_ALIGN_NEUTRAL; + + /* Pick some monster types */ + for (i = 0; i < NUM_NEST_MON_TYPE; i++) + { + int r_idx = 0, attempts = 100; + monster_race *r_ptr = NULL; + + while (attempts--) + { + /* Get a (hard) monster type */ + r_idx = get_mon_num(dun_level + 11); + r_ptr = &r_info[r_idx]; + + /* Decline incorrect alignment */ + if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue; + + /* Accept this monster */ + break; + } + + /* Notice failure */ + if (!r_idx || !attempts) return FALSE; + + /* Note the alignment */ + if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL; + if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD; + + nest_mon_info[i].r_idx = r_idx; + nest_mon_info[i].used = FALSE; + } + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 11, 25)) return FALSE; + + /* Large room */ + y1 = yval - 4; + y2 = yval + 4; + x1 = xval - 11; + x2 = xval + 11; + + /* Place the floor area */ + for (y = y1 - 1; y <= y2 + 1; y++) { for (x = x1 - 1; x <= x2 + 1; x++) { @@ -1816,177 +2381,153 @@ static void build_type5(int by0, int bx0, bool pit) } } - /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } + msg_format_wizard(CHEAT_DUNGEON, _("モンスター部屋(nest)(%s%s)を生成します。", "Monster nest (%s%s)"), n_ptr->name, pit_subtype_string(cur_nest_type, TRUE)); - /* Prepare allocation table */ - get_mon_num_prep(n_ptr->hook_func, NULL); - - /* Pick some monster types */ - for (i = 0; i < 64; i++) + /* Place some monsters */ + for (y = yval - 2; y <= yval + 2; y++) { - int r_idx = 0, attempts = 100; - - while (attempts--) + for (x = xval - 9; x <= xval + 9; x++) { - /* Get a (hard) monster type */ - r_idx = get_mon_num(dun_level + 10); - - /* Decline incorrect alignment */ - if (((align < 0) && (r_info[r_idx].flags3 & RF3_GOOD)) || - ((align > 0) && (r_info[r_idx].flags3 & RF3_EVIL))) - { - continue; - } - - /* Accept this monster */ - break; - } + int r_idx; - /* Notice failure */ - if (!r_idx || !attempts) return; + i = randint0(NUM_NEST_MON_TYPE); + r_idx = nest_mon_info[i].r_idx; - /* Note the alignment */ - if (r_info[r_idx].flags3 & RF3_GOOD) align++; - else if (r_info[r_idx].flags3 & RF3_EVIL) align--; + /* Place that "random" monster (no groups) */ + (void)place_monster_aux(0, y, x, r_idx, 0L); - what[i] = r_idx; + nest_mon_info[i].used = TRUE; + } } - /* Describe */ if (cheat_room) { - /* Room type */ -#ifdef JP -msg_format("¥â¥ó¥¹¥¿¡¼Éô²°(%s)", n_ptr->name); -#else - msg_format("Monster nest (%s)", n_ptr->name); -#endif - - } - - - /* Increase the level rating */ - rating += 10; - - /* (Sometimes) Cause a "special feeling" (for "Monster Nests") */ - if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300)) - { - good_item_flag = TRUE; - } + ang_sort_comp = ang_sort_comp_nest_mon_info; + ang_sort_swap = ang_sort_swap_nest_mon_info; + ang_sort(nest_mon_info, NULL, NUM_NEST_MON_TYPE); - /* Place some monsters */ - for (y = yval - 2; y <= yval + 2; y++) - { - for (x = xval - 9; x <= xval + 9; x++) + /* Dump the entries (prevent multi-printing) */ + for (i = 0; i < NUM_NEST_MON_TYPE; i++) { - int r_idx = what[randint0(64)]; - - /* Place that "random" monster (no groups) */ - (void)place_monster_aux(0, y, x, r_idx, 0L); + if (!nest_mon_info[i].used) break; + for (; i < NUM_NEST_MON_TYPE - 1; i++) + { + if (nest_mon_info[i].r_idx != nest_mon_info[i + 1].r_idx) break; + if (!nest_mon_info[i + 1].used) break; + } + msg_format_wizard(CHEAT_DUNGEON, "Nest構成モンスターNo.%d:%s", i, r_name + r_info[nest_mon_info[i].r_idx].name); } } -} - -static vault_aux_type pit_types[] = -{ -#ifdef JP - {"¥ª¡¼¥¯", vault_aux_orc, NULL, 5, 6}, - {"¥È¥í¥ë", vault_aux_troll, NULL, 20, 6}, - {"¥¸¥ã¥¤¥¢¥ó¥È",vault_aux_giant, NULL, 50, 6}, - {"¶¸µ¤", vault_aux_cthulhu, NULL, 80, 2}, - {"¥·¥ó¥Ü¥ë(Á±)",vault_aux_symbol_g, vault_prep_symbol, 70, 1}, - {"¥·¥ó¥Ü¥ë(°­)",vault_aux_symbol_e, vault_prep_symbol, 70, 1}, - {"¶µ²ñ", vault_aux_chapel_g, NULL, 65, 2}, - {"¥É¥é¥´¥ó", vault_aux_dragon, vault_prep_dragon, 70, 6}, - {"¥Ç¡¼¥â¥ó", vault_aux_demon, NULL, 80, 6}, - {NULL, NULL, NULL, 0, 0}, -#else - {"orc", vault_aux_orc, NULL, 5, 6}, - {"troll", vault_aux_troll, NULL, 20, 6}, - {"giant", vault_aux_giant, NULL, 50, 6}, - {"lovecraftian",vault_aux_cthulhu, NULL, 80, 2}, - {"symbol good",vault_aux_symbol_g, vault_prep_symbol, 70, 1}, - {"symbol evil",vault_aux_symbol_e, vault_prep_symbol, 70, 1}, - {"chapel", vault_aux_chapel_g, NULL, 65, 2}, - {"dragon", vault_aux_dragon, vault_prep_dragon, 70, 6}, - {"demon", vault_aux_demon, NULL, 80, 6}, - {NULL, NULL, NULL, 0, 0}, -#endif -}; + return TRUE; +} -/* - * Type 6 -- Monster pits - * - * A monster pit is a "big" room, with an "inner" room, containing - * a "collection" of monsters of a given type organized in the room. - * - * The inside room in a monster pit appears as shown below, where the - * actual monsters in each location depend on the type of the pit - * - * ##################### - * #0000000000000000000# - * #0112233455543322110# - * #0112233467643322110# - * #0112233455543322110# - * #0000000000000000000# - * ##################### - * - * Note that the monsters in the pit are now chosen by using "get_mon_num()" - * to request 16 "appropriate" monsters, sorting them by level, and using - * the "even" entries in this sorted list for the contents of the pit. - * - * Hack -- all of the "dragons" in a "dragon" pit must be the same "color", - * which is handled by requiring a specific "breath" attack for all of the - * dragons. This may include "multi-hued" breath. Note that "wyrms" may - * be present in many of the dragon pits, if they have the proper breath. - * - * Note the use of the "get_mon_num_prep()" function, and the special - * "get_mon_num_hook()" restriction function, to prepare the "monster - * allocation table" in such a way as to optimize the selection of - * "appropriate" non-unique monsters for the pit. - * - * Note that the "get_mon_num()" function may (rarely) fail, in which case - * the pit will be empty, and will not effect the level rating. - * - * Note that "monster pits" will never contain "unique" monsters. +/*! + * @brief タイプ6の部屋…pitを生成する / Type 6 -- Monster pits + * @return なし + * @details + * A monster pit is a "big" room, with an "inner" room, containing\n + * a "collection" of monsters of a given type organized in the room.\n + *\n + * The inside room in a monster pit appears as shown below, where the\n + * actual monsters in each location depend on the type of the pit\n + *\n + * XXXXXXXXXXXXXXXXXXXXX\n + * X0000000000000000000X\n + * X0112233455543322110X\n + * X0112233467643322110X\n + * X0112233455543322110X\n + * X0000000000000000000X\n + * XXXXXXXXXXXXXXXXXXXXX\n + *\n + * Note that the monsters in the pit are now chosen by using "get_mon_num()"\n + * to request 16 "appropriate" monsters, sorting them by level, and using\n + * the "even" entries in this sorted list for the contents of the pit.\n + *\n + * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",\n + * which is handled by requiring a specific "breath" attack for all of the\n + * dragons. This may include "multi-hued" breath. Note that "wyrms" may\n + * be present in many of the dragon pits, if they have the proper breath.\n + *\n + * Note the use of the "get_mon_num_prep()" function, and the special\n + * "get_mon_num_hook()" restriction function, to prepare the "monster\n + * allocation table" in such a way as to optimize the selection of\n + * "appropriate" non-unique monsters for the pit.\n + *\n + * Note that the "get_mon_num()" function may (rarely) fail, in which case\n + * the pit will be empty.\n + *\n + * Note that "monster pits" will never contain "unique" monsters.\n */ -static void build_type6(int by0, int bx0, bool nest) +static bool build_type6(void) { int y, x, y1, x1, y2, x2, xval, yval; int i, j; int what[16]; - int align = 0; + monster_type align; cave_type *c_ptr; - vault_aux_type *n_ptr = pick_vault_type(pit_types, ROOM_PIT); - - /* Try to allocate space for room. */ - if (!room_alloc(25, 11, TRUE, by0, bx0, &xval, &yval)) return; + int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit); + vault_aux_type *n_ptr; /* No type available */ - if (!n_ptr) - { - if (nest) return; - else {build_type5(by0, bx0, TRUE);return;} - } + if (cur_pit_type < 0) return FALSE; + + n_ptr = &pit_types[cur_pit_type]; /* Process a preparation function if necessary */ if (n_ptr->prep_func) (*(n_ptr->prep_func))(); + /* Prepare allocation table */ + get_mon_num_prep(n_ptr->hook_func, NULL); + + align.sub_align = SUB_ALIGN_NEUTRAL; + + /* Pick some monster types */ + for (i = 0; i < 16; i++) + { + int r_idx = 0, attempts = 100; + monster_race *r_ptr = NULL; + + while (attempts--) + { + /* Get a (hard) monster type */ + r_idx = get_mon_num(dun_level + 11); + r_ptr = &r_info[r_idx]; + + /* Decline incorrect alignment */ + if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue; + + /* Accept this monster */ + break; + } + + /* Notice failure */ + if (!r_idx || !attempts) return FALSE; + + /* Note the alignment */ + if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL; + if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD; + + what[i] = r_idx; + } + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 11, 25)) return FALSE; + /* Large room */ y1 = yval - 4; y2 = yval + 4; @@ -2052,45 +2593,10 @@ static void build_type6(int by0, int bx0, bool nest) /* Place a secret door */ switch (randint1(4)) { - case 1: place_secret_door(y1 - 1, xval); break; - case 2: place_secret_door(y2 + 1, xval); break; - case 3: place_secret_door(yval, x1 - 1); break; - case 4: place_secret_door(yval, x2 + 1); break; - } - - - /* Prepare allocation table */ - get_mon_num_prep(n_ptr->hook_func, NULL); - - /* Pick some monster types */ - for (i = 0; i < 16; i++) - { - int r_idx = 0, attempts = 100; - - while (attempts--) - { - /* Get a (hard) monster type */ - r_idx = get_mon_num(dun_level + 10); - - /* Decline incorrect alignment */ - if (((align < 0) && (r_info[r_idx].flags3 & RF3_GOOD)) || - ((align > 0) && (r_info[r_idx].flags3 & RF3_EVIL))) - { - continue; - } - - /* Accept this monster */ - break; - } - - /* Notice failure */ - if (!r_idx || !attempts) return; - - /* Note the alignment */ - if (r_info[r_idx].flags3 & RF3_GOOD) align++; - else if (r_info[r_idx].flags3 & RF3_EVIL) align--; - - what[i] = r_idx; + case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break; + case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break; + case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break; + case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break; } /* Sort the entries */ @@ -2115,37 +2621,14 @@ static void build_type6(int by0, int bx0, bool nest) } } - /* Message */ - if (cheat_room) - { -#ifdef JP -msg_format("%s¤ÎÁã", n_ptr->name); -#else - /* Room type */ - msg_format("Monster pit (%s)", n_ptr->name); -#endif - } + msg_format_wizard(CHEAT_DUNGEON, _("モンスター部屋(pit)(%s%s)を生成します。", "Monster pit (%s%s)"), n_ptr->name, pit_subtype_string(cur_pit_type, FALSE)); /* Select the entries */ for (i = 0; i < 8; i++) { /* Every other entry */ what[i] = what[i * 2]; - - if (cheat_hear) - { - /* Message */ - msg_print(r_name + r_info[what[i]].name); - } - } - - /* Increase the level rating */ - rating += 10; - - /* (Sometimes) Cause a "special feeling" (for "Monster Pits") */ - if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300)) - { - good_item_flag = TRUE; + msg_format_wizard(CHEAT_DUNGEON, _("Nest構成モンスター選択No.%d:%s", "Nest Monster Select No.%d:%s"), i, r_name + r_info[what[i]].name); } /* Top and bottom rows */ @@ -2196,10 +2679,20 @@ msg_format("%s /* Center monster */ place_monster_aux(0, yval, xval, what[7], PM_NO_KAGE); + + return TRUE; } -/* coordinate translation code */ +/*! + * @brief Vault地形を回転、上下左右反転するための座標変換を返す / coordinate translation code + * @param x 変換したい点のX座標参照ポインタ + * @param y 変換したい点のY座標参照ポインタ + * @param xoffset Vault生成時の基準X座標 + * @param yoffset Vault生成時の基準Y座標 + * @param transno 処理ID + * @return なし + */ static void coord_trans(int *x, int *y, int xoffset, int yoffset, int transno) { int i; @@ -2214,7 +2707,7 @@ static void coord_trans(int *x, int *y, int xoffset, int yoffset, int transno) * be expressed simply in terms of swapping and inverting the * x and y coordinates. */ - for (i = 0; i <= transno % 4; i++) + for (i = 0; i < transno % 4; i++) { /* rotate by 90 degrees */ temp = *x; @@ -2233,9 +2726,17 @@ static void coord_trans(int *x, int *y, int xoffset, int yoffset, int transno) *y += yoffset; } - -/* - * Hack -- fill in "vault" rooms +/*! + * @brief Vaultをフロアに配置する / Hack -- fill in "vault" rooms + * @param yval 生成基準Y座標 + * @param xval 生成基準X座標 + * @param ymax VaultのYサイズ + * @param xmax VaultのXサイズ + * @param data Vaultのデータ文字列 + * @param xoffset 変換基準X座標 + * @param yoffset 変換基準Y座標 + * @param transno 変換ID + * @return なし */ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, int xoffset, int yoffset, int transno) @@ -2260,7 +2761,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, coord_trans(&i, &j, xoffset, yoffset, transno); /* Extract the location */ - if (transno%2) + if (transno % 2 == 0) { /* no swap of x/y */ x = xval - (xmax / 2) + i; @@ -2286,7 +2787,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, c_ptr->mimic = 0; /* Part of a vault */ - c_ptr->info |= (CAVE_ICKY); + c_ptr->info |= (CAVE_ROOM | CAVE_ICKY); /* Analyze the grid */ switch (*t) @@ -2301,18 +2802,28 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, place_inner_grid(c_ptr); break; + /* Glass wall (inner) */ + case '$': + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + break; + /* Permanent wall (inner) */ case 'X': - c_ptr->feat = FEAT_PERM_INNER; - c_ptr->info &= ~(CAVE_MASK); - c_ptr->info |= CAVE_INNER; + place_inner_perm_grid(c_ptr); + break; + + /* Permanent glass wall (inner) */ + case 'Y': + place_inner_perm_grid(c_ptr); + c_ptr->feat = feat_permanent_glass_wall; break; /* Treasure/trap */ case '*': if (randint0(100) < 75) { - place_object(y, x, FALSE, FALSE); + place_object(y, x, 0L); } else { @@ -2322,7 +2833,18 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, /* Secret doors */ case '+': - place_secret_door(y, x); + place_secret_door(y, x, DOOR_DEFAULT); + break; + + /* Secret glass doors */ + case '-': + place_secret_door(y, x, DOOR_GLASS_DOOR); + if (is_closed_door(c_ptr->feat)) c_ptr->mimic = feat_glass_wall; + break; + + /* Curtains */ + case '\'': + place_secret_door(y, x, DOOR_CURTAIN); break; /* Trap */ @@ -2332,43 +2854,43 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, /* Black market in a dungeon */ case 'S': - set_cave_feat(y, x, FEAT_SHOP_HEAD + STORE_BLACK); + set_cave_feat(y, x, feat_black_market); store_init(NO_TOWN, STORE_BLACK); break; - + /* The Pattern */ case 'p': - set_cave_feat(y, x, FEAT_PATTERN_START); + set_cave_feat(y, x, feat_pattern_start); break; - + case 'a': - set_cave_feat(y, x, FEAT_PATTERN_1); + set_cave_feat(y, x, feat_pattern_1); break; - + case 'b': - set_cave_feat(y, x, FEAT_PATTERN_2); + set_cave_feat(y, x, feat_pattern_2); break; - + case 'c': - set_cave_feat(y, x, FEAT_PATTERN_3); + set_cave_feat(y, x, feat_pattern_3); break; - + case 'd': - set_cave_feat(y, x, FEAT_PATTERN_4); + set_cave_feat(y, x, feat_pattern_4); break; - + case 'P': - set_cave_feat(y, x, FEAT_PATTERN_END); + set_cave_feat(y, x, feat_pattern_end); break; - + case 'B': - set_cave_feat(y, x, FEAT_PATTERN_XTRA1); + set_cave_feat(y, x, feat_pattern_exit); break; case 'A': /* Reward for Pattern walk */ object_level = base_level + 12; - place_object(y, x, TRUE, FALSE); + place_object(y, x, AM_GOOD | AM_GREAT); object_level = base_level; break; } @@ -2389,7 +2911,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, coord_trans(&i, &j, xoffset, yoffset, transno); /* Extract the location */ - if (transno % 2) + if (transno % 2 == 0) { /* no swap of x/y */ x = xval - (xmax / 2) + i; @@ -2433,7 +2955,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, place_monster(y, x, PM_ALLOW_SLEEP); monster_level = base_level; object_level = base_level + 7; - place_object(y, x, TRUE, FALSE); + place_object(y, x, AM_GOOD); object_level = base_level; break; } @@ -2445,7 +2967,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, place_monster(y, x, PM_ALLOW_SLEEP); monster_level = base_level; object_level = base_level + 20; - place_object(y, x, TRUE, TRUE); + place_object(y, x, AM_GOOD | AM_GREAT); object_level = base_level; break; } @@ -2462,7 +2984,7 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, if (randint0(100) < 50) { object_level = base_level + 7; - place_object(y, x, FALSE, FALSE); + place_object(y, x, 0L); object_level = base_level; } break; @@ -2474,23 +2996,22 @@ static void build_vault(int yval, int xval, int ymax, int xmax, cptr data, } -/* - * Type 7 -- simple vaults (see "v_info.txt") +/*! + * @brief タイプ7の部屋…v_info.txtより小型vaultを生成する / Type 7 -- simple vaults (see "v_info.txt") + * @return なし */ -static void build_type7(int by0, int bx0) +static bool build_type7(void) { vault_type *v_ptr = NULL; - int dummy = 0; + int dummy; int x, y; int xval, yval; int xoffset, yoffset; int transno; /* Pick a lesser vault */ - while (dummy < SAFE_MAX_ATTEMPTS) + for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++) { - dummy++; - /* Access a random vault record */ v_ptr = &v_info[randint0(max_v_idx)]; @@ -2499,7 +3020,11 @@ static void build_type7(int by0, int bx0) } /* No lesser vault found */ - if (!v_ptr) return; + if (dummy >= SAFE_MAX_ATTEMPTS) + { + msg_print_wizard(CHEAT_DUNGEON, _("小型固定Vaultを配置できませんでした。", "Could not place lesser vault.")); + return FALSE; + } /* pick type of transformation (0-7) */ transno = randint0(8); @@ -2508,6 +3033,13 @@ static void build_type7(int by0, int bx0) x = v_ptr->wid; y = v_ptr->hgt; + /* Some huge vault cannot be ratated to fit in the dungeon */ + if (x+2 > cur_hgt-2) + { + /* Forbid 90 or 270 degree ratation */ + transno &= ~1; + } + coord_trans(&x, &y, 0, 0, transno); if (x < 0) @@ -2528,64 +3060,39 @@ static void build_type7(int by0, int bx0) yoffset = 0; } - /* Try to allocate space for room. */ - if (!room_alloc(abs(x), abs(y), FALSE, by0, bx0, &xval, &yval)) return; - - if (dummy >= SAFE_MAX_ATTEMPTS) - { - if (cheat_room) - { -#ifdef JP -msg_print("·Ù¹ð¡ª¾®¤µ¤ÊÃϲ¼¼¼¤òÇÛÃ֤Ǥ­¤Þ¤»¤ó¡ª"); -#else - msg_print("Warning! Could not place lesser vault!"); -#endif - - } - return; - } - + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, abs(y), abs(x))) return FALSE; #ifdef FORCE_V_IDX v_ptr = &v_info[2]; #endif /* Message */ - if (cheat_room) msg_format("%s", v_name + v_ptr->name); - - /* Boost the rating */ - rating += v_ptr->rat; - - /* (Sometimes) Cause a special feeling */ - if ((dun_level <= 50) || - (randint1((dun_level - 40) * (dun_level - 40) + 50) < 400)) - { - good_item_flag = TRUE; - } + msg_format_wizard(CHEAT_DUNGEON, _("小型Vault(%s)を生成しました。", "Lesser vault (%s)."), v_name + v_ptr->name); /* Hack -- Build the vault */ build_vault(yval, xval, v_ptr->hgt, v_ptr->wid, v_text + v_ptr->text, xoffset, yoffset, transno); -} + return TRUE; +} -/* - * Type 8 -- greater vaults (see "v_info.txt") +/*! + * @brief タイプ8の部屋…v_info.txtより大型vaultを生成する / Type 8 -- greater vaults (see "v_info.txt") + * @return なし */ -static void build_type8(int by0, int bx0) +static bool build_type8(void) { - vault_type *v_ptr = NULL; - int dummy = 0; + vault_type *v_ptr; + int dummy; int xval, yval; int x, y; int transno; int xoffset, yoffset; /* Pick a greater vault */ - while (dummy < SAFE_MAX_ATTEMPTS) + for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++) { - dummy++; - /* Access a random vault record */ v_ptr = &v_info[randint0(max_v_idx)]; @@ -2594,7 +3101,11 @@ static void build_type8(int by0, int bx0) } /* No greater vault found */ - if (!v_ptr) return; + if (dummy >= SAFE_MAX_ATTEMPTS) + { + msg_print_wizard(CHEAT_DUNGEON, _("大型固定Vaultを配置できませんでした。", "Could not place greater vault.")); + return FALSE; + } /* pick type of transformation (0-7) */ transno = randint0(8); @@ -2603,6 +3114,13 @@ static void build_type8(int by0, int bx0) x = v_ptr->wid; y = v_ptr->hgt; + /* Some huge vault cannot be ratated to fit in the dungeon */ + if (x+2 > cur_hgt-2) + { + /* Forbid 90 or 270 degree ratation */ + transno &= ~1; + } + coord_trans(&x, &y, 0, 0, transno); if (x < 0) @@ -2623,44 +3141,26 @@ static void build_type8(int by0, int bx0) yoffset = 0; } - /* Try to allocate space for room. If fails, exit */ - if (!room_alloc(abs(x), abs(y), FALSE, by0, bx0, &xval, &yval)) return; - - if (dummy >= SAFE_MAX_ATTEMPTS) - { - if (cheat_room) - { -#ifdef JP -msg_print("·Ù¹ð¡ªµðÂç¤ÊÃϲ¼¼¼¤òÇÛÃ֤Ǥ­¤Þ¤»¤ó¡ª"); -#else - msg_print("Warning! Could not place greater vault!"); -#endif - - } - return; - } - + /* + * Try to allocate space for room. If fails, exit + * + * Hack -- Prepare a bit larger space (+2, +2) to + * prevent generation of vaults with no-entrance. + */ + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, abs(y) + 2, abs(x) + 2)) return FALSE; #ifdef FORCE_V_IDX v_ptr = &v_info[76 + randint1(3)]; #endif - /* Message */ - if (cheat_room) msg_format("%s", v_name + v_ptr->name); - - /* Boost the rating */ - rating += v_ptr->rat; - - /* (Sometimes) Cause a special feeling */ - if ((dun_level <= 50) || - (randint1((dun_level - 40) * (dun_level - 40) + 50) < 400)) - { - good_item_flag = TRUE; - } + msg_format_wizard(CHEAT_DUNGEON, _("大型固定Vault(%s)を生成しました。", "Greater vault (%s)."), v_name + v_ptr->name); /* Hack -- Build the vault */ build_vault(yval, xval, v_ptr->hgt, v_ptr->wid, v_text + v_ptr->text, xoffset, yoffset, transno); + + return TRUE; } /* @@ -2752,7 +3252,7 @@ static void store_height(int x, int y, int val) * The tricky part is making sure the created cave is connected. This * is done by 'filling' from the inside and only keeping the 'filled' * floor. Walls bounding the 'filled' floor are also kept. Everything -* else is converted to the normal granite FEAT_WALL_EXTRA. +* else is converted to the normal _extra_. */ @@ -2806,10 +3306,10 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, fill_data.ymin = y0 - yhsize; fill_data.xmax = x0 + xhsize; fill_data.ymax = y0 + yhsize; - + /* Store cutoff in global for quick access */ fill_data.c1 = cutoff; - + /* * Scale factor for middle points: * About sqrt(2) * 256 - correct for a square lattice @@ -2825,8 +3325,8 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, { for (j = 0; j <= ysize; j++) { - /* 255 is a flag for "not done yet" */ - cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].feat = 255; + /* -1 is a flag for "not done yet" */ + cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].feat = -1; /* Clear icky flag because may be redoing the cave */ cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].info &= ~(CAVE_ICKY); } @@ -2858,11 +3358,11 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, xhstep /= 2; ystep = yhstep; yhstep /= 2; - + /* cache well used values */ xstep2 = xstep / 256; ystep2 = ystep / 256; - + xhstep2 = xhstep / 256; yhstep2 = yhstep / 256; @@ -2874,10 +3374,10 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, /* cache often used values */ ii = i / 256 + fill_data.xmin; jj = j / 256 + fill_data.ymin; - + /* Test square */ - if (cave[jj][ii].feat == 255) - { + if (cave[jj][ii].feat == -1) + { if (xhstep2 > grd) { /* If greater than 'grid' level then is random */ @@ -2904,9 +3404,9 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, /* cache often used values */ ii = i / 256 + fill_data.xmin; jj = j / 256 + fill_data.ymin; - + /* Test square */ - if (cave[jj][ii].feat == 255) + if (cave[jj][ii].feat == -1) { if (xhstep2 > grd) { @@ -2933,10 +3433,10 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, /* cache often used values */ ii = i / 256 + fill_data.xmin; jj = j / 256 + fill_data.ymin; - + /* Test square */ - if (cave[jj][ii].feat == 255) - { + if (cave[jj][ii].feat == -1) + { if (xhstep2 > grd) { /* If greater than 'grid' level then is random */ @@ -2948,12 +3448,12 @@ static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, xm = fill_data.xmin + (i - xhstep) / 256; xp = fill_data.xmin + (i + xhstep) / 256; ym = fill_data.ymin + (j - yhstep) / 256; - yp = fill_data.ymin + (j + yhstep) / 256; - + yp = fill_data.ymin + (j + yhstep) / 256; + /* * Average over all four corners + scale by diagsize to * reduce the effect of the square grid on the shape of the fractal - */ + */ store_height(ii, jj, (cave[ym][xm].feat + cave[yp][xm].feat + cave[ym][xp].feat + cave[yp][xp].feat) / 4 @@ -3022,6 +3522,7 @@ static bool hack_isnt_wall(int y, int x, int c1, int c2, int c3, int feat1, int else if (cave[y][x].feat <= c3) { cave[y][x].feat = feat3; + cave[y][x].info &= ~(CAVE_MASK); cave[y][x].info |= info3; return TRUE; } @@ -3126,7 +3627,6 @@ static void cave_fill(byte y, byte x) static bool generate_fracave(int y0, int x0, int xsize, int ysize, int cutoff, bool light, bool room) { int x, y, i, xhsize, yhsize; - /* offsets to middle from corner */ xhsize = xsize / 2; @@ -3298,7 +3798,7 @@ static bool generate_fracave(int y0, int x0, int xsize, int ysize, int cutoff, b * XXX XXX XXX There is a slight problem when tunnels pierce the caves: * Extra doors appear inside the system. (Its not very noticeable though.) * This can be removed by "filling" from the outside in. This allows a separation - * from FEAT_WALL_OUTER with FEAT_WALL_INNER. (Internal walls are F.W.OUTER instead.) + * from _outer_ with _inner_. (Internal walls are _outer_ instead.) * The extra effort for what seems to be only a minor thing (even non-existant if you * think of the caves not as normal rooms, but as holes in the dungeon), doesn't seem * worth it. @@ -3308,10 +3808,11 @@ static bool generate_fracave(int y0, int x0, int xsize, int ysize, int cutoff, b } -/* - * Driver routine to create fractal cave system +/*! + * @brief タイプ9の部屋…フラクタルカーブによる洞窟生成 / Type 9 -- Driver routine to create fractal cave system + * @return なし */ -static void build_type9(int by0, int bx0) +static bool build_type9(void) { int grd, roug, cutoff, xsize, ysize, y0, x0; @@ -3321,8 +3822,23 @@ static void build_type9(int by0, int bx0) xsize = randint1(22) * 2 + 6; ysize = randint1(15) * 2 + 6; - /* Try to allocate space for room. If fails, exit */ - if (!room_alloc(xsize + 1, ysize + 1, FALSE, by0, bx0, &x0, &y0)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) + { + /* Limit to the minimum room size, and retry */ + xsize = 8; + ysize = 8; + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) + { + /* + * Still no space?! + * Try normal room + */ + return build_type1(); + } + } light = done = FALSE; room = TRUE; @@ -3350,6 +3866,8 @@ static void build_type9(int by0, int bx0) /* Convert to normal format + clean up */ done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room); } + + return TRUE; } #ifdef ALLOW_CAVERNS_AND_LAKES @@ -3405,51 +3923,44 @@ static bool generate_lake(int y0, int x0, int xsize, int ysize, int c1, int c2, /* Get features based on type */ switch (type) { - case 1: { - /* Lava */ - feat1 = FEAT_DEEP_LAVA; - feat2 = FEAT_SHAL_LAVA; - feat3 = floor_type[randint0(100)]; - }; break; - case 2:{ - /* Water */ - feat1 = FEAT_DEEP_WATER; - feat2 = FEAT_SHAL_WATER; - feat3 = floor_type[randint0(100)]; - }; break; - case 3: { - /* Collapsed cave */ - feat1 = floor_type[randint0(100)]; - feat2 = floor_type[randint0(100)]; - feat3 = FEAT_RUBBLE; - }; break; - case 4: { - /* Earth vault */ - feat1 = FEAT_RUBBLE; - feat2 = floor_type[randint0(100)]; - feat3 = FEAT_RUBBLE; - }; break; - case 5: { - /* Air vault */ - feat1 = FEAT_GRASS; - feat2 = FEAT_TREES; - feat3 = FEAT_GRASS; - }; break; - case 6: { - /* Water vault */ - feat1 = FEAT_SHAL_WATER; - feat2 = FEAT_DEEP_WATER; - feat3 = FEAT_SHAL_WATER; - }; break; - case 7: { - /* Fire Vault */ - feat1 = FEAT_SHAL_LAVA; - feat2 = FEAT_DEEP_LAVA; - feat3 = FEAT_SHAL_LAVA; - }; break; - - /* Paranoia */ - default: return FALSE; + case LAKE_T_LAVA: /* Lava */ + feat1 = feat_deep_lava; + feat2 = feat_shallow_lava; + feat3 = floor_type[randint0(100)]; + break; + case LAKE_T_WATER: /* Water */ + feat1 = feat_deep_water; + feat2 = feat_shallow_water; + feat3 = floor_type[randint0(100)]; + break; + case LAKE_T_CAVE: /* Collapsed cave */ + feat1 = floor_type[randint0(100)]; + feat2 = floor_type[randint0(100)]; + feat3 = feat_rubble; + break; + case LAKE_T_EARTH_VAULT: /* Earth vault */ + feat1 = feat_rubble; + feat2 = floor_type[randint0(100)]; + feat3 = feat_rubble; + break; + case LAKE_T_AIR_VAULT: /* Air vault */ + feat1 = feat_grass; + feat2 = feat_tree; + feat3 = feat_grass; + break; + case LAKE_T_WATER_VAULT: /* Water vault */ + feat1 = feat_shallow_water; + feat2 = feat_deep_water; + feat3 = feat_shallow_water; + break; + case LAKE_T_FIRE_VAULT: /* Fire Vault */ + feat1 = feat_shallow_lava; + feat2 = feat_deep_lava; + feat3 = feat_shallow_lava; + break; + + /* Paranoia */ + default: return FALSE; } /* @@ -3457,7 +3968,7 @@ static bool generate_lake(int y0, int x0, int xsize, int ysize, int c1, int c2, * this gets rid of alot of isolated one-sqaures that * can make teleport traps instadeaths... */ - + /* cutoffs */ fill_data.c1 = c1; fill_data.c2 = c2; @@ -3532,11 +4043,10 @@ static bool generate_lake(int y0, int x0, int xsize, int ysize, int c1, int c2, /* turn off icky flag (no longer needed.) */ cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM); - /* Light lava and trees */ - if ((cave[y0 + y - yhsize][x0 + x - xhsize].feat == FEAT_DEEP_LAVA) || - (cave[y0 + y - yhsize][x0 + x - xhsize].feat == FEAT_SHAL_LAVA)) + /* Light lava */ + if (cave_have_flag_bold(y0 + y - yhsize, x0 + x - xhsize, FF_LAVA)) { - cave[y0 + y - yhsize][x0 + x - xhsize].info |= CAVE_GLOW; + if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) cave[y0 + y - yhsize][x0 + x - xhsize].info |= CAVE_GLOW; } } } @@ -3555,7 +4065,7 @@ void build_lake(int type) int c1, c2, c3; /* paranoia - exit if lake type out of range. */ - if ((type < 1) || (type > 7)) + if ((type < LAKE_T_LAVA) || (type > LAKE_T_FIRE_VAULT)) { msg_format("Invalid lake type (%d)", type); return; @@ -3623,7 +4133,7 @@ static void add_door(int x, int y) (is_outer_bold(y, x - 1) && is_outer_bold(y, x + 1))) { /* secret door */ - place_secret_door(y, x); + place_secret_door(y, x, DOOR_DEFAULT); /* set boundarys so don't get wide doors */ place_solid_bold(y, x - 1); @@ -3643,7 +4153,7 @@ static void add_door(int x, int y) is_floor_bold(y,x-1) && is_floor_bold(y,x+1)) { /* secret door */ - place_secret_door(y, x); + place_secret_door(y, x, DOOR_DEFAULT); /* set boundarys so don't get wide doors */ place_solid_bold(y - 1, x); @@ -3680,8 +4190,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) /* if floor, shallow water and lava */ if (is_floor_bold(y, x) || - (cave[y][x].feat == FEAT_SHAL_WATER) || - (cave[y][x].feat == FEAT_SHAL_LAVA)) + (cave_have_flag_bold(y, x, FF_PLACE) && cave_have_flag_bold(y, x, FF_DROP))) { /* The smaller 'value' is, the better the stuff */ if (value < 0) @@ -3691,7 +4200,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP)); monster_level = base_level; object_level = base_level + 20; - place_object(y, x, TRUE, FALSE); + place_object(y, x, AM_GOOD); object_level = base_level; } else if (value < 5) @@ -3701,7 +4210,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP)); monster_level = base_level; object_level = base_level + 10; - place_object(y, x, TRUE, FALSE); + place_object(y, x, AM_GOOD); object_level = base_level; } else if (value < 10) @@ -3727,7 +4236,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) /* Object or trap */ if (randint0(100) < 25) { - place_object(y, x, FALSE, FALSE); + place_object(y, x, 0L); } else { @@ -3754,7 +4263,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) if (randint0(100) < 50) { object_level = base_level + 7; - place_object(y, x, FALSE, FALSE); + place_object(y, x, 0L); object_level = base_level; } } @@ -3778,7 +4287,7 @@ static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty) } else if (randint0(100) < 50) { - place_object(y, x, FALSE, FALSE); + place_object(y, x, 0L); } } @@ -3814,12 +4323,11 @@ static void build_bubble_vault(int x0, int y0, int xsize, int ysize) int xhsize = xsize / 2; int yhsize = ysize / 2; - - if (cheat_room) msg_print("Bubble Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("泡型ランダムVaultを生成しました。", "Room Vault.")); /* Allocate center of bubbles */ - center[0].x = randint1(xsize - 3) + 1; - center[0].y = randint1(ysize - 3) + 1; + center[0].x = (byte)randint1(xsize - 3) + 1; + center[0].y = (byte)randint1(ysize - 3) + 1; for (i = 1; i < BUBBLENUM; i++) { @@ -3848,23 +4356,23 @@ static void build_bubble_vault(int x0, int y0, int xsize, int ysize) /* Top and bottom boundaries */ for (i = 0; i < xsize; i++) { - int x = x0 - xhsize + i; + int side_x = x0 - xhsize + i; - place_outer_noperm_bold(y0 - yhsize + 0, x); - cave[y0 - yhsize + 0][x].info |= (CAVE_ROOM | CAVE_ICKY); - place_outer_noperm_bold(y0 - yhsize + ysize - 1, x); - cave[y0 - yhsize + ysize - 1][x].info |= (CAVE_ROOM | CAVE_ICKY); + place_outer_noperm_bold(y0 - yhsize + 0, side_x); + cave[y0 - yhsize + 0][side_x].info |= (CAVE_ROOM | CAVE_ICKY); + place_outer_noperm_bold(y0 - yhsize + ysize - 1, side_x); + cave[y0 - yhsize + ysize - 1][side_x].info |= (CAVE_ROOM | CAVE_ICKY); } /* Left and right boundaries */ for (i = 1; i < ysize - 1; i++) { - int y = y0 - yhsize + i; + int side_y = y0 - yhsize + i; - place_outer_noperm_bold(y, x0 - xhsize + 0); - cave[y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY); - place_outer_noperm_bold(y, x0 - xhsize + xsize - 1); - cave[y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY); + place_outer_noperm_bold(side_y, x0 - xhsize + 0); + cave[side_y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY); + place_outer_noperm_bold(side_y, x0 - xhsize + xsize - 1); + cave[side_y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY); } /* Fill in middle with bubbles */ @@ -4016,7 +4524,7 @@ static void build_room_vault(int x0, int y0, int xsize, int ysize) xhsize = xsize / 2; yhsize = ysize / 2; - if (cheat_room) msg_print("Room Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("部屋型ランダムVaultを生成しました。", "Room Vault.")); /* fill area so don't get problems with arena levels */ for (x1 = 0; x1 < xsize; x1++) @@ -4067,7 +4575,7 @@ static void build_cave_vault(int x0, int y0, int xsiz, int ysiz) xsize = xhsize * 2; ysize = yhsize * 2; - if (cheat_room) msg_print("Cave Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("洞穴ランダムVaultを生成しました。", "Cave Vault.")); light = done = FALSE; room = TRUE; @@ -4215,8 +4723,7 @@ void build_maze_vault(int x0, int y0, int xsize, int ysize, bool is_vault) bool light; cave_type *c_ptr; - - if (cheat_room && is_vault) msg_print("Maze Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("迷路ランダムVaultを生成しました。", "Maze Vault.")); /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && is_vault && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -4280,13 +4787,13 @@ void build_maze_vault(int x0, int y0, int xsize, int ysize, bool is_vault) * a way to get in even if the vault abuts a side of the dungeon. */ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) - { +{ int dy, dx; int y1, x1, y2, x2, y, x, total; int m, n, num_vertices; int *visited; - if (cheat_room) msg_print("Mini Checker Board Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("小型チェッカーランダムVaultを生成しました。", "Mini Checker Board Vault.")); /* Pick a random room size */ dy = ysize / 2 - 1; @@ -4305,7 +4812,7 @@ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) cave[y1-2][x].info |= (CAVE_ROOM | CAVE_ICKY); - place_extra_noperm_bold(y1-2, x); + place_outer_noperm_bold(y1-2, x); } for (x = x1 - 2; x <= x2 + 2; x++) @@ -4314,7 +4821,7 @@ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) cave[y2+2][x].info |= (CAVE_ROOM | CAVE_ICKY); - place_extra_noperm_bold(y2+2, x); + place_outer_noperm_bold(y2+2, x); } for (y = y1 - 2; y <= y2 + 2; y++) @@ -4323,7 +4830,7 @@ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) cave[y][x1-2].info |= (CAVE_ROOM | CAVE_ICKY); - place_extra_noperm_bold(y, x1-2); + place_outer_noperm_bold(y, x1-2); } for (y = y1 - 2; y <= y2 + 2; y++) @@ -4332,17 +4839,19 @@ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) cave[y][x2+2].info |= (CAVE_ROOM | CAVE_ICKY); - place_extra_noperm_bold(y, x2+2); + place_outer_noperm_bold(y, x2+2); } for (y = y1 - 1; y <= y2 + 1; y++) { for (x = x1 - 1; x <= x2 + 1; x++) { - cave[y][x].info |= (CAVE_ROOM | CAVE_ICKY); + cave_type *c_ptr = &cave[y][x]; + + c_ptr->info |= (CAVE_ROOM | CAVE_ICKY); /* Permanent walls */ - cave[y][x].feat = FEAT_PERM_INNER; + place_inner_perm_grid(c_ptr); } } @@ -4377,15 +4886,15 @@ static void build_mini_c_vault(int x0, int y0, int xsize, int ysize) { /* left and right */ y = randint1(dy) + dy / 2; - place_outer_noperm_bold(y1 + y, x1 - 1); - place_outer_noperm_bold(y1 + y, x2 + 1); + place_inner_bold(y1 + y, x1 - 1); + place_inner_bold(y1 + y, x2 + 1); } else { /* top and bottom */ x = randint1(dx) + dx / 2; - place_outer_noperm_bold(y1 - 1, x1 + x); - place_outer_noperm_bold(y2 + 1, x1 + x); + place_inner_bold(y1 - 1, x1 + x); + place_inner_bold(y2 + 1, x1 + x); } /* Fill with monsters and treasure, highest difficulty */ @@ -4623,7 +5132,7 @@ static void build_castle_vault(int x0, int y0, int xsize, int ysize) y2 = y0 + dy; x2 = x0 + dx; - if (cheat_room) msg_print("Castle Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("城型ランダムVaultを生成しました。", "Castle Vault")); /* generate the room */ for (y = y1 - 1; y <= y2 + 1; y++) @@ -4649,19 +5158,24 @@ static void build_castle_vault(int x0, int y0, int xsize, int ysize) * Note: no range checking is done so must be inside dungeon * This routine also stomps on doors */ -static void add_outer_wall(int x, int y, int light, - int x1, int y1, int x2, int y2) +static void add_outer_wall(int x, int y, int light, int x1, int y1, int x2, int y2) { + cave_type *c_ptr; + feature_type *f_ptr; int i, j; if (!in_bounds(y, x)) return; + c_ptr = &cave[y][x]; + /* hack- check to see if square has been visited before * if so, then exit (use room flag to do this) */ - if (cave[y][x].info & CAVE_ROOM) return; + if (c_ptr->info & CAVE_ROOM) return; /* set room flag */ - cave[y][x].info |= CAVE_ROOM; + c_ptr->info |= CAVE_ROOM; + + f_ptr = &f_info[c_ptr->feat]; if (is_floor_bold(y, x)) { @@ -4673,7 +5187,7 @@ static void add_outer_wall(int x, int y, int light, (y + j >= y1) && (y + j <= y2)) { add_outer_wall(x + i, y + j, light, x1, y1, x2, y2); - if (light) cave[y][x].info |= CAVE_GLOW; + if (light) c_ptr->info |= CAVE_GLOW; } } } @@ -4682,12 +5196,12 @@ static void add_outer_wall(int x, int y, int light, { /* Set bounding walls */ place_outer_bold(y, x); - if (light == TRUE) cave[y][x].info |= CAVE_GLOW; + if (light) c_ptr->info |= CAVE_GLOW; } - else if (cave[y][x].feat == FEAT_PERM_OUTER) + else if (permanent_wall(f_ptr)) { /* Set bounding walls */ - if (light == TRUE) cave[y][x].info |= CAVE_GLOW; + if (light) c_ptr->info |= CAVE_GLOW; } } @@ -4735,7 +5249,7 @@ static void build_target_vault(int x0, int y0, int xsize, int ysize) h3 = randint1(32); h4 = randint1(32) - 16; - if (cheat_room) msg_print("Target Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("対称形ランダムVaultを生成しました。", "Elemental Vault")); /* work out outer radius */ if (xsize > ysize) @@ -4856,8 +5370,7 @@ static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz) int xsize, ysize, xhsize, yhsize, x, y, i; int type; - - if (cheat_room) msg_print("Elemental Vault"); + msg_print_wizard(CHEAT_DUNGEON, _("精霊界ランダムVaultを生成しました。", "Elemental Vault")); /* round to make sizes even */ xhsize = xsiz / 2; @@ -4868,22 +5381,22 @@ static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz) if (dun_level < 25) { /* Earth vault (Rubble) */ - type = 4; + type = LAKE_T_EARTH_VAULT; } else if (dun_level < 50) { /* Air vault (Trees) */ - type = 5; + type = LAKE_T_AIR_VAULT; } else if (dun_level < 75) { /* Water vault (shallow water) */ - type = 6; + type = LAKE_T_WATER_VAULT; } else { /* Fire vault (shallow lava) */ - type = 7; + type = LAKE_T_FIRE_VAULT; } while (!done) @@ -4934,10 +5447,11 @@ static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz) #endif /* ALLOW_CAVERNS_AND_LAKES */ -/* - * Random vaults +/*! + * @brief タイプ10の部屋…ランダム生成vault / Type 10 -- Random vaults + * @return なし */ -static void build_type10(int by0, int bx0) +static bool build_type10(void) { int y0, x0, xsize, ysize, vtype; @@ -4946,24 +5460,24 @@ static void build_type10(int by0, int bx0) xsize = randint1(22) + 22; ysize = randint1(11) + 11; - /* Allocate in room_map. If will not fit, exit */ - if (!room_alloc(xsize + 1, ysize + 1, FALSE, by0, bx0, &x0, &y0)) return; - - /* Boost the rating- higher than lesser vaults and lower than greater vaults */ - rating += 10; - - /* (Sometimes) Cause a special feeling */ - if ((dun_level <= 50) || - (randint1((dun_level - 40) * (dun_level - 40) + 1) < 400)) - { - good_item_flag = TRUE; - } + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) return FALSE; /* Select type of vault */ #ifdef ALLOW_CAVERNS_AND_LAKES - vtype = randint1(15); + do + { + vtype = randint1(15); + } + while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) && + ((vtype == 1) || (vtype == 3) || (vtype == 8) || (vtype == 9) || (vtype == 11))); #else /* ALLOW_CAVERNS_AND_LAKES */ - vtype = randint1(7); + do + { + vtype = randint1(7); + } + while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) && + ((vtype == 1) || (vtype == 3))); #endif /* ALLOW_CAVERNS_AND_LAKES */ switch (vtype) @@ -4982,19 +5496,23 @@ static void build_type10(int by0, int bx0) /* I know how to add a few more... give me some time. */ /* Paranoia */ - default: return; + default: return FALSE; } + + return TRUE; } -/* - * Build an vertical oval room. - * For every grid in the possible square, check the distance. - * If it's less than the radius, make it a room square. - * - * When done fill from the inside to find the walls, +/*! + * @brief タイプ11の部屋…円形部屋の生成 / Type 11 -- Build an vertical oval room. + * @return なし + * @details + * For every grid in the possible square, check the distance.\n + * If it's less than the radius, make it a room square.\n + *\n + * When done fill from the inside to find the walls,\n */ -static void build_type11(int by0, int bx0) +static bool build_type11(void) { int rad, x, y, x0, y0; int light = FALSE; @@ -5004,8 +5522,8 @@ static void build_type11(int by0, int bx0) rad = randint0(9); - /* Allocate in room_map. If will not fit, exit */ - if (!room_alloc(rad * 2 + 1, rad * 2 + 1, FALSE, by0, bx0, &x0, &y0)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&y0, &x0, rad * 2 + 1, rad * 2 + 1)) return FALSE; /* Make circular floor */ for (x = x0 - rad; x <= x0 + rad; x++) @@ -5027,18 +5545,22 @@ static void build_type11(int by0, int bx0) /* Find visible outer walls and set to be FEAT_OUTER */ add_outer_wall(x0, y0, light, x0 - rad, y0 - rad, x0 + rad, y0 + rad); + + return TRUE; } -/* - * Build crypt room. - * For every grid in the possible square, check the (fake) distance. - * If it's less than the radius, make it a room square. - * - * When done fill from the inside to find the walls, +/*! + * @brief タイプ12の部屋…ドーム型部屋の生成 / Type 12 -- Build crypt room. + * @return なし + * @details + * For every grid in the possible square, check the (fake) distance.\n + * If it's less than the radius, make it a room square.\n + *\n + * When done fill from the inside to find the walls,\n */ -static void build_type12(int by0, int bx0) - { +static bool build_type12(void) +{ int rad, x, y, x0, y0; int light = FALSE; bool emptyflag = TRUE; @@ -5055,8 +5577,8 @@ static void build_type12(int by0, int bx0) rad = randint1(9); - /* Allocate in room_map. If will not fit, exit */ - if (!room_alloc(rad * 2 + 3, rad * 2 + 3, FALSE, by0, bx0, &x0, &y0)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&y0, &x0, rad * 2 + 3, rad * 2 + 3)) return FALSE; /* Make floor */ for (x = x0 - rad; x <= x0 + rad; x++) @@ -5113,7 +5635,7 @@ static void build_type12(int by0, int bx0) build_small_room(x0, y0); /* Place a treasure in the vault */ - place_object(y0, x0, FALSE, FALSE); + place_object(y0, x0, 0L); /* Let's guard the treasure well */ vault_monsters(y0, x0, randint0(2) + 3); @@ -5121,6 +5643,8 @@ static void build_type12(int by0, int bx0) /* Traps naturally */ vault_traps(y0, x0, 4, 4, randint0(3) + 2); } + + return TRUE; } @@ -5142,51 +5666,52 @@ static bool vault_aux_trapped_pit(int r_idx) } -/* - * Type 12 -- Trapped monster pits - * - * A trapped monster pit is a "big" room with a straight corridor in - * which wall opening traps are placed, and with two "inner" rooms - * containing a "collection" of monsters of a given type organized in - * the room. - * - * The trapped monster pit appears as shown below, where the actual - * monsters in each location depend on the type of the pit - * - * ######################### - * # # - * ####################### # - * #####001123454321100### # - * ###0012234567654322100# # - * ####################### # - * # ^ # - * # ####################### - * # #0012234567654322100### - * # ###001123454321100##### - * # ####################### - * # # - * ######################### - * - * Note that the monsters in the pit are now chosen by using "get_mon_num()" - * to request 16 "appropriate" monsters, sorting them by level, and using - * the "even" entries in this sorted list for the contents of the pit. - * - * Hack -- all of the "dragons" in a "dragon" pit must be the same "color", - * which is handled by requiring a specific "breath" attack for all of the - * dragons. This may include "multi-hued" breath. Note that "wyrms" may - * be present in many of the dragon pits, if they have the proper breath. - * - * Note the use of the "get_mon_num_prep()" function, and the special - * "get_mon_num_hook()" restriction function, to prepare the "monster - * allocation table" in such a way as to optimize the selection of - * "appropriate" non-unique monsters for the pit. - * - * Note that the "get_mon_num()" function may (rarely) fail, in which case - * the pit will be empty, and will not effect the level rating. - * - * Note that "monster pits" will never contain "unique" monsters. +/*! + * @brief タイプ13の部屋…トラップpitの生成 / Type 13 -- Trapped monster pits + * @return なし + * @details + * A trapped monster pit is a "big" room with a straight corridor in\n + * which wall opening traps are placed, and with two "inner" rooms\n + * containing a "collection" of monsters of a given type organized in\n + * the room.\n + *\n + * The trapped monster pit appears as shown below, where the actual\n + * monsters in each location depend on the type of the pit\n + *\n + * XXXXXXXXXXXXXXXXXXXXXXXXX\n + * X X\n + * XXXXXXXXXXXXXXXXXXXXXXX X\n + * XXXXX001123454321100XXX X\n + * XXX0012234567654322100X X\n + * XXXXXXXXXXXXXXXXXXXXXXX X\n + * X ^ X\n + * X XXXXXXXXXXXXXXXXXXXXXXX\n + * X X0012234567654322100XXX\n + * X XXX001123454321100XXXXX\n + * X XXXXXXXXXXXXXXXXXXXXXXX\n + * X X\n + * XXXXXXXXXXXXXXXXXXXXXXXXX\n + *\n + * Note that the monsters in the pit are now chosen by using "get_mon_num()"\n + * to request 16 "appropriate" monsters, sorting them by level, and using\n + * the "even" entries in this sorted list for the contents of the pit.\n + *\n + * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",\n + * which is handled by requiring a specific "breath" attack for all of the\n + * dragons. This may include "multi-hued" breath. Note that "wyrms" may\n + * be present in many of the dragon pits, if they have the proper breath.\n + *\n + * Note the use of the "get_mon_num_prep()" function, and the special\n + * "get_mon_num_hook()" restriction function, to prepare the "monster\n + * allocation table" in such a way as to optimize the selection of\n + * "appropriate" non-unique monsters for the pit.\n + *\n + * Note that the "get_mon_num()" function may (rarely) fail, in which case\n + * the pit will be empty.\n + *\n + * Note that "monster pits" will never contain "unique" monsters.\n */ -static void build_type13(int by0, int bx0) +static bool build_type13(void) { static int placing[][3] = { {-2, -9, 0}, {-2, -8, 0}, {-3, -7, 0}, {-3, -6, 0}, @@ -5222,24 +5747,61 @@ static void build_type13(int by0, int bx0) int what[16]; - int align = 0; + monster_type align; cave_type *c_ptr; - vault_aux_type *n_ptr = pick_vault_type(pit_types, ROOM_PIT); + int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit); + vault_aux_type *n_ptr; /* Only in Angband */ - if (dungeon_type != 1) return; - - /* Try to allocate space for room. */ - if (!room_alloc(25, 13, TRUE, by0, bx0, &xval, &yval)) return; + if (dungeon_type != DUNGEON_ANGBAND) return FALSE; /* No type available */ - if (!n_ptr) return; + if (cur_pit_type < 0) return FALSE; + + n_ptr = &pit_types[cur_pit_type]; /* Process a preparation function if necessary */ if (n_ptr->prep_func) (*(n_ptr->prep_func))(); + /* Prepare allocation table */ + get_mon_num_prep(n_ptr->hook_func, vault_aux_trapped_pit); + + align.sub_align = SUB_ALIGN_NEUTRAL; + + /* Pick some monster types */ + for (i = 0; i < 16; i++) + { + int r_idx = 0, attempts = 100; + monster_race *r_ptr = NULL; + + while (attempts--) + { + /* Get a (hard) monster type */ + r_idx = get_mon_num(dun_level + 0); + r_ptr = &r_info[r_idx]; + + /* Decline incorrect alignment */ + if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue; + + /* Accept this monster */ + break; + } + + /* Notice failure */ + if (!r_idx || !attempts) return FALSE; + + /* Note the alignment */ + if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL; + if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD; + + what[i] = r_idx; + } + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, 13, 25)) return FALSE; + /* Large room */ y1 = yval - 5; y2 = yval + 5; @@ -5338,41 +5900,7 @@ static void build_type13(int by0, int bx0) /* Place the wall open trap */ cave[yval][xval].mimic = cave[yval][xval].feat; - cave[yval][xval].feat = FEAT_TRAP_OPEN; - - /* Prepare allocation table */ - get_mon_num_prep(n_ptr->hook_func, vault_aux_trapped_pit); - - /* Pick some monster types */ - for (i = 0; i < 16; i++) - { - int r_idx = 0, attempts = 100; - - while (attempts--) - { - /* Get a (hard) monster type */ - r_idx = get_mon_num(dun_level + 0); - - /* Decline incorrect alignment */ - if (((align < 0) && (r_info[r_idx].flags3 & RF3_GOOD)) || - ((align > 0) && (r_info[r_idx].flags3 & RF3_EVIL))) - { - continue; - } - - /* Accept this monster */ - break; - } - - /* Notice failure */ - if (!r_idx || !attempts) return; - - /* Note the alignment */ - if (r_info[r_idx].flags3 & RF3_GOOD) align++; - else if (r_info[r_idx].flags3 & RF3_EVIL) align--; - - what[i] = r_idx; - } + cave[yval][xval].feat = feat_trap_open; /* Sort the entries */ for (i = 0; i < 16 - 1; i++) @@ -5396,16 +5924,8 @@ static void build_type13(int by0, int bx0) } } - /* Message */ - if (cheat_room) - { -#ifdef JP - msg_format("%s¤Î櫥ԥåÈ", n_ptr->name); -#else - /* Room type */ - msg_format("Trapped monster pit (%s)", n_ptr->name); -#endif - } + msg_format_wizard(CHEAT_DUNGEON, _("%s%sの罠ピットが生成されました。", "Trapped monster pit (%s%s)"), + n_ptr->name, pit_subtype_string(cur_pit_type, FALSE)); /* Select the entries */ for (i = 0; i < 8; i++) @@ -5420,31 +5940,24 @@ static void build_type13(int by0, int bx0) } } - /* Increase the level rating */ - rating += 20; - - /* (Sometimes) Cause a "special feeling" (for "Monster Pits") */ - if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300)) - { - good_item_flag = TRUE; - } - - for (i = 0; placing[i][2] >= 0; i++) { y = yval + placing[i][0]; x = xval + placing[i][1]; place_monster_aux(0, y, x, what[placing[i][2]], PM_NO_KAGE); } + + return TRUE; } -/* - * Type 14 -- trapped rooms - * +/*! + * @brief タイプ14の部屋…特殊トラップ部屋の生成 / Type 14 -- trapped rooms + * @return なし + * @details * A special trap is placed at center of the room */ -static void build_type14(int by0, int bx0) +static bool build_type14(void) { int y, x, y2, x2, yval, xval; int y1, x1, xsize, ysize; @@ -5452,7 +5965,7 @@ static void build_type14(int by0, int bx0) bool light; cave_type *c_ptr; - byte trap; + s16b trap; /* Pick a room size */ y1 = randint1(4); @@ -5463,8 +5976,8 @@ static void build_type14(int by0, int bx0) xsize = x1 + x2 + 1; ysize = y1 + y2 + 1; - /* Try to allocate space for room. If fails, exit */ - if (!room_alloc(xsize + 2, ysize + 2, FALSE, by0, bx0, &xval, &yval)) return; + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE; /* Choose lite or dark */ light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); @@ -5506,62 +6019,859 @@ static void build_type14(int by0, int bx0) } if (dun_level < 30 + randint1(30)) - trap = FEAT_TRAP_PIRANHA; + trap = feat_trap_piranha; else - trap = FEAT_TRAP_ARMAGEDDON; + trap = feat_trap_armageddon; /* Place a special trap */ - cave[yval][xval].mimic = cave[yval][xval].feat; - cave[yval][xval].feat = trap; + c_ptr = &cave[rand_spread(yval, ysize/4)][rand_spread(xval, xsize/4)]; + c_ptr->mimic = c_ptr->feat; + c_ptr->feat = trap; - /* Message */ - if (cheat_room) - { -#ifdef JP - msg_format("%s¤ÎÉô²°", f_name + f_info[trap].name); -#else - msg_format("Room of %s", f_name + f_info[trap].name); -#endif - } + msg_format_wizard(CHEAT_DUNGEON, _("%sの部屋が生成されました。", "Room of %s was generated."), f_name + f_info[trap].name); + + return TRUE; } /* - * Attempt to build a room of the given type at the given block - * - * Note that we restrict the number of "crowded" rooms to reduce - * the chance of overflowing the monster list during level creation. + * Helper function for "glass room" */ -bool room_build(int by0, int bx0, int typ) +static bool vault_aux_lite(int r_idx) { - /* Restrict level */ - if ((dun_level < roomdep[typ]) && !ironman_rooms) return (FALSE); + monster_race *r_ptr = &r_info[r_idx]; + + /* Validate the monster */ + if (!vault_monster_okay(r_idx)) return FALSE; - /* Restrict "crowded" rooms */ - if ((dun->crowded >= 2) && ((typ == 5) || (typ == 6) || (typ == 13))) return (FALSE); + /* Require lite attack */ + if (!(r_ptr->flags4 & RF4_BR_LITE) && !(r_ptr->a_ability_flags1 & RF5_BA_LITE)) return FALSE; - /* Build a room */ - switch (typ) + /* No wall passing monsters */ + if (r_ptr->flags2 & (RF2_PASS_WALL | RF2_KILL_WALL)) return FALSE; + + /* No disintegrating monsters */ + if (r_ptr->flags4 & RF4_BR_DISI) return FALSE; + + return TRUE; +} + +/* + * Helper function for "glass room" + */ +static bool vault_aux_shards(int r_idx) +{ + monster_race *r_ptr = &r_info[r_idx]; + + /* Validate the monster */ + if (!vault_monster_okay(r_idx)) return FALSE; + + /* Require shards breath attack */ + if (!(r_ptr->flags4 & RF4_BR_SHAR)) return FALSE; + + return TRUE; +} + +/* + * Hack -- determine if a template is potion + */ +static bool kind_is_potion(int k_idx) +{ + return k_info[k_idx].tval == TV_POTION; +} + +/*! + * @brief タイプ15の部屋…ガラス部屋の生成 / Type 15 -- glass rooms + * @return なし + */ +static bool build_type15(void) +{ + int y, x, y2, x2, yval, xval; + int y1, x1, xsize, ysize; + bool light; + + cave_type *c_ptr; + + /* Pick a room size */ + xsize = rand_range(9, 13); + ysize = rand_range(9, 13); + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE; + + /* Choose lite or dark */ + light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)); + + /* Get corner values */ + y1 = yval - ysize / 2; + x1 = xval - xsize / 2; + y2 = yval + (ysize - 1) / 2; + x2 = xval + (xsize - 1) / 2; + + /* Place a full floor under the room */ + for (y = y1 - 1; y <= y2 + 1; y++) { - /* Build an appropriate room */ - case 14: build_type14(by0, bx0); break; - case 13: build_type13(by0, bx0); break; - case 12: build_type12(by0, bx0); break; - case 11: build_type11(by0, bx0); break; - case 10: build_type10(by0, bx0); break; - case 9: build_type9(by0, bx0); break; - case 8: build_type8(by0, bx0); break; - case 7: build_type7(by0, bx0); break; - case 6: build_type6(by0, bx0, FALSE); break; - case 5: build_type5(by0, bx0, FALSE); break; - case 4: build_type4(by0, bx0); break; - case 3: build_type3(by0, bx0); break; - case 2: build_type2(by0, bx0); break; - case 1: build_type1(by0, bx0); break; + for (x = x1 - 1; x <= x2 + 1; x++) + { + c_ptr = &cave[y][x]; + place_floor_grid(c_ptr); + c_ptr->feat = feat_glass_floor; + c_ptr->info |= (CAVE_ROOM); + if (light) c_ptr->info |= (CAVE_GLOW); + } + } - /* Paranoia */ - default: return (FALSE); + /* Walls around the room */ + for (y = y1 - 1; y <= y2 + 1; y++) + { + c_ptr = &cave[y][x1 - 1]; + place_outer_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + c_ptr = &cave[y][x2 + 1]; + place_outer_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + for (x = x1 - 1; x <= x2 + 1; x++) + { + c_ptr = &cave[y1 - 1][x]; + place_outer_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + c_ptr = &cave[y2 + 1][x]; + place_outer_grid(c_ptr); + c_ptr->feat = feat_glass_wall; } - return (TRUE); + switch (randint1(3)) + { + case 1: /* 4 lite breathers + potion */ + { + int dir1, dir2; + + /* Prepare allocation table */ + get_mon_num_prep(vault_aux_lite, NULL); + + /* Place fixed lite berathers */ + for (dir1 = 4; dir1 < 8; dir1++) + { + int r_idx = get_mon_num(dun_level); + + y = yval + 2 * ddy_ddd[dir1]; + x = xval + 2 * ddx_ddd[dir1]; + if (r_idx) place_monster_aux(0, y, x, r_idx, PM_ALLOW_SLEEP); + + /* Walls around the breather */ + for (dir2 = 0; dir2 < 8; dir2++) + { + c_ptr = &cave[y + ddy_ddd[dir2]][x + ddx_ddd[dir2]]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + } + + /* Walls around the potion */ + for (dir1 = 0; dir1 < 4; dir1++) + { + y = yval + 2 * ddy_ddd[dir1]; + x = xval + 2 * ddx_ddd[dir1]; + c_ptr = &cave[y][x]; + place_inner_perm_grid(c_ptr); + c_ptr->feat = feat_permanent_glass_wall; + cave[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]].info |= (CAVE_ICKY); + } + + /* Glass door */ + dir1 = randint0(4); + y = yval + 2 * ddy_ddd[dir1]; + x = xval + 2 * ddx_ddd[dir1]; + place_secret_door(y, x, DOOR_GLASS_DOOR); + c_ptr = &cave[y][x]; + if (is_closed_door(c_ptr->feat)) c_ptr->mimic = feat_glass_wall; + + /* Place a potion */ + get_obj_num_hook = kind_is_potion; + place_object(yval, xval, AM_NO_FIXED_ART); + cave[yval][xval].info |= (CAVE_ICKY); + } + break; + + case 2: /* 1 lite breather + random object */ + { + int r_idx, dir1; + + /* Pillars */ + c_ptr = &cave[y1 + 1][x1 + 1]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + + c_ptr = &cave[y1 + 1][x2 - 1]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + + c_ptr = &cave[y2 - 1][x1 + 1]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + + c_ptr = &cave[y2 - 1][x2 - 1]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + + /* Prepare allocation table */ + get_mon_num_prep(vault_aux_lite, NULL); + + r_idx = get_mon_num(dun_level); + if (r_idx) place_monster_aux(0, yval, xval, r_idx, 0L); + + /* Walls around the breather */ + for (dir1 = 0; dir1 < 8; dir1++) + { + c_ptr = &cave[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + + /* Curtains around the breather */ + for (y = yval - 1; y <= yval + 1; y++) + { + place_closed_door(y, xval - 2, DOOR_CURTAIN); + place_closed_door(y, xval + 2, DOOR_CURTAIN); + } + for (x = xval - 1; x <= xval + 1; x++) + { + place_closed_door(yval - 2, x, DOOR_CURTAIN); + place_closed_door(yval + 2, x, DOOR_CURTAIN); + } + + /* Place an object */ + place_object(yval, xval, AM_NO_FIXED_ART); + cave[yval][xval].info |= (CAVE_ICKY); + } + break; + + case 3: /* 4 shards breathers + 2 potions */ + { + int dir1; + + /* Walls around the potion */ + for (y = yval - 2; y <= yval + 2; y++) + { + c_ptr = &cave[y][xval - 3]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + c_ptr = &cave[y][xval + 3]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + for (x = xval - 2; x <= xval + 2; x++) + { + c_ptr = &cave[yval - 3][x]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + c_ptr = &cave[yval + 3][x]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + for (dir1 = 4; dir1 < 8; dir1++) + { + c_ptr = &cave[yval + 2 * ddy_ddd[dir1]][xval + 2 * ddx_ddd[dir1]]; + place_inner_grid(c_ptr); + c_ptr->feat = feat_glass_wall; + } + + /* Prepare allocation table */ + get_mon_num_prep(vault_aux_shards, NULL); + + /* Place shard berathers */ + for (dir1 = 4; dir1 < 8; dir1++) + { + int r_idx = get_mon_num(dun_level); + + y = yval + ddy_ddd[dir1]; + x = xval + ddx_ddd[dir1]; + if (r_idx) place_monster_aux(0, y, x, r_idx, 0L); + } + + /* Place two potions */ + if (one_in_(2)) + { + get_obj_num_hook = kind_is_potion; + place_object(yval, xval - 1, AM_NO_FIXED_ART); + get_obj_num_hook = kind_is_potion; + place_object(yval, xval + 1, AM_NO_FIXED_ART); + } + else + { + get_obj_num_hook = kind_is_potion; + place_object(yval - 1, xval, AM_NO_FIXED_ART); + get_obj_num_hook = kind_is_potion; + place_object(yval + 1, xval, AM_NO_FIXED_ART); + } + + for (y = yval - 2; y <= yval + 2; y++) + for (x = xval - 2; x <= xval + 2; x++) + cave[y][x].info |= (CAVE_ICKY); + + } + break; + } + + msg_print_wizard(CHEAT_DUNGEON, _("ガラスの部屋が生成されました。", "Glass room was generated.")); + + return TRUE; +} + + +/* Create a new floor room with optional light */ +void generate_room_floor(int y1, int x1, int y2, int x2, int light) +{ + int y, x; + + cave_type *c_ptr; + + for (y = y1; y <= y2; y++) + { + for (x = x1; x <= x2; x++) + { + /* Point to grid */ + c_ptr = &cave[y][x]; + place_floor_grid(c_ptr); + c_ptr->info |= (CAVE_ROOM); + if (light) c_ptr->info |= (CAVE_GLOW); + } + } +} + +void generate_fill_perm_bold(int y1, int x1, int y2, int x2) +{ + int y, x; + + for (y = y1; y <= y2; y++) + { + for (x = x1; x <= x2; x++) + { + /* Point to grid */ + place_inner_perm_bold(y, x); + } + } +} + +/* Minimum & maximum town size */ +#define MIN_TOWN_WID ((MAX_WID / 3) / 2) +#define MIN_TOWN_HGT ((MAX_HGT / 3) / 2) +#define MAX_TOWN_WID ((MAX_WID / 3) * 2 / 3) +#define MAX_TOWN_HGT ((MAX_HGT / 3) * 2 / 3) + +/* Struct for build underground buildings */ +typedef struct +{ + int y0, x0; /* North-west corner (relative) */ + int y1, x1; /* South-east corner (relative) */ +} +ugbldg_type; + +ugbldg_type *ugbldg; + +/* + * Precalculate buildings' location of underground arcade + */ +static bool precalc_ugarcade(int town_hgt, int town_wid, int n) +{ + int i, y, x, center_y, center_x, tmp, attempt = 10000; + int max_bldg_hgt = 3 * town_hgt / MAX_TOWN_HGT; + int max_bldg_wid = 5 * town_wid / MAX_TOWN_WID; + ugbldg_type *cur_ugbldg; + bool **ugarcade_used, abort; + + /* Allocate "ugarcade_used" array (2-dimension) */ + C_MAKE(ugarcade_used, town_hgt, bool *); + C_MAKE(*ugarcade_used, town_hgt * town_wid, bool); + for (y = 1; y < town_hgt; y++) ugarcade_used[y] = *ugarcade_used + y * town_wid; + + /* Calculate building locations */ + for (i = 0; i < n; i++) + { + cur_ugbldg = &ugbldg[i]; + (void)WIPE(cur_ugbldg, ugbldg_type); + + do + { + /* Find the "center" of the store */ + center_y = rand_range(2, town_hgt - 3); + center_x = rand_range(2, town_wid - 3); + + /* Determine the store boundaries */ + tmp = center_y - randint1(max_bldg_hgt); + cur_ugbldg->y0 = MAX(tmp, 1); + tmp = center_x - randint1(max_bldg_wid); + cur_ugbldg->x0 = MAX(tmp, 1); + tmp = center_y + randint1(max_bldg_hgt); + cur_ugbldg->y1 = MIN(tmp, town_hgt - 2); + tmp = center_x + randint1(max_bldg_wid); + cur_ugbldg->x1 = MIN(tmp, town_wid - 2); + + /* Scan this building's area */ + for (abort = FALSE, y = cur_ugbldg->y0; (y <= cur_ugbldg->y1) && !abort; y++) + { + for (x = cur_ugbldg->x0; x <= cur_ugbldg->x1; x++) + { + if (ugarcade_used[y][x]) + { + abort = TRUE; + break; + } + } + } + + attempt--; + } + while (abort && attempt); /* Accept this building if no overlapping */ + + /* Failed to generate underground arcade */ + if (!attempt) break; + + /* + * Mark to ugarcade_used[][] as "used" + * Note: Building-adjacent grids are included for preventing + * connected bulidings. + */ + for (y = cur_ugbldg->y0 - 1; y <= cur_ugbldg->y1 + 1; y++) + { + for (x = cur_ugbldg->x0 - 1; x <= cur_ugbldg->x1 + 1; x++) + { + ugarcade_used[y][x] = TRUE; + } + } + } + + /* Free "ugarcade_used" array (2-dimension) */ + C_KILL(*ugarcade_used, town_hgt * town_wid, bool); + C_KILL(ugarcade_used, town_hgt, bool *); + + /* If i < n, generation is not allowed */ + return i == n; +} + +/*! + * @brief タイプ16の部屋…地下都市生成のサブルーチン / Actually create buildings + * @return なし + * @param ltcy 生成基準Y座標 + * @param ltcx 生成基準X座標 + * @param stotes[] 生成する店舗のリスト + * @param n 生成する店舗の数 + * @note + * Note: ltcy and ltcx indicate "left top corner". + */ +static void build_stores(int ltcy, int ltcx, int stores[], int n) +{ + int i, j, y, x; + ugbldg_type *cur_ugbldg; + + for (i = 0; i < n; i++) + { + cur_ugbldg = &ugbldg[i]; + + /* Generate new room */ + generate_room_floor( + ltcy + cur_ugbldg->y0 - 2, ltcx + cur_ugbldg->x0 - 2, + ltcy + cur_ugbldg->y1 + 2, ltcx + cur_ugbldg->x1 + 2, + FALSE); + } + + for (i = 0; i < n; i++) + { + cur_ugbldg = &ugbldg[i]; + + /* Build an invulnerable rectangular building */ + generate_fill_perm_bold( + ltcy + cur_ugbldg->y0, ltcx + cur_ugbldg->x0, + ltcy + cur_ugbldg->y1, ltcx + cur_ugbldg->x1); + + /* Pick a door direction (S,N,E,W) */ + switch (randint0(4)) + { + /* Bottom side */ + case 0: + y = cur_ugbldg->y1; + x = rand_range(cur_ugbldg->x0, cur_ugbldg->x1); + break; + + /* Top side */ + case 1: + y = cur_ugbldg->y0; + x = rand_range(cur_ugbldg->x0, cur_ugbldg->x1); + break; + + /* Right side */ + case 2: + y = rand_range(cur_ugbldg->y0, cur_ugbldg->y1); + x = cur_ugbldg->x1; + break; + + /* Left side */ + default: + y = rand_range(cur_ugbldg->y0, cur_ugbldg->y1); + x = cur_ugbldg->x0; + break; + } + + for (j = 0; j < max_f_idx; j++) + { + if (have_flag(f_info[j].flags, FF_STORE)) + { + if (f_info[j].subtype == stores[i]) break; + } + } + + /* Clear previous contents, add a store door */ + if (j < max_f_idx) + { + cave_set_feat(ltcy + y, ltcx + x, j); + + /* Init store */ + store_init(NO_TOWN, stores[i]); + } + } +} + + +/*! + * @brief タイプ16の部屋…地下都市の生成 / Type 16 -- Underground Arcade + * @return なし + * @details + * Town logic flow for generation of new town\n + * Originally from Vanilla 3.0.3\n + *\n + * We start with a fully wiped cave of normal floors.\n + *\n + * Note that town_gen_hack() plays games with the R.N.G.\n + *\n + * This function does NOT do anything about the owners of the stores,\n + * nor the contents thereof. It only handles the physical layout.\n + */ +static bool build_type16(void) +{ + int stores[] = + { + STORE_GENERAL, STORE_ARMOURY, STORE_WEAPON, STORE_TEMPLE, + STORE_ALCHEMIST, STORE_MAGIC, STORE_BLACK, STORE_BOOK, + }; + int n = sizeof stores / sizeof (int); + int i, y, x, y1, x1, yval, xval; + int town_hgt = rand_range(MIN_TOWN_HGT, MAX_TOWN_HGT); + int town_wid = rand_range(MIN_TOWN_WID, MAX_TOWN_WID); + bool prevent_bm = FALSE; + + /* Hack -- If already exist black market, prevent building */ + for (y = 0; (y < cur_hgt) && !prevent_bm; y++) + { + for (x = 0; x < cur_wid; x++) + { + if (cave[y][x].feat == FF_STORE) + { + prevent_bm = (f_info[cave[y][x].feat].subtype == STORE_BLACK); + break; + } + } + } + for (i = 0; i < n; i++) + { + if ((stores[i] == STORE_BLACK) && prevent_bm) stores[i] = stores[--n]; + } + if (!n) return FALSE; + + /* Allocate buildings array */ + C_MAKE(ugbldg, n, ugbldg_type); + + /* If cannot build stores, abort */ + if (!precalc_ugarcade(town_hgt, town_wid, n)) + { + /* Free buildings array */ + C_KILL(ugbldg, n, ugbldg_type); + return FALSE; + } + + /* Find and reserve some space in the dungeon. Get center of room. */ + if (!find_space(&yval, &xval, town_hgt + 4, town_wid + 4)) + { + /* Free buildings array */ + C_KILL(ugbldg, n, ugbldg_type); + return FALSE; + } + + /* Get top left corner */ + y1 = yval - (town_hgt / 2); + x1 = xval - (town_wid / 2); + + /* Generate new room */ + generate_room_floor( + y1 + town_hgt / 3, x1 + town_wid / 3, + y1 + town_hgt * 2 / 3, x1 + town_wid * 2 / 3, FALSE); + + /* Build stores */ + build_stores(y1, x1, stores, n); + + msg_print_wizard(CHEAT_DUNGEON, _("地下街を生成しました", "Underground arcade was generated.")); + + /* Free buildings array */ + C_KILL(ugbldg, n, ugbldg_type); + + return TRUE; +} + + +/*! + * @brief 与えられた部屋型IDに応じて部屋の生成処理分岐を行い結果を返す / Attempt to build a room of the given type at the given block + * @param type 部屋型ID + * @note that we restrict the number of "crowded" rooms to reduce the chance of overflowing the monster list during level creation. + * @return 部屋の精製に成功した場合 TRUE を返す。 + */ +static bool room_build(int typ) +{ + /* Build a room */ + switch (typ) + { + /* Build an appropriate room */ + case ROOM_T_NORMAL: return build_type1(); + case ROOM_T_OVERLAP: return build_type2(); + case ROOM_T_CROSS: return build_type3(); + case ROOM_T_INNER_FEAT: return build_type4(); + case ROOM_T_NEST: return build_type5(); + case ROOM_T_PIT: return build_type6(); + case ROOM_T_LESSER_VAULT: return build_type7(); + case ROOM_T_GREATER_VAULT: return build_type8(); + case ROOM_T_FRACAVE: return build_type9(); + case ROOM_T_RANDOM_VAULT: return build_type10(); + case ROOM_T_OVAL: return build_type11(); + case ROOM_T_CRYPT: return build_type12(); + case ROOM_T_TRAP_PIT: return build_type13(); + case ROOM_T_TRAP: return build_type14(); + case ROOM_T_GLASS: return build_type15(); + case ROOM_T_ARCADE: return build_type16(); + } + + /* Paranoia */ + return FALSE; +} + +/*! + * @brief 指定した部屋の生成確率を別の部屋に加算し、指定した部屋の生成率を0にする + * @param dst 確率を移す先の部屋種ID + * @param src 確率を与える元の部屋種ID + */ +#define MOVE_PLIST(dst, src) (prob_list[dst] += prob_list[src], prob_list[src] = 0) + +/*! + * @brief 部屋生成処理のメインルーチン(Sangbandを経由してOangbandからの実装を引用) / Generate rooms in dungeon. Build bigger rooms at first.　[from SAngband (originally from OAngband)] + * @return 部屋生成に成功した場合 TRUE を返す。 + */ +bool generate_rooms(void) +{ + int i; + bool remain; + int crowded = 0; + int total_prob; + int prob_list[ROOM_T_MAX]; + int rooms_built = 0; + int area_size = 100 * (cur_hgt*cur_wid) / (MAX_HGT*MAX_WID); + int level_index = MIN(10, div_round(dun_level, 10)); + + /* Number of each type of room on this level */ + s16b room_num[ROOM_T_MAX]; + + /* Limit number of rooms */ + int dun_rooms = DUN_ROOMS_MAX * area_size / 100; + + /* Assume normal cave */ + room_info_type *room_info_ptr = room_info_normal; + + /* + * Initialize probability list. + */ + for (i = 0; i < ROOM_T_MAX; i++) + { + /* No rooms allowed above their minimum depth. */ + if (dun_level < room_info_ptr[i].min_level) + { + prob_list[i] = 0; + } + else + { + prob_list[i] = room_info_ptr[i].prob[level_index]; + } + } + + /* + * XXX -- Various dungeon types and options. + */ + + /*! @details ダンジョンにBEGINNER、CHAMELEON、SMALLESTいずれのフラグもなく、かつ「常に通常でない部屋を生成する」フラグがONならば、GRATER_VAULTのみを生成対象とする。 / Ironman sees only Greater Vaults */ + if (ironman_rooms && !((d_info[dungeon_type].flags1 & (DF1_BEGINNER | DF1_CHAMELEON | DF1_SMALLEST)))) + { + for (i = 0; i < ROOM_T_MAX; i++) + { + if (i == ROOM_T_GREATER_VAULT) prob_list[i] = 1; + else prob_list[i] = 0; + } + } + + /*! @details ダンジョンにNO_VAULTフラグがあるならば、LESSER_VAULT / GREATER_VAULT/ RANDOM_VAULTを除外 / Forbidden vaults */ + else if (d_info[dungeon_type].flags1 & DF1_NO_VAULT) + { + prob_list[ROOM_T_LESSER_VAULT] = 0; + prob_list[ROOM_T_GREATER_VAULT] = 0; + prob_list[ROOM_T_RANDOM_VAULT] = 0; + } + + /*! @details ダンジョンにNO_CAVEフラグがある場合、FRACAVEの生成枠がNORMALに与えられる。CRIPT、OVALの生成枠がINNER_Fに与えられる。/ NO_CAVE dungeon (Castle)*/ + if (d_info[dungeon_type].flags1 & DF1_NO_CAVE) + { + MOVE_PLIST(ROOM_T_NORMAL, ROOM_T_FRACAVE); + MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_CRYPT); + MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_OVAL); + } + + /*! @details ダンジョンにCAVEフラグがある場合、NORMALの生成枠がFRACAVEに与えられる。/ CAVE dungeon (Orc cave etc.) */ + else if (d_info[dungeon_type].flags1 & DF1_CAVE) + { + MOVE_PLIST(ROOM_T_FRACAVE, ROOM_T_NORMAL); + } + + /*! @details ダンジョンの基本地形が最初から渓谷かアリーナ型の場合 FRACAVE は生成から除外。 / No caves when a (random) cavern exists: they look bad */ + else if (dun->cavern || dun->empty_level) + { + prob_list[ROOM_T_FRACAVE] = 0; + } + + /*! @details ダンジョンに最初からGLASS_ROOMフラグがある場合、GLASS を生成から除外。/ Forbidden glass rooms */ + if (!(d_info[dungeon_type].flags1 & DF1_GLASS_ROOM)) + { + prob_list[ROOM_T_GLASS] = 0; + } + + /*! @details ARCADEは同フラグがダンジョンにないと生成されない。 / Forbidden glass rooms */ + if (!(d_info[dungeon_type].flags1 & DF1_ARCADE)) + { + prob_list[ROOM_T_ARCADE] = 0; + } + + /* + * Initialize number of rooms, + * And calcurate total probability. + */ + for (total_prob = 0, i = 0; i < ROOM_T_MAX; i++) + { + room_num[i] = 0; + total_prob += prob_list[i]; + } + + /* + * Prepare the number of rooms, of all types, we should build + * on this level. + */ + for (i = dun_rooms; i > 0; i--) + { + int room_type; + int rand = randint0(total_prob); + + /* Get room_type randomly */ + for (room_type = 0; room_type < ROOM_T_MAX; room_type++) + { + if (rand < prob_list[room_type]) break; + else rand -= prob_list[room_type]; + } + + /* Paranoia */ + if (room_type >= ROOM_T_MAX) room_type = ROOM_T_NORMAL; + + /* Increase the number of rooms of that type we should build. */ + room_num[room_type]++; + + switch (room_type) + { + case ROOM_T_NEST: + case ROOM_T_PIT: + case ROOM_T_LESSER_VAULT: + case ROOM_T_TRAP_PIT: + case ROOM_T_GLASS: + case ROOM_T_ARCADE: + + /* Large room */ + i -= 2; + break; + + case ROOM_T_GREATER_VAULT: + case ROOM_T_RANDOM_VAULT: + + /* Largest room */ + i -= 3; + break; + } + } + + /* + * Build each type of room one by one until we cannot build any more. + * [from SAngband (originally from OAngband)] + */ + while (TRUE) + { + /* Assume no remaining rooms */ + remain = FALSE; + + for (i = 0; i < ROOM_T_MAX; i++) + { + /* What type of room are we building now? */ + int room_type = room_build_order[i]; + + /* Go next if none available */ + if (!room_num[room_type]) continue; + + /* Use up one unit */ + room_num[room_type]--; + + /* Build the room. */ + if (room_build(room_type)) + { + /* Increase the room built count. */ + rooms_built++; + + /* Mark as there was some remaining rooms */ + remain = TRUE; + + switch (room_type) + { + case ROOM_T_PIT: + case ROOM_T_NEST: + case ROOM_T_TRAP_PIT: + + /* Avoid too many monsters */ + if (++crowded >= 2) + { + room_num[ROOM_T_PIT] = 0; + room_num[ROOM_T_NEST] = 0; + room_num[ROOM_T_TRAP_PIT] = 0; + } + break; + + case ROOM_T_ARCADE: + + /* Avoid double-town */ + room_num[ROOM_T_ARCADE] = 0; + break; + } + } + } + + /* End loop if no room remain */ + if (!remain) break; + } + + /*! @details 部屋生成数が2未満の場合生成失敗を返す */ + if (rooms_built < 2) + { + msg_format_wizard(CHEAT_DUNGEON, _("部屋数が2未満でした。生成を再試行します。", "Number of rooms was under 2. Retry."), rooms_built); + return FALSE; + } + + msg_format_wizard(CHEAT_DUNGEON, _("このダンジョンの部屋数は %d です。", "Number of Rooms: %d"), rooms_built); + + return TRUE; }