X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=src%2Fcave.c;h=e75d77dea2ab06efd8a94427359656007e9e8894;hb=a55fcffc6673dd5b7a79f87233961be0f4533b83;hp=bef0f8a4b3468886d6664e7221463d7406785520;hpb=2095df741d803545b613b8210d791a419416f11c;p=hengband%2Fhengband.git diff --git a/src/cave.c b/src/cave.c index bef0f8a4b..e75d77dea 100644 --- a/src/cave.c +++ b/src/cave.c @@ -1,44 +1,48 @@ -/* File: cave.c */ - -/* - * Copyright (c) 1997 Ben Harrison, 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. Other copyrights may also apply. +/*! + * @file cave.c + * @brief ダンジョンの基礎部分実装(主にマスの実装) / low level dungeon routines -BEN- + * @date 2013/12/30 + * @author + * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n + *\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 + * \n + * Support for Adam Bolt's tileset, lighting and transparency effects\n + * by Robert Ruehlmann (rr9@angband.org)\n + * \n + * 2013 Deskull Doxygen向けのコメント整理\n */ -/* Purpose: low level dungeon routines -BEN- */ - #include "angband.h" - -/* - * Support for Adam Bolt's tileset, lighting and transparency effects - * by Robert Ruehlmann (rr9@angband.org) - */ - -static byte display_autopick; +static byte display_autopick; /*!< 自動拾い状態の設定フラグ */ static int match_autopick; -static object_type *autopick_obj; -static int feat_priority; - -/* - * Distance between two points via Newton-Raphson technique +static object_type *autopick_obj; /*!< 各種自動拾い処理時に使うオブジェクトポインタ */ +static int feat_priority; /*!< マップ縮小表示時に表示すべき地形の優先度を保管する */ + +/*! + * @brief 2点間の距離をニュートン・ラプソン法で算出する / Distance between two points via Newton-Raphson technique + * @param y1 1点目のy座標 + * @param x1 1点目のx座標 + * @param y2 2点目のy座標 + * @param x2 2点目のx座標 + * @return 2点間の距離 */ -int distance (int y1, int x1, int y2, int x2) +POSITION distance (POSITION y1, POSITION x1, POSITION y2, POSITION x2) { - int dy = (y1 > y2) ? (y1 - y2) : (y2 - y1); - int dx = (x1 > x2) ? (x1 - x2) : (x2 - x1); + POSITION dy = (y1 > y2) ? (y1 - y2) : (y2 - y1); + POSITION dx = (x1 > x2) ? (x1 - x2) : (x2 - x1); /* Squared distance */ - int target = (dy * dy) + (dx * dx); + POSITION target = (dy * dy) + (dx * dx); /* Approximate distance: hypot(dy,dx) = max(dy,dx) + min(dy,dx) / 2 */ - int d = (dy > dx) ? (dy + (dx>>1)) : (dx + (dy>>1)); + POSITION d = (dy > dx) ? (dy + (dx>>1)) : (dx + (dy>>1)); - int err; + POSITION err; /* Simple case */ if (!dy || !dx) return d; @@ -58,32 +62,35 @@ int distance (int y1, int x1, int y2, int x2) return d; } - -/* - * Return TRUE if the given feature is a trap +/*! + * @brief 地形が罠持ちであるかの判定を行う。 / Return TRUE if the given feature is a trap + * @param feat 地形情報のID + * @return 罠持ちの地形ならばTRUEを返す。 */ -bool is_trap(int feat) +bool is_trap(IDX feat) { return have_flag(f_info[feat].flags, FF_TRAP); } - -/* - * Return TRUE if the given grid is a known trap +/*! + * @brief マスに看破済みの罠があるかの判定を行う。 / Return TRUE if the given grid is a known trap + * @param c_ptr マス構造体の参照ポインタ + * @return 看破済みの罠があるならTRUEを返す。 */ bool is_known_trap(cave_type *c_ptr) { - if (!c_ptr->mimic && !have_flag(f_flags_grid(c_ptr), FF_SECRET) && + if (!c_ptr->mimic && !cave_have_flag_grid(c_ptr, FF_SECRET) && is_trap(c_ptr->feat)) return TRUE; else return FALSE; } - -/* - * Return TRUE if the given grid is a closed door +/*! + * @brief 地形が閉じたドアであるかの判定を行う。 / Return TRUE if the given grid is a closed door + * @param feat 地形情報のID + * @return 閉じたドアのある地形ならばTRUEを返す。 */ -bool is_closed_door(int feat) +bool is_closed_door(IDX feat) { feature_type *f_ptr = &f_info[feat]; @@ -91,59 +98,66 @@ bool is_closed_door(int feat) !have_flag(f_ptr->flags, FF_MOVE); } - -/* - * Return TRUE if the given grid is a hidden closed door +/*! + * @brief マスに隠されたドアがあるかの判定を行う。 / Return TRUE if the given grid is a hidden closed door + * @param c_ptr マス構造体の参照ポインタ + * @return 隠されたドアがあるならTRUEを返す。 */ bool is_hidden_door(cave_type *c_ptr) { - if ((c_ptr->mimic || have_flag(f_flags_grid(c_ptr), FF_SECRET)) && + if ((c_ptr->mimic || cave_have_flag_grid(c_ptr, FF_SECRET)) && is_closed_door(c_ptr->feat)) return TRUE; else return FALSE; } - -/* - * A simple, fast, integer-based line-of-sight algorithm. By Joseph Hall, - * 4116 Brewster Drive, Raleigh NC 27606. Email to jnh@ecemwl.ncsu.edu. - * - * Returns TRUE if a line of sight can be traced from (x1,y1) to (x2,y2). - * - * The LOS begins at the center of the tile (x1,y1) and ends at the center of - * the tile (x2,y2). If los() is to return TRUE, all of the tiles this line - * passes through must be floor tiles, except for (x1,y1) and (x2,y2). - * - * We assume that the "mathematical corner" of a non-floor tile does not - * block line of sight. - * - * Because this function uses (short) ints for all calculations, overflow may - * occur if dx and dy exceed 90. - * - * Once all the degenerate cases are eliminated, the values "qx", "qy", and - * "m" are multiplied by a scale factor "f1 = abs(dx * dy * 2)", so that - * we can use integer arithmetic. - * - * We travel from start to finish along the longer axis, starting at the border - * between the first and second tiles, where the y offset = .5 * slope, taking - * into account the scale factor. See below. - * - * Also note that this function and the "move towards target" code do NOT - * share the same properties. Thus, you can see someone, target them, and - * then fire a bolt at them, but the bolt may hit a wall, not them. However, - * by clever choice of target locations, you can sometimes throw a "curve". - * - * Note that "line of sight" is not "reflexive" in all cases. - * - * Use the "projectable()" routine to test "spell/missile line of sight". - * - * Use the "update_view()" function to determine player line-of-sight. +/*! + * @brief LOS(Line Of Sight / 視線が通っているか)の判定を行う。 + * @param y1 始点のy座標 + * @param x1 始点のx座標 + * @param y2 終点のy座標 + * @param x2 終点のx座標 + * @return LOSが通っているならTRUEを返す。 + * @details + * A simple, fast, integer-based line-of-sight algorithm. By Joseph Hall,\n + * 4116 Brewster Drive, Raleigh NC 27606. Email to jnh@ecemwl.ncsu.edu.\n + *\n + * Returns TRUE if a line of sight can be traced from (x1,y1) to (x2,y2).\n + *\n + * The LOS begins at the center of the tile (x1,y1) and ends at the center of\n + * the tile (x2,y2). If los() is to return TRUE, all of the tiles this line\n + * passes through must be floor tiles, except for (x1,y1) and (x2,y2).\n + *\n + * We assume that the "mathematical corner" of a non-floor tile does not\n + * block line of sight.\n + *\n + * Because this function uses (short) ints for all calculations, overflow may\n + * occur if dx and dy exceed 90.\n + *\n + * Once all the degenerate cases are eliminated, the values "qx", "qy", and\n + * "m" are multiplied by a scale factor "f1 = abs(dx * dy * 2)", so that\n + * we can use integer arithmetic.\n + *\n + * We travel from start to finish along the longer axis, starting at the border\n + * between the first and second tiles, where the y offset = .5 * slope, taking\n + * into account the scale factor. See below.\n + *\n + * Also note that this function and the "move towards target" code do NOT\n + * share the same properties. Thus, you can see someone, target them, and\n + * then fire a bolt at them, but the bolt may hit a wall, not them. However\n, + * by clever choice of target locations, you can sometimes throw a "curve".\n + *\n + * Note that "line of sight" is not "reflexive" in all cases.\n + *\n + * Use the "projectable()" routine to test "spell/missile line of sight".\n + *\n + * Use the "update_view()" function to determine player line-of-sight.\n */ -bool los(int y1, int x1, int y2, int x2) +bool los(POSITION y1, POSITION x1, POSITION y2, POSITION x2) { /* Delta */ - int dx, dy; + POSITION dx, dy; /* Absolute */ int ax, ay; @@ -363,62 +377,196 @@ bool los(int y1, int x1, int y2, int x2) return TRUE; } +#define COMPLEX_WALL_ILLUMINATION /*!< 照明状態を壁により影響を受ける、より複雑な判定に切り替えるマクロ */ - - - -/* - * Check for "local" illumination +/*! + * @brief 指定された座標のマスが現在照らされているかを返す。 / Check for "local" illumination + * @param y y座標 + * @param x x座標 + * @return 指定された座標に照明がかかっているならTRUEを返す。。 */ static bool check_local_illumination(int y, int x) { /* Hack -- move towards player */ - int yy = (y < py) ? (y + 1) : (y > py) ? (y - 1) : y; - int xx = (x < px) ? (x + 1) : (x > px) ? (x - 1) : x; + int yy = (y < p_ptr->y) ? (y + 1) : (y > p_ptr->y) ? (y - 1) : y; + int xx = (x < p_ptr->x) ? (x + 1) : (x > p_ptr->x) ? (x - 1) : x; /* Check for "local" illumination */ - return (cave[yy][xx].info & (CAVE_LITE | CAVE_MNLT)) || - ((cave[yy][xx].info & (CAVE_GLOW | CAVE_MNDK)) == CAVE_GLOW); + +#ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */ + + /* Check for "complex" illumination */ + if ((feat_supports_los(get_feat_mimic(&cave[yy][xx])) && + (cave[yy][xx].info & CAVE_GLOW)) || + (feat_supports_los(get_feat_mimic(&cave[y][xx])) && + (cave[y][xx].info & CAVE_GLOW)) || + (feat_supports_los(get_feat_mimic(&cave[yy][x])) && + (cave[yy][x].info & CAVE_GLOW))) + { + return TRUE; + } + else return FALSE; + +#else /* COMPLEX_WALL_ILLUMINATION */ + + /* Check for "simple" illumination */ + return (cave[yy][xx].info & CAVE_GLOW) ? TRUE : FALSE; + +#endif /* COMPLEX_WALL_ILLUMINATION */ } -/* - * Can the player "see" the given grid in detail? - * - * He must have vision, illumination, and line of sight. - * - * Note -- "CAVE_LITE" is only set if the "torch" has "los()". - * So, given "CAVE_LITE", we know that the grid is "fully visible". - * - * Note that "CAVE_GLOW" makes little sense for a wall, since it would mean - * that a wall is visible from any direction. That would be odd. Except - * under wizard light, which might make sense. Thus, for walls, we require - * not only that they be "CAVE_GLOW", but also, that they be adjacent to a - * grid which is not only "CAVE_GLOW", but which is a non-wall, and which is - * in line of sight of the player. - * - * This extra check is expensive, but it provides a more "correct" semantics. - * - * Note that we should not run this check on walls which are "outer walls" of - * the dungeon, or we will induce a memory fault, but actually verifying all - * of the locations would be extremely expensive. - * - * Thus, to speed up the function, we assume that all "perma-walls" which are - * "CAVE_GLOW" are "illuminated" from all sides. This is correct for all cases - * except "vaults" and the "buildings" in town. But the town is a hack anyway, - * and the player has more important things on his mind when he is attacking a - * monster vault. It is annoying, but an extremely important optimization. - * - * Note that "glowing walls" are only considered to be "illuminated" if the - * grid which is next to the wall in the direction of the player is also a - * "glowing" grid. This prevents the player from being able to "see" the - * walls of illuminated rooms from a corridor outside the room. +/*! 対象座標のマスの照明状態を更新する際の補助処理マクロ */ +#define update_local_illumination_aux(Y, X) \ +{ \ + if (player_has_los_bold((Y), (X))) \ + { \ + /* Update the monster */ \ + if (cave[(Y)][(X)].m_idx) update_mon(cave[(Y)][(X)].m_idx, FALSE); \ +\ + /* Notice and redraw */ \ + note_spot((Y), (X)); \ + lite_spot((Y), (X)); \ + } \ +} + +/*! + * @brief 指定された座標の照明状態を更新する / Update "local" illumination + * @param y y座標 + * @param x x座標 + * @return なし + */ +void update_local_illumination(int y, int x) +{ + int i, yy, xx; + + if (!in_bounds(y, x)) return; + +#ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */ + + if ((y != p_ptr->y) && (x != p_ptr->x)) + { + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); + xx = (x < p_ptr->x) ? (x - 1) : (x + 1); + update_local_illumination_aux(yy, xx); + update_local_illumination_aux(y, xx); + update_local_illumination_aux(yy, x); + } + else if (x != p_ptr->x) /* y == p_ptr->y */ + { + xx = (x < p_ptr->x) ? (x - 1) : (x + 1); + for (i = -1; i <= 1; i++) + { + yy = y + i; + update_local_illumination_aux(yy, xx); + } + yy = y - 1; + update_local_illumination_aux(yy, x); + yy = y + 1; + update_local_illumination_aux(yy, x); + } + else if (y != p_ptr->y) /* x == p_ptr->x */ + { + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); + for (i = -1; i <= 1; i++) + { + xx = x + i; + update_local_illumination_aux(yy, xx); + } + xx = x - 1; + update_local_illumination_aux(y, xx); + xx = x + 1; + update_local_illumination_aux(y, xx); + } + else /* Player's grid */ + { + for (i = 0; i < 8; i++) + { + yy = y + ddy_cdd[i]; + xx = x + ddx_cdd[i]; + update_local_illumination_aux(yy, xx); + } + } + +#else /* COMPLEX_WALL_ILLUMINATION */ + + if ((y != p_ptr->y) && (x != p_ptr->x)) + { + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); + xx = (x < p_ptr->x) ? (x - 1) : (x + 1); + update_local_illumination_aux(yy, xx); + } + else if (x != p_ptr->x) /* y == p_ptr->y */ + { + xx = (x < p_ptr->x) ? (x - 1) : (x + 1); + for (i = -1; i <= 1; i++) + { + yy = y + i; + update_local_illumination_aux(yy, xx); + } + } + else if (y != p_ptr->y) /* x == p_ptr->x */ + { + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); + for (i = -1; i <= 1; i++) + { + xx = x + i; + update_local_illumination_aux(yy, xx); + } + } + else /* Player's grid */ + { + for (i = 0; i < 8; i++) + { + yy = y + ddy_cdd[i]; + xx = x + ddx_cdd[i]; + update_local_illumination_aux(yy, xx); + } + } + +#endif /* COMPLEX_WALL_ILLUMINATION */ +} + + +/*! + * @brief 指定された座標をプレイヤーが視覚に収められるかを返す。 / Can the player "see" the given grid in detail? + * @param y y座標 + * @param x x座標 + * @return 視覚に収められる状態ならTRUEを返す + * @details + * He must have vision, illumination, and line of sight.\n + * \n + * Note -- "CAVE_LITE" is only set if the "torch" has "los()".\n + * So, given "CAVE_LITE", we know that the grid is "fully visible".\n + *\n + * Note that "CAVE_GLOW" makes little sense for a wall, since it would mean\n + * that a wall is visible from any direction. That would be odd. Except\n + * under wizard light, which might make sense. Thus, for walls, we require\n + * not only that they be "CAVE_GLOW", but also, that they be adjacent to a\n + * grid which is not only "CAVE_GLOW", but which is a non-wall, and which is\n + * in line of sight of the player.\n + *\n + * This extra check is expensive, but it provides a more "correct" semantics.\n + *\n + * Note that we should not run this check on walls which are "outer walls" of\n + * the dungeon, or we will induce a memory fault, but actually verifying all\n + * of the locations would be extremely expensive.\n + *\n + * Thus, to speed up the function, we assume that all "perma-walls" which are\n + * "CAVE_GLOW" are "illuminated" from all sides. This is correct for all cases\n + * except "vaults" and the "buildings" in town. But the town is a hack anyway,\n + * and the player has more important things on his mind when he is attacking a\n + * monster vault. It is annoying, but an extremely important optimization.\n + *\n + * Note that "glowing walls" are only considered to be "illuminated" if the\n + * grid which is next to the wall in the direction of the player is also a\n + * "glowing" grid. This prevents the player from being able to "see" the\n + * walls of illuminated rooms from a corridor outside the room.\n */ bool player_can_see_bold(int y, int x) { cave_type *c_ptr; - s16b feat; /* Blind players see nothing */ if (p_ptr->blind) return FALSE; @@ -439,32 +587,31 @@ bool player_can_see_bold(int y, int x) if ((c_ptr->info & (CAVE_GLOW | CAVE_MNDK)) != CAVE_GLOW) return FALSE; /* Feature code (applying "mimic" field) */ - feat = get_feat_mimic(c_ptr); - /* Floors are simple */ - if (feat_supports_los(feat)) return TRUE; + if (feat_supports_los(get_feat_mimic(c_ptr))) return TRUE; /* Check for "local" illumination */ return check_local_illumination(y, x); } - - -/* - * Returns true if the player's grid is dark +/*! + * @brief 指定された座標をプレイヤー収められていない状態かどうか / Returns true if the player's grid is dark + * @return 視覚に収められていないならTRUEを返す + * @details player_can_see_bold()関数の返り値の否定を返している。 */ bool no_lite(void) { - return (!player_can_see_bold(py, px)); + return (!player_can_see_bold(p_ptr->y, p_ptr->x)); } - - -/* - * Determine if a given location may be "destroyed" - * - * Used by destruction spells, and for placing stairs, etc. +/*! + * @brief 指定された座標が地震や階段生成の対象となるマスかを返す。 / Determine if a given location may be "destroyed" + * @param y y座標 + * @param x x座標 + * @return 各種の変更が可能ならTRUEを返す。 + * @details + * 条件は永久地形でなく、なおかつ該当のマスにアーティファクトが存在しないか、である。英語の旧コメントに反して＊破壊＊の抑止判定には現在使われていない。 */ bool cave_valid_bold(int y, int x) { @@ -488,7 +635,7 @@ bool cave_valid_bold(int y, int x) next_o_idx = o_ptr->next_o_idx; /* Forbid artifact grids */ - if ((o_ptr->art_name) || artifact_p(o_ptr)) return (FALSE); + if (object_is_artifact(o_ptr)) return (FALSE); } /* Accept */ @@ -498,54 +645,22 @@ bool cave_valid_bold(int y, int x) -/* - * Determine if a given location may be "destroyed" - * - * Used by destruction spells, and for placing stairs, etc. - */ -bool cave_valid_grid(cave_type *c_ptr) -{ - s16b this_o_idx, next_o_idx = 0; - - - /* Forbid perma-grids */ - if (cave_perma_grid(c_ptr)) return (FALSE); - - /* Check objects */ - for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx) - { - object_type *o_ptr; - - /* Acquire object */ - o_ptr = &o_list[this_o_idx]; - - /* Acquire next object */ - next_o_idx = o_ptr->next_o_idx; - - /* Forbid artifact grids */ - if ((o_ptr->art_name) || artifact_p(o_ptr)) return (FALSE); - } - - /* Accept */ - return (TRUE); -} - - - - -/* - * Hack -- Legal monster codes +/*! + * 一般的にモンスターシンボルとして扱われる記号を定義する(幻覚処理向け) / Hack -- Legal monster codes */ static char image_monster_hack[] = \ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; -/* - * Hack -- Legal object codes +/*! + * 一般的にオブジェクトシンボルとして扱われる記号を定義する(幻覚処理向け) / Hack -- Legal object codes */ static char image_object_hack[] = "?/|\\\"!$()_-=[]{},~"; -/* - * Mega-Hack -- Hallucinatory monster +/*! + * @brief モンスターの表示を幻覚状態に差し替える / Mega-Hack -- Hallucinatory monster + * @param ap 本来の色 + * @param cp 本来のシンボル + * @return なし */ static void image_monster(byte *ap, char *cp) { @@ -569,9 +684,11 @@ static void image_monster(byte *ap, char *cp) } } - -/* - * Mega-Hack -- Hallucinatory object +/*! + * @brief オブジェクトの表示を幻覚状態に差し替える / Hallucinatory object + * @param ap 本来の色 + * @param cp 本来のシンボル + * @return なし */ static void image_object(byte *ap, char *cp) { @@ -594,9 +711,11 @@ static void image_object(byte *ap, char *cp) } - -/* - * Hack -- Random hallucination +/*! + * @brief オブジェクト＆モンスターの表示を幻覚状態に差し替える / Hack -- Random hallucination + * @param ap 本来の色 + * @param cp 本来のシンボル + * @return なし */ static void image_random(byte *ap, char *cp) { @@ -613,16 +732,16 @@ static void image_random(byte *ap, char *cp) } } -/* - * This array lists the effects of "brightness" on various "base" colours. - * - * This is used to do dynamic lighting effects in ascii :-) - * At the moment, only the various "floor" tiles are affected. - * - * The layout of the array is [x][0] = light and [x][1] = dark. +/*! + * 照明の表現を行うための色合いの関係を{暗闇時, 照明時} で定義する / + * This array lists the effects of "brightness" on various "base" colours.\n + *\n + * This is used to do dynamic lighting effects in ascii :-)\n + * At the moment, only the various "floor" tiles are affected.\n + *\n + * The layout of the array is [x][0] = light and [x][1] = dark.\n */ - -byte lighting_colours[16][2] = +static byte lighting_colours[16][2] = { /* TERM_DARK */ {TERM_L_DARK, TERM_DARK}, @@ -673,161 +792,156 @@ byte lighting_colours[16][2] = {TERM_L_UMBER, TERM_UMBER} }; - -/* - * Mega-Hack -- Partial code of map_info() for darkened grids - * Note: Each variable is declared in map_info(). - * This macro modifies "feat", "f_ptr", "c" and "a". +/*! + * @brief 調査中 + * @todo コメントを付加すること */ -#define darkened_grid_hack() \ -{ \ - if (feat_supports_los(feat)) \ - { \ - /* Unsafe cave grid -- idea borrowed from Unangband */ \ - if (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) \ - feat = FEAT_UNDETECTED; \ - else \ - feat = FEAT_NONE; \ -\ - /* Access darkness */ \ - f_ptr = &f_info[feat]; \ -\ - /* Char and attr of darkness */ \ - c = f_ptr->x_char[F_LIT_STANDARD]; \ - a = f_ptr->x_attr[F_LIT_STANDARD]; \ - } \ - else if (view_granite_lite && view_yellow_lite) \ - { \ - /* Use a darkly darkened colour/tile */ \ - a = f_ptr->x_attr[F_LIT_DARKDARK]; \ - c = f_ptr->x_char[F_LIT_DARKDARK]; \ - } \ -} ; +void apply_default_feat_lighting(byte f_attr[F_LIT_MAX], byte f_char[F_LIT_MAX]) +{ + byte s_attr = f_attr[F_LIT_STANDARD]; + byte s_char = f_char[F_LIT_STANDARD]; + int i; + if (is_ascii_graphics(s_attr)) /* For ASCII */ + { + f_attr[F_LIT_LITE] = lighting_colours[s_attr & 0x0f][0]; + f_attr[F_LIT_DARK] = lighting_colours[s_attr & 0x0f][1]; + for (i = F_LIT_NS_BEGIN; i < F_LIT_MAX; i++) f_char[i] = s_char; + } + else /* For tile graphics */ + { + for (i = F_LIT_NS_BEGIN; i < F_LIT_MAX; i++) f_attr[i] = s_attr; + f_char[F_LIT_LITE] = s_char + 2; + f_char[F_LIT_DARK] = s_char + 1; + } +} -/* Is this grid "darkened" by monster? */ + +/*! + * モンスターにより照明が消されている地形か否かを判定する。 / Is this grid "darkened" by monster? + */ #define darkened_grid(C) \ ((((C)->info & (CAVE_VIEW | CAVE_LITE | CAVE_MNLT | CAVE_MNDK)) == (CAVE_VIEW | CAVE_MNDK)) && \ - !p_ptr->see_nocto && !p_ptr->blind) - - -/* - * Extract the attr/char to display at the given (legal) map location - * - * Basically, we "paint" the chosen attr/char in several passes, starting - * with any known "terrain features" (defaulting to darkness), then adding - * any known "objects", and finally, adding any known "monsters". This - * is not the fastest method but since most of the calls to this function - * are made for grids with no monsters or objects, it is fast enough. - * - * Note that this function, if used on the grid containing the "player", - * will return the attr/char of the grid underneath the player, and not - * the actual player attr/char itself, allowing a lot of optimization - * in various "display" functions. - * - * Note that the "zero" entry in the feature/object/monster arrays are - * used to provide "special" attr/char codes, with "monster zero" being - * used for the player attr/char, "object zero" being used for the "stack" - * attr/char, and "feature zero" being used for the "nothing" attr/char, - * though this function makes use of only "feature zero". - * - * Note that monsters can have some "special" flags, including "ATTR_MULTI", - * which means their color changes, and "ATTR_CLEAR", which means they take - * the color of whatever is under them, and "CHAR_CLEAR", which means that - * they take the symbol of whatever is under them. Technically, the flag - * "CHAR_MULTI" is supposed to indicate that a monster looks strange when - * examined, but this flag is currently ignored. - * - * Currently, we do nothing with multi-hued objects, because there are - * not any. If there were, they would have to set "shimmer_objects" - * when they were created, and then new "shimmer" code in "dungeon.c" - * would have to be created handle the "shimmer" effect, and the code - * in "cave.c" would have to be updated to create the shimmer effect. - * - * Note the effects of hallucination. Objects always appear as random - * "objects", monsters as random "monsters", and normal grids occasionally - * appear as random "monsters" or "objects", but note that these random - * "monsters" and "objects" are really just "colored ascii symbols". - * - * Note that "floors" and "invisible traps" (and "zero" features) are - * drawn as "floors" using a special check for optimization purposes, - * and these are the only features which get drawn using the special - * lighting effects activated by "view_special_lite". - * - * Note the use of the "mimic" field in the "terrain feature" processing, - * which allows any feature to "pretend" to be another feature. This is - * used to "hide" secret doors, and to make all "doors" appear the same, - * and all "walls" appear the same, and "hidden" treasure stay hidden. - * It is possible to use this field to make a feature "look" like a floor, - * but the "special lighting effects" for floors will not be used. - * - * Note the use of the new "terrain feature" information. Note that the - * assumption that all interesting "objects" and "terrain features" are - * memorized allows extremely optimized processing below. Note the use - * of separate flags on objects to mark them as memorized allows a grid - * to have memorized "terrain" without granting knowledge of any object - * which may appear in that grid. - * - * Note the efficient code used to determine if a "floor" grid is - * "memorized" or "viewable" by the player, where the test for the - * grid being "viewable" is based on the facts that (1) the grid - * must be "lit" (torch-lit or perma-lit), (2) the grid must be in - * line of sight, and (3) the player must not be blind, and uses the - * assumption that all torch-lit grids are in line of sight. - * - * Note that floors (and invisible traps) are the only grids which are - * not memorized when seen, so only these grids need to check to see if - * the grid is "viewable" to the player (if it is not memorized). Since - * most non-memorized grids are in fact walls, this induces *massive* - * efficiency, at the cost of *forcing* the memorization of non-floor - * grids when they are first seen. Note that "invisible traps" are - * always treated exactly like "floors", which prevents "cheating". - * - * Note the "special lighting effects" which can be activated for floor - * grids using the "view_special_lite" option (for "white" floor grids), - * causing certain grids to be displayed using special colors. If the - * player is "blind", we will use "dark gray", else if the grid is lit - * by the torch, and the "view_yellow_lite" option is set, we will use - * "yellow", else if the grid is "dark", we will use "dark gray", else - * if the grid is not "viewable", and the "view_bright_lite" option is - * set, and the we will use "slate" (gray). We will use "white" for all - * other cases, in particular, for illuminated viewable floor grids. - * - * Note the "special lighting effects" which can be activated for wall - * grids using the "view_granite_lite" option (for "white" wall grids), - * causing certain grids to be displayed using special colors. If the - * player is "blind", we will use "dark gray", else if the grid is lit - * by the torch, and the "view_yellow_lite" option is set, we will use - * "yellow", else if the "view_bright_lite" option is set, and the grid - * is not "viewable", or is "dark", or is glowing, but not when viewed - * from the player's current location, we will use "slate" (gray). We - * will use "white" for all other cases, in particular, for correctly - * illuminated viewable wall grids. - * - * Note that, when "view_granite_lite" is set, we use an inline version - * of the "player_can_see_bold()" function to check the "viewability" of - * grids when the "view_bright_lite" option is set, and we do NOT use - * any special colors for "dark" wall grids, since this would allow the - * player to notice the walls of illuminated rooms from a hallway that - * happened to run beside the room. The alternative, by the way, would - * be to prevent the generation of hallways next to rooms, but this - * would still allow problems when digging towards a room. - * - * Note that bizarre things must be done when the "attr" and/or "char" - * codes have the "high-bit" set, since these values are used to encode - * various "special" pictures in some versions, and certain situations, - * such as "multi-hued" or "clear" monsters, cause the attr/char codes - * to be "scrambled" in various ways. - * - * Note that eventually we may use the "&" symbol for embedded treasure, - * and use the "*" symbol to indicate multiple objects, though this will - * have to wait for Angband 2.8.0 or later. Note that currently, this - * is not important, since only one object or terrain feature is allowed - * in each grid. If needed, "k_info[0]" will hold the "stack" attr/char. - * - * Note the assumption that doing "x_ptr = &x_info[x]" plus a few of - * "x_ptr->xxx", is quicker than "x_info[x].xxx", if this is incorrect - * then a whole lot of code should be changed... XXX XXX + !p_ptr->see_nocto) + + +/*! + * @brief Mコマンドによる縮小マップの表示を行う / Extract the attr/char to display at the given (legal) map location + * @details + * Basically, we "paint" the chosen attr/char in several passes, starting\n + * with any known "terrain features" (defaulting to darkness), then adding\n + * any known "objects", and finally, adding any known "monsters". This\n + * is not the fastest method but since most of the calls to this function\n + * are made for grids with no monsters or objects, it is fast enough.\n + *\n + * Note that this function, if used on the grid containing the "player",\n + * will return the attr/char of the grid underneath the player, and not\n + * the actual player attr/char itself, allowing a lot of optimization\n + * in various "display" functions.\n + *\n + * Note that the "zero" entry in the feature/object/monster arrays are\n + * used to provide "special" attr/char codes, with "monster zero" being\n + * used for the player attr/char, "object zero" being used for the "stack"\n + * attr/char, and "feature zero" being used for the "nothing" attr/char,\n + * though this function makes use of only "feature zero".\n + *\n + * Note that monsters can have some "special" flags, including "ATTR_MULTI",\n + * which means their color changes, and "ATTR_CLEAR", which means they take\n + * the color of whatever is under them, and "CHAR_CLEAR", which means that\n + * they take the symbol of whatever is under them. Technically, the flag\n + * "CHAR_MULTI" is supposed to indicate that a monster looks strange when\n + * examined, but this flag is currently ignored.\n + *\n + * Currently, we do nothing with multi-hued objects, because there are\n + * not any. If there were, they would have to set "shimmer_objects"\n + * when they were created, and then new "shimmer" code in "dungeon.c"\n + * would have to be created handle the "shimmer" effect, and the code\n + * in "cave.c" would have to be updated to create the shimmer effect.\n + *\n + * Note the effects of hallucination. Objects always appear as random\n + * "objects", monsters as random "monsters", and normal grids occasionally\n + * appear as random "monsters" or "objects", but note that these random\n + * "monsters" and "objects" are really just "colored ascii symbols".\n + *\n + * Note that "floors" and "invisible traps" (and "zero" features) are\n + * drawn as "floors" using a special check for optimization purposes,\n + * and these are the only features which get drawn using the special\n + * lighting effects activated by "view_special_lite".\n + *\n + * Note the use of the "mimic" field in the "terrain feature" processing,\n + * which allows any feature to "pretend" to be another feature. This is\n + * used to "hide" secret doors, and to make all "doors" appear the same,\n + * and all "walls" appear the same, and "hidden" treasure stay hidden.\n + * It is possible to use this field to make a feature "look" like a floor,\n + * but the "special lighting effects" for floors will not be used.\n + *\n + * Note the use of the new "terrain feature" information. Note that the\n + * assumption that all interesting "objects" and "terrain features" are\n + * memorized allows extremely optimized processing below. Note the use\n + * of separate flags on objects to mark them as memorized allows a grid\n + * to have memorized "terrain" without granting knowledge of any object\n + * which may appear in that grid.\n + *\n + * Note the efficient code used to determine if a "floor" grid is\n + * "memorized" or "viewable" by the player, where the test for the\n + * grid being "viewable" is based on the facts that (1) the grid\n + * must be "lit" (torch-lit or perma-lit), (2) the grid must be in\n + * line of sight, and (3) the player must not be blind, and uses the\n + * assumption that all torch-lit grids are in line of sight.\n + *\n + * Note that floors (and invisible traps) are the only grids which are\n + * not memorized when seen, so only these grids need to check to see if\n + * the grid is "viewable" to the player (if it is not memorized). Since\n + * most non-memorized grids are in fact walls, this induces *massive*\n + * efficiency, at the cost of *forcing* the memorization of non-floor\n + * grids when they are first seen. Note that "invisible traps" are\n + * always treated exactly like "floors", which prevents "cheating".\n + *\n + * Note the "special lighting effects" which can be activated for floor\n + * grids using the "view_special_lite" option (for "white" floor grids),\n + * causing certain grids to be displayed using special colors. If the\n + * player is "blind", we will use "dark gray", else if the grid is lit\n + * by the torch, and the "view_yellow_lite" option is set, we will use\n + * "yellow", else if the grid is "dark", we will use "dark gray", else\n + * if the grid is not "viewable", and the "view_bright_lite" option is\n + * set, and the we will use "slate" (gray). We will use "white" for all\n + * other cases, in particular, for illuminated viewable floor grids.\n + *\n + * Note the "special lighting effects" which can be activated for wall\n + * grids using the "view_granite_lite" option (for "white" wall grids),\n + * causing certain grids to be displayed using special colors. If the\n + * player is "blind", we will use "dark gray", else if the grid is lit\n + * by the torch, and the "view_yellow_lite" option is set, we will use\n + * "yellow", else if the "view_bright_lite" option is set, and the grid\n + * is not "viewable", or is "dark", or is glowing, but not when viewed\n + * from the player's current location, we will use "slate" (gray). We\n + * will use "white" for all other cases, in particular, for correctly\n + * illuminated viewable wall grids.\n + *\n + * Note that, when "view_granite_lite" is set, we use an inline version\n + * of the "player_can_see_bold()" function to check the "viewability" of\n + * grids when the "view_bright_lite" option is set, and we do NOT use\n + * any special colors for "dark" wall grids, since this would allow the\n + * player to notice the walls of illuminated rooms from a hallway that\n + * happened to run beside the room. The alternative, by the way, would\n + * be to prevent the generation of hallways next to rooms, but this\n + * would still allow problems when digging towards a room.\n + *\n + * Note that bizarre things must be done when the "attr" and/or "char"\n + * codes have the "high-bit" set, since these values are used to encode\n + * various "special" pictures in some versions, and certain situations,\n + * such as "multi-hued" or "clear" monsters, cause the attr/char codes\n + * to be "scrambled" in various ways.\n + *\n + * Note that eventually we may use the "&" symbol for embedded treasure,\n + * and use the "*" symbol to indicate multiple objects, though this will\n + * have to wait for Angband 2.8.0 or later. Note that currently, this\n + * is not important, since only one object or terrain feature is allowed\n + * in each grid. If needed, "k_info[0]" will hold the "stack" attr/char.\n + *\n + * Note the assumption that doing "x_ptr = &x_info[x]" plus a few of\n + * "x_ptr->xxx", is quicker than "x_info[x].xxx", if this is incorrect\n + * then a whole lot of code should be changed... XXX XXX\n */ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) { @@ -848,50 +962,56 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) /* Boring grids (floors, etc) */ if (!have_flag(f_ptr->flags, FF_REMEMBER)) { - /* Memorized (or visible) floor */ - if ((c_ptr->info & CAVE_MARK) || - (((c_ptr->info & (CAVE_LITE | CAVE_MNLT)) || - ((c_ptr->info & CAVE_VIEW) && - (((c_ptr->info & (CAVE_GLOW | CAVE_MNDK)) == CAVE_GLOW) || p_ptr->see_nocto))) && - !p_ptr->blind)) + /* + * Handle Memorized or visible floor + * + * No visual when blinded. + * (to prevent strange effects on darkness breath) + * otherwise, + * - Can see grids with CAVE_MARK. + * - Can see grids with CAVE_LITE or CAVE_MNLT. + * (Such grids also have CAVE_VIEW) + * - Can see grids with CAVE_VIEW unless darkened by monsters. + */ + if (!p_ptr->blind && + ((c_ptr->info & (CAVE_MARK | CAVE_LITE | CAVE_MNLT)) || + ((c_ptr->info & CAVE_VIEW) && (((c_ptr->info & (CAVE_GLOW | CAVE_MNDK)) == CAVE_GLOW) || p_ptr->see_nocto)))) { - /* Normal char */ - c = f_ptr->x_char[F_LIT_STANDARD]; - - /* Normal attr */ + /* Normal attr/char */ a = f_ptr->x_attr[F_LIT_STANDARD]; + c = f_ptr->x_char[F_LIT_STANDARD]; if (p_ptr->wild_mode) { /* Special lighting effects */ - /* Handle "blind" */ - if (view_special_lite && p_ptr->blind) + /* Handle "night" */ + if (view_special_lite && !is_daytime()) { - /* Use a darkly darkened colour/tile */ - a = f_ptr->x_attr[F_LIT_DARKDARK]; - c = f_ptr->x_char[F_LIT_DARKDARK]; + /* Use a darkened colour/tile */ + a = f_ptr->x_attr[F_LIT_DARK]; + c = f_ptr->x_char[F_LIT_DARK]; } } /* Mega-Hack -- Handle "in-sight" and "darkened" grids */ else if (darkened_grid(c_ptr)) { - darkened_grid_hack(); + /* Unsafe cave grid -- idea borrowed from Unangband */ + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; + + /* Access darkness */ + f_ptr = &f_info[feat]; + + /* Char and attr of darkness */ + a = f_ptr->x_attr[F_LIT_STANDARD]; + c = f_ptr->x_char[F_LIT_STANDARD]; } /* Special lighting effects */ else if (view_special_lite) { - /* Handle "blind" */ - if (p_ptr->blind) - { - /* Use a darkly darkened colour/tile */ - a = f_ptr->x_attr[F_LIT_DARKDARK]; - c = f_ptr->x_char[F_LIT_DARKDARK]; - } - /* Handle "torch-lit" grids */ - else if (c_ptr->info & (CAVE_LITE | CAVE_MNLT)) + if (c_ptr->info & (CAVE_LITE | CAVE_MNLT)) { /* Torch lite */ if (view_yellow_lite) @@ -905,9 +1025,9 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) /* Handle "dark" grids */ else if ((c_ptr->info & (CAVE_GLOW | CAVE_MNDK)) != CAVE_GLOW) { - /* Use a darkly darkened colour/tile */ - a = f_ptr->x_attr[F_LIT_DARKDARK]; - c = f_ptr->x_char[F_LIT_DARKDARK]; + /* Use a darkened colour/tile */ + a = f_ptr->x_attr[F_LIT_DARK]; + c = f_ptr->x_char[F_LIT_DARK]; } /* Handle "out-of-sight" grids */ @@ -928,18 +1048,13 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) else { /* Unsafe cave grid -- idea borrowed from Unangband */ - if (view_unsafe_grids && (c_ptr->info & (CAVE_UNSAFE))) - feat = FEAT_UNDETECTED; - else - feat = FEAT_NONE; + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; /* Access darkness */ f_ptr = &f_info[feat]; - /* Normal attr */ + /* Normal attr/char */ a = f_ptr->x_attr[F_LIT_STANDARD]; - - /* Normal char */ c = f_ptr->x_char[F_LIT_STANDARD]; } } @@ -950,17 +1065,15 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) /* Memorized grids */ if (c_ptr->info & CAVE_MARK) { - /* Normal char */ - c = f_ptr->x_char[F_LIT_STANDARD]; - - /* Normal attr */ + /* Normal attr/char */ a = f_ptr->x_attr[F_LIT_STANDARD]; + c = f_ptr->x_char[F_LIT_STANDARD]; if (p_ptr->wild_mode) { /* Special lighting effects */ - /* Handle "blind" */ - if (view_granite_lite && p_ptr->blind) + /* Handle "blind" or "night" */ + if (view_granite_lite && (p_ptr->blind || !is_daytime())) { /* Use a darkened colour/tile */ a = f_ptr->x_attr[F_LIT_DARK]; @@ -969,9 +1082,26 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) } /* Mega-Hack -- Handle "in-sight" and "darkened" grids */ - else if (darkened_grid(c_ptr)) + else if (darkened_grid(c_ptr) && !p_ptr->blind) { - darkened_grid_hack(); + if (have_flag(f_ptr->flags, FF_LOS) && have_flag(f_ptr->flags, FF_PROJECT)) + { + /* Unsafe cave grid -- idea borrowed from Unangband */ + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; + + /* Access darkness */ + f_ptr = &f_info[feat]; + + /* Char and attr of darkness */ + a = f_ptr->x_attr[F_LIT_STANDARD]; + c = f_ptr->x_char[F_LIT_STANDARD]; + } + else if (view_granite_lite && view_bright_lite) + { + /* Use a darkened colour/tile */ + a = f_ptr->x_attr[F_LIT_DARK]; + c = f_ptr->x_char[F_LIT_DARK]; + } } /* Special lighting effects */ @@ -1017,7 +1147,7 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) } /* Not glowing correctly */ - else if (!feat_supports_los(feat) && !check_local_illumination(y, x)) + else if (!have_flag(f_ptr->flags, FF_LOS) && !check_local_illumination(y, x)) { /* Use a darkened colour/tile */ a = f_ptr->x_attr[F_LIT_DARK]; @@ -1031,18 +1161,13 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) else { /* Unsafe cave grid -- idea borrowed from Unangband */ - if (view_unsafe_grids && (c_ptr->info & (CAVE_UNSAFE))) - feat = FEAT_UNDETECTED; - else - feat = FEAT_NONE; + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; /* Access feature */ f_ptr = &f_info[feat]; - /* Normal attr */ + /* Normal attr/char */ a = f_ptr->x_attr[F_LIT_STANDARD]; - - /* Normal char */ c = f_ptr->x_char[F_LIT_STANDARD]; } } @@ -1079,7 +1204,7 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) next_o_idx = o_ptr->next_o_idx; /* Memorized objects */ - if (o_ptr->marked) + if (o_ptr->marked & OM_FOUND) { if (display_autopick) { @@ -1383,10 +1508,10 @@ void note_spot(int y, int x) if (!(c_ptr->info & (CAVE_MARK))) { /* Feature code (applying "mimic" field) */ - s16b feat = get_feat_mimic(c_ptr); + feature_type *f_ptr = &f_info[get_feat_mimic(c_ptr)]; /* Memorize some "boring" grids */ - if (!have_flag(f_info[feat].flags, FF_REMEMBER)) + if (!have_flag(f_ptr->flags, FF_REMEMBER)) { /* Option -- memorize all torch-lit floors */ if (view_torch_grids && @@ -1405,7 +1530,7 @@ void note_spot(int y, int x) } /* Memorize normal grids */ - else if (feat_supports_los(feat)) + else if (have_flag(f_ptr->flags, FF_LOS)) { /* Memorize */ c_ptr->info |= (CAVE_MARK); @@ -1432,6 +1557,9 @@ void note_spot(int y, int x) c_ptr->info |= (CAVE_MARK); } } + + /* Memorize terrain of the grid */ + c_ptr->info |= (CAVE_KNOWN); } @@ -1441,12 +1569,12 @@ void display_dungeon(void) byte a; char c; - byte ta; - char tc; + byte ta = 0; + char tc = '\0'; - for (x = px - Term->wid / 2 + 1; x <= px + Term->wid / 2; x++) + for (x = p_ptr->x - Term->wid / 2 + 1; x <= p_ptr->x + Term->wid / 2; x++) { - for (y = py - Term->hgt / 2 + 1; y <= py + Term->hgt / 2; y++) + for (y = p_ptr->y - Term->hgt / 2 + 1; y <= p_ptr->y + Term->hgt / 2; y++) { if (in_bounds2(y, x)) { @@ -1463,14 +1591,14 @@ void display_dungeon(void) } /* Hack -- Queue it */ - Term_queue_char(x - px + Term->wid / 2 - 1, y - py + Term->hgt / 2 - 1, a, c, ta, tc); + Term_queue_char(x - p_ptr->x + Term->wid / 2 - 1, y - p_ptr->y + Term->hgt / 2 - 1, a, c, ta, tc); } else { /* Clear out-of-bound tiles */ /* Access darkness */ - feature_type *f_ptr = &f_info[FEAT_NONE]; + feature_type *f_ptr = &f_info[feat_none]; /* Normal attr */ a = f_ptr->x_attr[F_LIT_STANDARD]; @@ -1479,7 +1607,7 @@ void display_dungeon(void) c = f_ptr->x_char[F_LIT_STANDARD]; /* Hack -- Queue it */ - Term_queue_char(x - px + Term->wid / 2 - 1, y - py + Term->hgt / 2 - 1, a, c, ta, tc); + Term_queue_char(x - p_ptr->x + Term->wid / 2 - 1, y - p_ptr->y + Term->hgt / 2 - 1, a, c, ta, tc); } } } @@ -1601,7 +1729,7 @@ void prt_map(void) } /* Display player */ - lite_spot(py, px); + lite_spot(p_ptr->y, p_ptr->x); /* Restore the cursor */ (void)Term_set_cursor(v); @@ -1617,14 +1745,14 @@ void prt_path(int y, int x) int i; int path_n; u16b path_g[512]; - int default_color = TERM_SLATE; + byte_hack default_color = TERM_SLATE; if (!display_path) return; if (-1 == project_length) return; /* Get projection path */ - path_n = project_path(path_g, (project_length ? project_length : MAX_RANGE), py, px, y, x, PROJECT_PATH|PROJECT_THRU); + path_n = project_path(path_g, (project_length ? project_length : MAX_RANGE), p_ptr->y, p_ptr->x, y, x, PROJECT_PATH|PROJECT_THRU); /* Redraw map */ p_ptr->redraw |= (PR_MAP); @@ -1674,7 +1802,7 @@ void prt_path(int y, int x) } /* Known Wall */ - if ((c_ptr->info & CAVE_MARK) && !have_flag(f_flags_grid(c_ptr), FF_PROJECT)) break; + if ((c_ptr->info & CAVE_MARK) && !cave_have_flag_grid(c_ptr, FF_PROJECT)) break; /* Change color */ if (nx == x && ny == y) default_color = TERM_L_DARK; @@ -1685,7 +1813,7 @@ void prt_path(int y, int x) static cptr simplify_list[][2] = { #ifdef JP - {"¤ÎËâË¡½ñ", ""}, + {"の魔法書", ""}, {NULL, NULL} #else {"^Ring of ", "="}, @@ -1720,11 +1848,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) if (p_ptr->image) { attr = TERM_WHITE; -#ifdef JP - strcpy(buf, "²¿¤«´ñ̯¤Êʪ"); -#else - strcpy(buf, "something strange"); -#endif + strcpy(buf, _("何か奇妙な物", "something strange")); } for (c = buf; *c; c++) @@ -1758,7 +1882,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) c = buf; len = 0; - /* Ⱦ³Ñ 12 ʸ»úʬ¤ÇÀÚ¤ë */ + /* 半角 12 文字分で切る */ while(*c) { #ifdef JP @@ -1894,7 +2018,7 @@ void display_map(int *cy, int *cx) map_info(j, i, &ta, &tc, &ta, &tc); /* Extract the priority */ - tp = feat_priority; + tp = (byte_hack)feat_priority; if(match_autopick!=-1 && (match_autopick_yx[y][x] == -1 @@ -2022,11 +2146,11 @@ void display_map(int *cy, int *cx) } /* Player location */ - (*cy) = py / yrat + 1 + ROW_MAP; + (*cy) = p_ptr->y / yrat + 1 + ROW_MAP; if (!use_bigtile) - (*cx) = px / xrat + 1 + COL_MAP; + (*cx) = p_ptr->x / xrat + 1 + COL_MAP; else - (*cx) = (px / xrat + 1) * 2 + COL_MAP; + (*cx) = (p_ptr->x / xrat + 1) * 2 + COL_MAP; /* Restore lighting effects */ view_special_lite = old_view_special_lite; @@ -2036,33 +2160,33 @@ void display_map(int *cy, int *cx) for (y = 0; y < (hgt + 2); y++) { /* Free one row each array */ - C_FREE(ma[y], (wid + 2), byte); - C_FREE(mc[y], (wid + 2), char); - C_FREE(mp[y], (wid + 2), byte); - C_FREE(match_autopick_yx[y], (wid + 2), int); - C_FREE(object_autopick_yx[y], (wid + 2), object_type **); + C_KILL(ma[y], (wid + 2), byte); + C_KILL(mc[y], (wid + 2), char); + C_KILL(mp[y], (wid + 2), byte); + C_KILL(match_autopick_yx[y], (wid + 2), int); + C_KILL(object_autopick_yx[y], (wid + 2), object_type *); } /* Free each line map */ - C_FREE(ma, (hgt + 2), byte_ptr); - C_FREE(mc, (hgt + 2), char_ptr); - C_FREE(mp, (hgt + 2), byte_ptr); - C_FREE(match_autopick_yx, (hgt + 2), sint_ptr); - C_FREE(object_autopick_yx, (hgt + 2), object_type **); + C_KILL(ma, (hgt + 2), byte_ptr); + C_KILL(mc, (hgt + 2), char_ptr); + C_KILL(mp, (hgt + 2), byte_ptr); + C_KILL(match_autopick_yx, (hgt + 2), sint_ptr); + C_KILL(object_autopick_yx, (hgt + 2), object_type **); /* Free each line map */ for (y = 0; y < (cur_hgt + 2); y++) { /* Free one row each array */ - C_FREE(bigma[y], (cur_wid + 2), byte); - C_FREE(bigmc[y], (cur_wid + 2), char); - C_FREE(bigmp[y], (cur_wid + 2), byte); + C_KILL(bigma[y], (cur_wid + 2), byte); + C_KILL(bigmc[y], (cur_wid + 2), char); + C_KILL(bigmp[y], (cur_wid + 2), byte); } /* Free each line map */ - C_FREE(bigma, (cur_hgt + 2), byte_ptr); - C_FREE(bigmc, (cur_hgt + 2), char_ptr); - C_FREE(bigmp, (cur_hgt + 2), byte_ptr); + C_KILL(bigma, (cur_hgt + 2), byte_ptr); + C_KILL(bigmc, (cur_hgt + 2), char_ptr); + C_KILL(bigmp, (cur_hgt + 2), byte_ptr); } @@ -2080,11 +2204,7 @@ void do_cmd_view_map(void) screen_save(); /* Note */ -#ifdef JP -prt("¤ªÂÔ¤Á²¼¤µ¤¤...", 0, 0); -#else - prt("Please wait...", 0, 0); -#endif + prt(_("お待ち下さい...", "Please wait..."), 0, 0); /* Flush */ Term_fresh(); @@ -2112,11 +2232,8 @@ prt(" Term_get_size(&wid, &hgt); row_message = hgt - 1; -#ifdef JP - put_str("²¿¤«¥­¡¼¤ò²¡¤·¤Æ¤¯¤À¤µ¤¤('M':½¦¤¦ 'N':ÊüÃÖ 'D':M+N 'K':²õ¤¹¥¢¥¤¥Æ¥à¤òɽ¼¨)", row_message, 1); -#else - put_str(" Hit M, N(for ~), K(for !), or D(same as M+N) to display auto-picker items.", row_message, 1); -#endif + put_str(_("何かキーを押してください('M':拾う 'N':放置 'D':M+N 'K':壊すアイテムを表示)", + " Hit M, N(for ~), K(for !), or D(same as M+N) to display auto-picker items."), row_message, 1); /* Hilite the player */ move_cursor(cy, cx); @@ -2149,11 +2266,8 @@ prt(" } else { -#ifdef JP - put_str("²¿¤«¥­¡¼¤ò²¡¤¹¤È¥²¡¼¥à¤ËÌá¤ê¤Þ¤¹", 23, 30); -#else - put_str("Hit any key to continue", 23, 30); -#endif /* Hilite the player */ + put_str(_("何かキーを押すとゲームに戻ります", "Hit any key to continue"), 23, 30); + /* Hilite the player */ move_cursor(cy, cx); /* Get any key */ inkey(); @@ -2491,7 +2605,7 @@ void update_lite(void) /* forget_lite(); Perhaps don't need? */ /* Add it to later visual update */ - cave_redraw_later(&cave[py][px], py, px); + cave_redraw_later(&cave[p_ptr->y][p_ptr->x], p_ptr->y, p_ptr->x); } #endif @@ -2525,54 +2639,54 @@ void update_lite(void) if (p >= 1) { /* Player grid */ - cave_lite_hack(py, px); + cave_lite_hack(p_ptr->y, p_ptr->x); /* Adjacent grid */ - cave_lite_hack(py+1, px); - cave_lite_hack(py-1, px); - cave_lite_hack(py, px+1); - cave_lite_hack(py, px-1); + cave_lite_hack(p_ptr->y+1, p_ptr->x); + cave_lite_hack(p_ptr->y-1, p_ptr->x); + cave_lite_hack(p_ptr->y, p_ptr->x+1); + cave_lite_hack(p_ptr->y, p_ptr->x-1); /* Diagonal grids */ - cave_lite_hack(py+1, px+1); - cave_lite_hack(py+1, px-1); - cave_lite_hack(py-1, px+1); - cave_lite_hack(py-1, px-1); + cave_lite_hack(p_ptr->y+1, p_ptr->x+1); + cave_lite_hack(p_ptr->y+1, p_ptr->x-1); + cave_lite_hack(p_ptr->y-1, p_ptr->x+1); + cave_lite_hack(p_ptr->y-1, p_ptr->x-1); } /* Radius 2 -- lantern radius */ if (p >= 2) { /* South of the player */ - if (cave_los_bold(py + 1, px)) + if (cave_los_bold(p_ptr->y + 1, p_ptr->x)) { - cave_lite_hack(py+2, px); - cave_lite_hack(py+2, px+1); - cave_lite_hack(py+2, px-1); + cave_lite_hack(p_ptr->y+2, p_ptr->x); + cave_lite_hack(p_ptr->y+2, p_ptr->x+1); + cave_lite_hack(p_ptr->y+2, p_ptr->x-1); } /* North of the player */ - if (cave_los_bold(py - 1, px)) + if (cave_los_bold(p_ptr->y - 1, p_ptr->x)) { - cave_lite_hack(py-2, px); - cave_lite_hack(py-2, px+1); - cave_lite_hack(py-2, px-1); + cave_lite_hack(p_ptr->y-2, p_ptr->x); + cave_lite_hack(p_ptr->y-2, p_ptr->x+1); + cave_lite_hack(p_ptr->y-2, p_ptr->x-1); } /* East of the player */ - if (cave_los_bold(py, px + 1)) + if (cave_los_bold(p_ptr->y, p_ptr->x + 1)) { - cave_lite_hack(py, px+2); - cave_lite_hack(py+1, px+2); - cave_lite_hack(py-1, px+2); + cave_lite_hack(p_ptr->y, p_ptr->x+2); + cave_lite_hack(p_ptr->y+1, p_ptr->x+2); + cave_lite_hack(p_ptr->y-1, p_ptr->x+2); } /* West of the player */ - if (cave_los_bold(py, px - 1)) + if (cave_los_bold(p_ptr->y, p_ptr->x - 1)) { - cave_lite_hack(py, px-2); - cave_lite_hack(py+1, px-2); - cave_lite_hack(py-1, px-2); + cave_lite_hack(p_ptr->y, p_ptr->x-2); + cave_lite_hack(p_ptr->y+1, p_ptr->x-2); + cave_lite_hack(p_ptr->y-1, p_ptr->x-2); } } @@ -2585,43 +2699,43 @@ void update_lite(void) if (p > 14) p = 14; /* South-East of the player */ - if (cave_los_bold(py + 1, px + 1)) + if (cave_los_bold(p_ptr->y + 1, p_ptr->x + 1)) { - cave_lite_hack(py+2, px+2); + cave_lite_hack(p_ptr->y+2, p_ptr->x+2); } /* South-West of the player */ - if (cave_los_bold(py + 1, px - 1)) + if (cave_los_bold(p_ptr->y + 1, p_ptr->x - 1)) { - cave_lite_hack(py+2, px-2); + cave_lite_hack(p_ptr->y+2, p_ptr->x-2); } /* North-East of the player */ - if (cave_los_bold(py - 1, px + 1)) + if (cave_los_bold(p_ptr->y - 1, p_ptr->x + 1)) { - cave_lite_hack(py-2, px+2); + cave_lite_hack(p_ptr->y-2, p_ptr->x+2); } /* North-West of the player */ - if (cave_los_bold(py - 1, px - 1)) + if (cave_los_bold(p_ptr->y - 1, p_ptr->x - 1)) { - cave_lite_hack(py-2, px-2); + cave_lite_hack(p_ptr->y-2, p_ptr->x-2); } /* Maximal north */ - min_y = py - p; + min_y = p_ptr->y - p; if (min_y < 0) min_y = 0; /* Maximal south */ - max_y = py + p; + max_y = p_ptr->y + p; if (max_y > cur_hgt-1) max_y = cur_hgt-1; /* Maximal west */ - min_x = px - p; + min_x = p_ptr->x - p; if (min_x < 0) min_x = 0; /* Maximal east */ - max_x = px + p; + max_x = p_ptr->x + p; if (max_x > cur_wid-1) max_x = cur_wid-1; /* Scan the maximal box */ @@ -2629,8 +2743,8 @@ void update_lite(void) { for (x = min_x; x <= max_x; x++) { - int dy = (py > y) ? (py - y) : (y - py); - int dx = (px > x) ? (px - x) : (x - px); + int dy = (p_ptr->y > y) ? (p_ptr->y - y) : (y - p_ptr->y); + int dx = (p_ptr->x > x) ? (p_ptr->x - x) : (x - p_ptr->x); /* Skip the "central" grids (above) */ if ((dy <= 2) && (dx <= 2)) continue; @@ -2642,7 +2756,7 @@ void update_lite(void) if (d > p) continue; /* Viewable, nearby, grids get "torch lit" */ - if (player_has_los_bold(y, x)) + if (cave[y][x].info & CAVE_VIEW) { /* This grid is "torch lit" */ cave_lite_hack(y, x); @@ -2696,15 +2810,16 @@ void update_lite(void) static bool mon_invis; -static s16b mon_fy, mon_fx; +static POSITION mon_fy, mon_fx; /* * Add a square to the changes array */ -static void mon_lite_hack(int y, int x) +static void mon_lite_hack(POSITION y, POSITION x) { cave_type *c_ptr; - int midpoint, dpf, d; + int dpf, d; + POSITION midpoint; /* We trust this grid is in bounds */ /* if (!in_bounds2(y, x)) return; */ @@ -2716,17 +2831,14 @@ static void mon_lite_hack(int y, int x) if (!cave_los_grid(c_ptr)) { - /* Hack XXX XXX - Is it a wall and monster not in LOS? */ - if (mon_invis) return; - /* Hack -- Prevent monster lite leakage in walls */ /* Horizontal walls between player and a monster */ - if (((y < py) && (y > mon_fy)) || ((y > py) && (y < mon_fy))) + if (((y < p_ptr->y) && (y > mon_fy)) || ((y > p_ptr->y) && (y < mon_fy))) { - dpf = py - mon_fy; + dpf = p_ptr->y - mon_fy; d = y - mon_fy; - midpoint = mon_fx + ((px - mon_fx) * ABS(d)) / ABS(dpf); + midpoint = mon_fx + ((p_ptr->x - mon_fx) * ABS(d)) / ABS(dpf); /* Only first wall viewed from mid-x is lit */ if (x < midpoint) @@ -2737,14 +2849,17 @@ static void mon_lite_hack(int y, int x) { if (!cave_los_bold(y, x - 1)) return; } + + /* Hack XXX XXX - Is it a wall and monster not in LOS? */ + else if (mon_invis) return; } /* Vertical walls between player and a monster */ - if (((x < px) && (x > mon_fx)) || ((x > px) && (x < mon_fx))) + if (((x < p_ptr->x) && (x > mon_fx)) || ((x > p_ptr->x) && (x < mon_fx))) { - dpf = px - mon_fx; + dpf = p_ptr->x - mon_fx; d = x - mon_fx; - midpoint = mon_fy + ((py - mon_fy) * ABS(d)) / ABS(dpf); + midpoint = mon_fy + ((p_ptr->y - mon_fy) * ABS(d)) / ABS(dpf); /* Only first wall viewed from mid-y is lit */ if (y < midpoint) @@ -2755,6 +2870,9 @@ static void mon_lite_hack(int y, int x) { if (!cave_los_bold(y - 1, x)) return; } + + /* Hack XXX XXX - Is it a wall and monster not in LOS? */ + else if (mon_invis) return; } } @@ -2784,7 +2902,7 @@ static void mon_lite_hack(int y, int x) /* * Add a square to the changes array */ -static void mon_dark_hack(int y, int x) +static void mon_dark_hack(POSITION y, POSITION x) { cave_type *c_ptr; int midpoint, dpf, d; @@ -2797,47 +2915,50 @@ static void mon_dark_hack(int y, int x) /* Want a unlit and undarkened square in view of the player */ if ((c_ptr->info & (CAVE_LITE | CAVE_MNLT | CAVE_MNDK | CAVE_VIEW)) != CAVE_VIEW) return; - if (!cave_los_grid(c_ptr)) + if (!cave_los_grid(c_ptr) && !cave_have_flag_grid(c_ptr, FF_PROJECT)) { - /* Hack XXX XXX - Is it a wall and monster not in LOS? */ - if (mon_invis) return; - /* Hack -- Prevent monster dark lite leakage in walls */ /* Horizontal walls between player and a monster */ - if (((y < py) && (y > mon_fy)) || ((y > py) && (y < mon_fy))) + if (((y < p_ptr->y) && (y > mon_fy)) || ((y > p_ptr->y) && (y < mon_fy))) { - dpf = py - mon_fy; + dpf = p_ptr->y - mon_fy; d = y - mon_fy; - midpoint = mon_fx + ((px - mon_fx) * ABS(d)) / ABS(dpf); + midpoint = mon_fx + ((p_ptr->x - mon_fx) * ABS(d)) / ABS(dpf); /* Only first wall viewed from mid-x is lit */ if (x < midpoint) { - if (!cave_los_bold(y, x + 1)) return; + if (!cave_los_bold(y, x + 1) && !cave_have_flag_bold(y, x + 1, FF_PROJECT)) return; } else if (x > midpoint) { - if (!cave_los_bold(y, x - 1)) return; + if (!cave_los_bold(y, x - 1) && !cave_have_flag_bold(y, x - 1, FF_PROJECT)) return; } + + /* Hack XXX XXX - Is it a wall and monster not in LOS? */ + else if (mon_invis) return; } /* Vertical walls between player and a monster */ - if (((x < px) && (x > mon_fx)) || ((x > px) && (x < mon_fx))) + if (((x < p_ptr->x) && (x > mon_fx)) || ((x > p_ptr->x) && (x < mon_fx))) { - dpf = px - mon_fx; + dpf = p_ptr->x - mon_fx; d = x - mon_fx; - midpoint = mon_fy + ((py - mon_fy) * ABS(d)) / ABS(dpf); + midpoint = mon_fy + ((p_ptr->y - mon_fy) * ABS(d)) / ABS(dpf); /* Only first wall viewed from mid-y is lit */ if (y < midpoint) { - if (!cave_los_bold(y + 1, x)) return; + if (!cave_los_bold(y + 1, x) && !cave_have_flag_bold(y + 1, x, FF_PROJECT)) return; } else if (y > midpoint) { - if (!cave_los_bold(y - 1, x)) return; + if (!cave_los_bold(y - 1, x) && !cave_have_flag_bold(y - 1, x, FF_PROJECT)) return; } + + /* Hack XXX XXX - Is it a wall and monster not in LOS? */ + else if (mon_invis) return; } } @@ -2868,8 +2989,9 @@ void update_mon_lite(void) int i, rad; cave_type *c_ptr; - s16b fx, fy; - void (*add_mon_lite)(int, int); + POSITION fx, fy; + void (*add_mon_lite)(POSITION, POSITION); + int f_flag; s16b end_temp; @@ -2893,166 +3015,172 @@ void update_mon_lite(void) /* Empty temp list of new squares to lite up */ temp_n = 0; - /* Loop through monsters, adding newly lit squares to changes list */ - for (i = 1; i < m_max; i++) + /* If a monster stops time, don't process */ + if (!world_monster) { - monster_type *m_ptr = &m_list[i]; - monster_race *r_ptr = &r_info[m_ptr->r_idx]; + monster_type *m_ptr; + monster_race *r_ptr; - /* Skip dead monsters */ - if (!m_ptr->r_idx) continue; + /* Loop through monsters, adding newly lit squares to changes list */ + for (i = 1; i < m_max; i++) + { + m_ptr = &m_list[i]; + r_ptr = &r_info[m_ptr->r_idx]; - /* Is it too far away? */ - if (m_ptr->cdis > dis_lim) continue; + /* Skip dead monsters */ + if (!m_ptr->r_idx) continue; - /* If a monster stops time, break */ - if (world_monster) break; + /* Is it too far away? */ + if (m_ptr->cdis > dis_lim) continue; - /* Get lite radius */ - rad = 0; + /* Get lite radius */ + rad = 0; - /* Note the radii are cumulative */ - if (r_ptr->flags7 & (RF7_HAS_LITE_1 | RF7_SELF_LITE_1)) rad++; - if (r_ptr->flags7 & (RF7_HAS_LITE_2 | RF7_SELF_LITE_2)) rad += 2; - if (r_ptr->flags7 & (RF7_HAS_DARK_1 | RF7_SELF_DARK_1)) rad--; - if (r_ptr->flags7 & (RF7_HAS_DARK_2 | RF7_SELF_DARK_2)) rad -= 2; + /* Note the radii are cumulative */ + if (r_ptr->flags7 & (RF7_HAS_LITE_1 | RF7_SELF_LITE_1)) rad++; + if (r_ptr->flags7 & (RF7_HAS_LITE_2 | RF7_SELF_LITE_2)) rad += 2; + if (r_ptr->flags7 & (RF7_HAS_DARK_1 | RF7_SELF_DARK_1)) rad--; + if (r_ptr->flags7 & (RF7_HAS_DARK_2 | RF7_SELF_DARK_2)) rad -= 2; - /* Exit if has no light */ - if (!rad) continue; - else if (rad > 0) - { - if (!(r_ptr->flags7 & (RF7_SELF_LITE_1 | RF7_SELF_LITE_2)) && (m_ptr->csleep || (!dun_level && is_daytime()) || p_ptr->inside_battle)) continue; - if (d_info[dungeon_type].flags1 & DF1_DARKNESS) rad = 1; - add_mon_lite = mon_lite_hack; - } - else - { - if (!(r_ptr->flags7 & (RF7_SELF_DARK_1 | RF7_SELF_DARK_2)) && (m_ptr->csleep || (!dun_level && !is_daytime()))) continue; - add_mon_lite = mon_dark_hack; - rad = -rad; /* Use absolute value */ - } + /* Exit if has no light */ + if (!rad) continue; + else if (rad > 0) + { + if (!(r_ptr->flags7 & (RF7_SELF_LITE_1 | RF7_SELF_LITE_2)) && (MON_CSLEEP(m_ptr) || (!dun_level && is_daytime()) || p_ptr->inside_battle)) continue; + if (d_info[dungeon_type].flags1 & DF1_DARKNESS) rad = 1; + add_mon_lite = mon_lite_hack; + f_flag = FF_LOS; + } + else + { + if (!(r_ptr->flags7 & (RF7_SELF_DARK_1 | RF7_SELF_DARK_2)) && (MON_CSLEEP(m_ptr) || (!dun_level && !is_daytime()))) continue; + add_mon_lite = mon_dark_hack; + f_flag = FF_PROJECT; + rad = -rad; /* Use absolute value */ + } - /* Access the location */ - mon_fx = m_ptr->fx; - mon_fy = m_ptr->fy; + /* Access the location */ + mon_fx = m_ptr->fx; + mon_fy = m_ptr->fy; - /* Is the monster visible? */ - mon_invis = !(cave[mon_fy][mon_fx].info & CAVE_VIEW); + /* Is the monster visible? */ + mon_invis = !(cave[mon_fy][mon_fx].info & CAVE_VIEW); - /* The square it is on */ - add_mon_lite(mon_fy, mon_fx); + /* The square it is on */ + add_mon_lite(mon_fy, mon_fx); - /* Adjacent squares */ - add_mon_lite(mon_fy + 1, mon_fx); - add_mon_lite(mon_fy - 1, mon_fx); - add_mon_lite(mon_fy, mon_fx + 1); - add_mon_lite(mon_fy, mon_fx - 1); - add_mon_lite(mon_fy + 1, mon_fx + 1); - add_mon_lite(mon_fy + 1, mon_fx - 1); - add_mon_lite(mon_fy - 1, mon_fx + 1); - add_mon_lite(mon_fy - 1, mon_fx - 1); + /* Adjacent squares */ + add_mon_lite(mon_fy + 1, mon_fx); + add_mon_lite(mon_fy - 1, mon_fx); + add_mon_lite(mon_fy, mon_fx + 1); + add_mon_lite(mon_fy, mon_fx - 1); + add_mon_lite(mon_fy + 1, mon_fx + 1); + add_mon_lite(mon_fy + 1, mon_fx - 1); + add_mon_lite(mon_fy - 1, mon_fx + 1); + add_mon_lite(mon_fy - 1, mon_fx - 1); - /* Radius 2 */ - if (rad >= 2) - { - /* South of the monster */ - if (cave_los_bold(mon_fy + 1, mon_fx)) + /* Radius 2 */ + if (rad >= 2) { - add_mon_lite(mon_fy + 2, mon_fx + 1); - add_mon_lite(mon_fy + 2, mon_fx); - add_mon_lite(mon_fy + 2, mon_fx - 1); + /* South of the monster */ + if (cave_have_flag_bold(mon_fy + 1, mon_fx, f_flag)) + { + add_mon_lite(mon_fy + 2, mon_fx + 1); + add_mon_lite(mon_fy + 2, mon_fx); + add_mon_lite(mon_fy + 2, mon_fx - 1); - c_ptr = &cave[mon_fy + 2][mon_fx]; + c_ptr = &cave[mon_fy + 2][mon_fx]; - /* Radius 3 */ - if ((rad == 3) && cave_los_grid(c_ptr)) - { - add_mon_lite(mon_fy + 3, mon_fx + 1); - add_mon_lite(mon_fy + 3, mon_fx); - add_mon_lite(mon_fy + 3, mon_fx - 1); + /* Radius 3 */ + if ((rad == 3) && cave_have_flag_grid(c_ptr, f_flag)) + { + add_mon_lite(mon_fy + 3, mon_fx + 1); + add_mon_lite(mon_fy + 3, mon_fx); + add_mon_lite(mon_fy + 3, mon_fx - 1); + } } - } - /* North of the monster */ - if (cave_los_bold(mon_fy - 1, mon_fx)) - { - add_mon_lite(mon_fy - 2, mon_fx + 1); - add_mon_lite(mon_fy - 2, mon_fx); - add_mon_lite(mon_fy - 2, mon_fx - 1); + /* North of the monster */ + if (cave_have_flag_bold(mon_fy - 1, mon_fx, f_flag)) + { + add_mon_lite(mon_fy - 2, mon_fx + 1); + add_mon_lite(mon_fy - 2, mon_fx); + add_mon_lite(mon_fy - 2, mon_fx - 1); - c_ptr = &cave[mon_fy - 2][mon_fx]; + c_ptr = &cave[mon_fy - 2][mon_fx]; - /* Radius 3 */ - if ((rad == 3) && cave_los_grid(c_ptr)) - { - add_mon_lite(mon_fy - 3, mon_fx + 1); - add_mon_lite(mon_fy - 3, mon_fx); - add_mon_lite(mon_fy - 3, mon_fx - 1); + /* Radius 3 */ + if ((rad == 3) && cave_have_flag_grid(c_ptr, f_flag)) + { + add_mon_lite(mon_fy - 3, mon_fx + 1); + add_mon_lite(mon_fy - 3, mon_fx); + add_mon_lite(mon_fy - 3, mon_fx - 1); + } } - } - /* East of the monster */ - if (cave_los_bold(mon_fy, mon_fx + 1)) - { - add_mon_lite(mon_fy + 1, mon_fx + 2); - add_mon_lite(mon_fy, mon_fx + 2); - add_mon_lite(mon_fy - 1, mon_fx + 2); + /* East of the monster */ + if (cave_have_flag_bold(mon_fy, mon_fx + 1, f_flag)) + { + add_mon_lite(mon_fy + 1, mon_fx + 2); + add_mon_lite(mon_fy, mon_fx + 2); + add_mon_lite(mon_fy - 1, mon_fx + 2); - c_ptr = &cave[mon_fy][mon_fx + 2]; + c_ptr = &cave[mon_fy][mon_fx + 2]; - /* Radius 3 */ - if ((rad == 3) && cave_los_grid(c_ptr)) - { - add_mon_lite(mon_fy + 1, mon_fx + 3); - add_mon_lite(mon_fy, mon_fx + 3); - add_mon_lite(mon_fy - 1, mon_fx + 3); + /* Radius 3 */ + if ((rad == 3) && cave_have_flag_grid(c_ptr, f_flag)) + { + add_mon_lite(mon_fy + 1, mon_fx + 3); + add_mon_lite(mon_fy, mon_fx + 3); + add_mon_lite(mon_fy - 1, mon_fx + 3); + } } - } - /* West of the monster */ - if (cave_los_bold(mon_fy, mon_fx - 1)) - { - add_mon_lite(mon_fy + 1, mon_fx - 2); - add_mon_lite(mon_fy, mon_fx - 2); - add_mon_lite(mon_fy - 1, mon_fx - 2); + /* West of the monster */ + if (cave_have_flag_bold(mon_fy, mon_fx - 1, f_flag)) + { + add_mon_lite(mon_fy + 1, mon_fx - 2); + add_mon_lite(mon_fy, mon_fx - 2); + add_mon_lite(mon_fy - 1, mon_fx - 2); - c_ptr = &cave[mon_fy][mon_fx - 2]; + c_ptr = &cave[mon_fy][mon_fx - 2]; - /* Radius 3 */ - if ((rad == 3) && cave_los_grid(c_ptr)) - { - add_mon_lite(mon_fy + 1, mon_fx - 3); - add_mon_lite(mon_fy, mon_fx - 3); - add_mon_lite(mon_fy - 1, mon_fx - 3); + /* Radius 3 */ + if ((rad == 3) && cave_have_flag_grid(c_ptr, f_flag)) + { + add_mon_lite(mon_fy + 1, mon_fx - 3); + add_mon_lite(mon_fy, mon_fx - 3); + add_mon_lite(mon_fy - 1, mon_fx - 3); + } } } - } - /* Radius 3 */ - if (rad == 3) - { - /* South-East of the monster */ - if (cave_los_bold(mon_fy + 1, mon_fx + 1)) + /* Radius 3 */ + if (rad == 3) { - add_mon_lite(mon_fy + 2, mon_fx + 2); - } + /* South-East of the monster */ + if (cave_have_flag_bold(mon_fy + 1, mon_fx + 1, f_flag)) + { + add_mon_lite(mon_fy + 2, mon_fx + 2); + } - /* South-West of the monster */ - if (cave_los_bold(mon_fy + 1, mon_fx - 1)) - { - add_mon_lite(mon_fy + 2, mon_fx - 2); - } + /* South-West of the monster */ + if (cave_have_flag_bold(mon_fy + 1, mon_fx - 1, f_flag)) + { + add_mon_lite(mon_fy + 2, mon_fx - 2); + } - /* North-East of the monster */ - if (cave_los_bold(mon_fy - 1, mon_fx + 1)) - { - add_mon_lite(mon_fy - 2, mon_fx + 2); - } + /* North-East of the monster */ + if (cave_have_flag_bold(mon_fy - 1, mon_fx + 1, f_flag)) + { + add_mon_lite(mon_fy - 2, mon_fx + 2); + } - /* North-West of the monster */ - if (cave_los_bold(mon_fy - 1, mon_fx - 1)) - { - add_mon_lite(mon_fy - 2, mon_fx - 2); + /* North-West of the monster */ + if (cave_have_flag_bold(mon_fy - 1, mon_fx - 1, f_flag)) + { + add_mon_lite(mon_fy - 2, mon_fx - 2); + } } } } @@ -3095,8 +3223,8 @@ void update_mon_lite(void) } /* Add to end of temp array */ - temp_x[temp_n] = (byte)fx; - temp_y[temp_n] = (byte)fy; + temp_x[temp_n] = fx; + temp_y[temp_n] = fy; temp_n++; } @@ -3155,7 +3283,7 @@ void update_mon_lite(void) /* Mega-Hack -- Visual update later */ p_ptr->update |= (PU_DELAY_VIS); - p_ptr->monlite = (cave[py][px].info & CAVE_MNLT) ? TRUE : FALSE; + p_ptr->monlite = (cave[p_ptr->y][p_ptr->x].info & CAVE_MNLT) ? TRUE : FALSE; if (p_ptr->special_defense & NINJA_S_STEALTH) { @@ -3163,19 +3291,11 @@ void update_mon_lite(void) { if (p_ptr->monlite) { -#ifdef JP - msg_print("±Æ¤Îʤ¤¤¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£"); -#else - msg_print("Your mantle of shadow become thin."); -#endif + msg_print(_("影の覆いが薄れた気がする。", "Your mantle of shadow become thin.")); } else { -#ifdef JP - msg_print("±Æ¤Îʤ¤¤¤¬Ç»¤¯¤Ê¤Ã¤¿¡ª"); -#else - msg_print("Your mantle of shadow restored its original darkness."); -#endif + msg_print(_("影の覆いが濃くなった！", "Your mantle of shadow restored its original darkness.")); } } } @@ -3227,7 +3347,7 @@ void forget_view(void) /* Forget that the grid is viewable */ c_ptr->info &= ~(CAVE_VIEW); - if (!panel_contains(y, x)) continue; + /* if (!panel_contains(y, x)) continue; */ /* Update the screen */ /* lite_spot(y, x); Perhaps don't need? */ @@ -3263,8 +3383,8 @@ void forget_view(void) * * This function assumes that (y,x) is legal (i.e. on the map). * - * Grid (y1,x1) is on the "diagonal" between (py,px) and (y,x) - * Grid (y2,x2) is "adjacent", also between (py,px) and (y,x). + * Grid (y1,x1) is on the "diagonal" between (p_ptr->y,p_ptr->x) and (y,x) + * Grid (y2,x2) is "adjacent", also between (p_ptr->y,p_ptr->x) and (y,x). * * Note that we are using the "CAVE_XTRA" field for marking grids as * "easily viewable". This bit is cleared at the end of "update_view()". @@ -3354,7 +3474,7 @@ static bool update_view_aux(int y, int x, int y1, int x1, int y2, int x2) /* Hack -- check line of sight */ - if (los(py, px, y, x)) + if (los(p_ptr->y, p_ptr->x, y, x)) { cave_view_hack(c_ptr, y, x); @@ -3461,14 +3581,15 @@ static bool update_view_aux(int y, int x, int y1, int x1, int y2, int x2) */ void update_view(void) { - int n, m, d, k, y, x, z; + int n, m, d, k, z; + POSITION y, x; int se, sw, ne, nw, es, en, ws, wn; int full, over; - int y_max = cur_hgt - 1; - int x_max = cur_wid - 1; + POSITION y_max = cur_hgt - 1; + POSITION x_max = cur_wid - 1; cave_type *c_ptr; @@ -3524,8 +3645,8 @@ void update_view(void) /*** Step 1 -- adjacent grids ***/ /* Now start on the player */ - y = py; - x = px; + y = p_ptr->y; + x = p_ptr->x; /* Access the grid */ c_ptr = &cave[y][x]; @@ -3981,8 +4102,8 @@ void forget_flow(void) * it everytime the player moves out of LOS of the last * "way-point". */ -static u16b flow_x = 0; -static u16b flow_y = 0; +static POSITION flow_x = 0; +static POSITION flow_y = 0; @@ -4001,7 +4122,7 @@ static u16b flow_y = 0; */ void update_flow(void) { - int x, y, d; + POSITION x, y, d; int flow_head = 1; int flow_tail = 0; @@ -4026,12 +4147,12 @@ void update_flow(void) } /* Save player position */ - flow_y = py; - flow_x = px; + flow_y = p_ptr->y; + flow_x = p_ptr->x; /* Add the player's grid to the queue */ - temp_y[0] = py; - temp_x[0] = px; + temp_y[0] = p_ptr->y; + temp_x[0] = p_ptr->x; /* Now process the queue */ while (flow_head != flow_tail) @@ -4049,8 +4170,8 @@ void update_flow(void) for (d = 0; d < 8; d++) { int old_head = flow_head; - int m = cave[ty][tx].cost + 1; - int n = cave[ty][tx].dist + 1; + byte_hack m = cave[ty][tx].cost + 1; + byte_hack n = cave[ty][tx].dist + 1; cave_type *c_ptr; /* Child location */ @@ -4068,7 +4189,7 @@ void update_flow(void) if (c_ptr->dist != 0 && c_ptr->dist <= n && c_ptr->cost <= m) continue; /* Ignore "walls" and "rubble" */ - if (!have_flag(f_flags_grid(c_ptr), FF_MOVE) && !is_closed_door(c_ptr->feat)) continue; + if (!cave_have_flag_grid(c_ptr, FF_MOVE) && !is_closed_door(c_ptr->feat)) continue; /* Save the flow cost */ if (c_ptr->cost == 0 || c_ptr->cost > m) c_ptr->cost = m; @@ -4150,8 +4271,8 @@ void update_smell(void) cave_type *c_ptr; /* Translate table to map grids */ - y = i + py - 2; - x = j + px - 2; + y = i + p_ptr->y - 2; + x = j + p_ptr->x - 2; /* Check Bounds */ if (!in_bounds(y, x)) continue; @@ -4159,7 +4280,7 @@ void update_smell(void) c_ptr = &cave[y][x]; /* Walls, water, and lava cannot hold scent. */ - if (!have_flag(f_flags_grid(c_ptr), FF_MOVE) && !is_closed_door(c_ptr->feat)) continue; + if (!cave_have_flag_grid(c_ptr, FF_MOVE) && !is_closed_door(c_ptr->feat)) continue; /* Grid must not be blocked by walls from the character */ if (!player_has_los_bold(y, x)) continue; @@ -4177,7 +4298,7 @@ void update_smell(void) /* * Hack -- map the current panel (plus some) ala "magic mapping" */ -void map_area(int range) +void map_area(POSITION range) { int i, x, y; cave_type *c_ptr; @@ -4191,10 +4312,13 @@ void map_area(int range) { for (x = 1; x < cur_wid - 1; x++) { - if (distance(py, px, y, x) > range) continue; + if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue; c_ptr = &cave[y][x]; + /* Memorize terrain of the grid */ + c_ptr->info |= (CAVE_KNOWN); + /* Feature code (applying "mimic" field) */ feat = get_feat_mimic(c_ptr); f_ptr = &f_info[feat]; @@ -4283,6 +4407,9 @@ void wiz_lite(bool ninja) { cave_type *c_ptr = &cave[y][x]; + /* Memorize terrain of the grid */ + c_ptr->info |= (CAVE_KNOWN); + /* Feature code (applying "mimic" field) */ feat = get_feat_mimic(c_ptr); f_ptr = &f_info[feat]; @@ -4338,6 +4465,11 @@ void wiz_lite(bool ninja) /* Window stuff */ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON); + + if (p_ptr->special_defense & NINJA_S_STEALTH) + { + if (cave[p_ptr->y][p_ptr->x].info & CAVE_GLOW) set_superstealth(FALSE); + } } @@ -4357,7 +4489,7 @@ void wiz_dark(void) cave_type *c_ptr = &cave[y][x]; /* Process the grid */ - c_ptr->info &= ~(CAVE_MARK | CAVE_IN_DETECT); + c_ptr->info &= ~(CAVE_MARK | CAVE_IN_DETECT | CAVE_KNOWN); c_ptr->info |= (CAVE_UNSAFE); } } @@ -4388,9 +4520,12 @@ void wiz_dark(void) if (o_ptr->held_m_idx) continue; /* Forget the object */ - o_ptr->marked = 0; + o_ptr->marked &= OM_TOUCHED; } + /* Forget travel route when we have forgotten map */ + forget_travel_flow(); + /* Mega-Hack -- Forget the view and lite */ p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE); @@ -4414,63 +4549,127 @@ void wiz_dark(void) /* * Change the "feat" flag for a grid, and notice/redraw the grid */ -void cave_set_feat(int y, int x, int feat) +void cave_set_feat(POSITION y, POSITION x, IDX feat) { cave_type *c_ptr = &cave[y][x]; feature_type *f_ptr = &f_info[feat]; + bool old_los, old_mirror; + + if (!character_dungeon) + { + /* Clear mimic type */ + c_ptr->mimic = 0; + + /* Change the feature */ + c_ptr->feat = feat; + + /* Hack -- glow the GLOW terrain */ + if (have_flag(f_ptr->flags, FF_GLOW) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) + { + int i, yy, xx; + + for (i = 0; i < 9; i++) + { + yy = y + ddy_ddd[i]; + xx = x + ddx_ddd[i]; + if (!in_bounds2(yy, xx)) continue; + cave[yy][xx].info |= CAVE_GLOW; + } + } + + return; + } + + old_los = cave_have_flag_bold(y, x, FF_LOS); + old_mirror = is_mirror_grid(c_ptr); /* Clear mimic type */ c_ptr->mimic = 0; + /* Change the feature */ + c_ptr->feat = feat; + /* Remove flag for mirror/glyph */ c_ptr->info &= ~(CAVE_OBJECT); - /* Change the feature */ - c_ptr->feat = feat; + if (old_mirror && (d_info[dungeon_type].flags1 & DF1_DARKNESS)) + { + c_ptr->info &= ~(CAVE_GLOW); + if (!view_torch_grids) c_ptr->info &= ~(CAVE_MARK); + + update_local_illumination(y, x); + } /* Check for change to boring grid */ if (!have_flag(f_ptr->flags, FF_REMEMBER)) c_ptr->info &= ~(CAVE_MARK); - /* Check for change to out of sight grid */ - else if (!player_can_see_bold(y, x)) c_ptr->info &= ~(CAVE_MARK); + /* Update the monster */ + if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE); - /* Hack -- glow the deep lava */ + /* Notice */ + note_spot(y, x); + + /* Redraw */ + lite_spot(y, x); + + /* Check if los has changed */ + if (old_los ^ have_flag(f_ptr->flags, FF_LOS)) + { + +#ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */ + + update_local_illumination(y, x); + +#endif /* COMPLEX_WALL_ILLUMINATION */ + + /* Update the visuals */ + p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE | PU_MONSTERS); + } + + /* Hack -- glow the GLOW terrain */ if (have_flag(f_ptr->flags, FF_GLOW) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) { int i, yy, xx; + cave_type *cc_ptr; for (i = 0; i < 9; i++) { yy = y + ddy_ddd[i]; xx = x + ddx_ddd[i]; if (!in_bounds2(yy, xx)) continue; - cave[yy][xx].info |= CAVE_GLOW; - if (player_has_los_bold(yy, xx)) + cc_ptr = &cave[yy][xx]; + cc_ptr->info |= CAVE_GLOW; + + if (player_has_los_grid(cc_ptr)) { + /* Update the monster */ + if (cc_ptr->m_idx) update_mon(cc_ptr->m_idx, FALSE); + /* Notice */ note_spot(yy, xx); /* Redraw */ lite_spot(yy, xx); } - } - } - /* Notice */ - note_spot(y, x); + update_local_illumination(yy, xx); + } - /* Redraw */ - lite_spot(y, x); + if (p_ptr->special_defense & NINJA_S_STEALTH) + { + if (cave[p_ptr->y][p_ptr->x].info & CAVE_GLOW) set_superstealth(FALSE); + } + } } -int conv_dungeon_feat(int newfeat) +IDX conv_dungeon_feat(IDX newfeat) { feature_type *f_ptr = &f_info[newfeat]; if (have_flag(f_ptr->flags, FF_CONVERT)) { - switch (f_ptr->power) + switch (f_ptr->subtype) { case CONVERT_TYPE_FLOOR: return floor_type[randint0(100)]; @@ -4498,7 +4697,7 @@ int conv_dungeon_feat(int newfeat) * Take a feature, determine what that feature becomes * through applying the given action. */ -int feat_state(int feat, int action) +IDX feat_state(IDX feat, int action) { feature_type *f_ptr = &f_info[feat]; int i; @@ -4521,10 +4720,10 @@ int feat_state(int feat, int action) void cave_alter_feat(int y, int x, int action) { /* Set old feature */ - int oldfeat = cave[y][x].feat; + IDX oldfeat = cave[y][x].feat; /* Get the new feat */ - int newfeat = feat_state(oldfeat, action); + IDX newfeat = feat_state(oldfeat, action); /* No change */ if (newfeat == oldfeat) return; @@ -4556,11 +4755,18 @@ void cave_alter_feat(int y, int x, int action) if (found && character_dungeon && player_can_see_bold(y, x)) { -#ifdef JP - msg_print("²¿¤«¤òȯ¸«¤·¤¿¡ª"); -#else - msg_print("You have found something!"); -#endif + msg_print(_("何かを発見した！", "You have found something!")); + } + } + + if (feature_action_flags[action] & FAF_CRASH_GLASS) + { + feature_type *old_f_ptr = &f_info[oldfeat]; + + if (have_flag(old_f_ptr->flags, FF_GLASS) && character_dungeon) + { + project(PROJECT_WHO_GLASS_SHARDS, 1, y, x, MIN(dun_level, 100) / 4, GF_SHARDS, + (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_HIDE | PROJECT_JUMP | PROJECT_NO_HANGEKI), -1); } } } @@ -4569,15 +4775,23 @@ void cave_alter_feat(int y, int x, int action) /* Remove a mirror */ void remove_mirror(int y, int x) { + cave_type *c_ptr = &cave[y][x]; + /* Remove the mirror */ - cave[y][x].info &= ~(CAVE_OBJECT); - cave[y][x].mimic = 0; + c_ptr->info &= ~(CAVE_OBJECT); + c_ptr->mimic = 0; if (d_info[dungeon_type].flags1 & DF1_DARKNESS) { - cave[y][x].info &= ~(CAVE_GLOW); - if( !view_torch_grids )cave[y][x].info &= ~(CAVE_MARK); + c_ptr->info &= ~(CAVE_GLOW); + if (!view_torch_grids) c_ptr->info &= ~(CAVE_MARK); + + /* Update the monster */ + if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE); + + update_local_illumination(y, x); } + /* Notice */ note_spot(y, x); @@ -4684,9 +4898,9 @@ void mmove2(int *y, int *x, int y1, int x1, int y2, int x2) * * This is slightly (but significantly) different from "los(y1,x1,y2,x2)". */ -bool projectable(int y1, int x1, int y2, int x2) +bool projectable(POSITION y1, POSITION x1, POSITION y2, POSITION x2) { - int y, x; + POSITION y, x; int grid_n = 0; u16b grid_g[512]; @@ -4720,9 +4934,9 @@ bool projectable(int y1, int x1, int y2, int x2) * * Currently the "m" parameter is unused. */ -void scatter(int *yp, int *xp, int y, int x, int d, int m) +void scatter(POSITION *yp, POSITION *xp, POSITION y, POSITION x, POSITION d, int m) { - int nx, ny; + POSITION nx, ny; /* Unused */ m = m; @@ -4740,8 +4954,8 @@ void scatter(int *yp, int *xp, int y, int x, int d, int m) /* Ignore "excessively distant" locations */ if ((d > 1) && (distance(y, x, ny, nx) > d)) continue; - /* Require "line of sight" */ - if (los(y, x, ny, nx)) break; + /* Require "line of projection" */ + if (projectable(y, x, ny, nx)) break; } /* Save the location */ @@ -4755,7 +4969,7 @@ void scatter(int *yp, int *xp, int y, int x, int d, int m) /* * Track a new monster */ -void health_track(int m_idx) +void health_track(MONSTER_IDX m_idx) { /* Mount monster is already tracked */ if (m_idx && m_idx == p_ptr->riding) return; @@ -4772,7 +4986,7 @@ void health_track(int m_idx) /* * Hack -- track the given monster race */ -void monster_race_track(int r_idx) +void monster_race_track(MONRACE_IDX r_idx) { /* Save this monster ID */ p_ptr->monster_race_idx = r_idx; @@ -4786,7 +5000,7 @@ void monster_race_track(int r_idx) /* * Hack -- track the given object kind */ -void object_kind_track(int k_idx) +void object_kind_track(IDX k_idx) { /* Save this monster ID */ p_ptr->object_kind_idx = k_idx; @@ -4806,10 +5020,12 @@ void object_kind_track(int k_idx) * * All disturbance cancels repeated commands, resting, and running. */ -void disturb(int stop_search, int unused_flag) +void disturb(int stop_search, int stop_travel) { +#ifndef TRAVEL /* Unused */ - unused_flag = unused_flag; + stop_travel = stop_travel; +#endif /* Cancel auto-commands */ /* command_new = 0; */ @@ -4847,6 +5063,20 @@ void disturb(int stop_search, int unused_flag) p_ptr->update |= (PU_FLOW); } +#ifdef TRAVEL + if (stop_travel) + { + /* Cancel */ + travel.run = 0; + + /* Check for new panel if appropriate */ + if (center_player && !center_running) verify_panel(); + + /* Calculate torch radius */ + p_ptr->update |= (PU_TORCH); + } +#endif + /* Flush the input if requested */ if (flush_disturb) flush(); } @@ -4879,9 +5109,14 @@ void glow_deep_lava_and_bldg(void) xx = x + ddx_ddd[i]; if (!in_bounds2(yy, xx)) continue; cave[yy][xx].info |= CAVE_GLOW; - if (player_has_los_bold(yy, xx)) note_spot(yy, xx); } } } } + + /* Update the view and lite */ + p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE); + + /* Redraw map */ + p_ptr->redraw |= (PR_MAP); }