X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=src%2Fcave.c;h=5a0118f1cf64810277624c448517a73e854805be;hb=f5d7e7a38b4256114811b63e44dd04509f011dbd;hp=412b7886e899699f0323dd6fc04560d7ecb52be2;hpb=70a074055d86965d5929d20ddf9506652cdb2a60;p=hengband%2Fhengband.git diff --git a/src/cave.c b/src/cave.c index 412b7886e..5a0118f1c 100644 --- a/src/cave.c +++ b/src/cave.c @@ -1,44 +1,50 @@ -/* 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" +#include "world.h" +#include "projection.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,18 +64,20 @@ 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(FEAT_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) { @@ -79,11 +87,12 @@ bool is_known_trap(cave_type *c_ptr) 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(FEAT_IDX feat) { feature_type *f_ptr = &f_info[feat]; @@ -91,9 +100,10 @@ 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) { @@ -104,64 +114,70 @@ bool is_hidden_door(cave_type *c_ptr) 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; + POSITION ax, ay; /* Signs */ - int sx, sy; + POSITION sx, sy; /* Fractions */ - int qx, qy; + POSITION qx, qy; /* Scanners */ - int tx, ty; + POSITION tx, ty; /* Scale factors */ - int f1, f2; + POSITION f1, f2; /* Slope, or 1/Slope, of LOS */ - int m; + POSITION m; /* Extract the offset */ @@ -363,81 +379,143 @@ 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) +static bool check_local_illumination(POSITION y, POSITION 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; + POSITION yy = (y < p_ptr->y) ? (y + 1) : (y > p_ptr->y) ? (y - 1) : y; + POSITION xx = (x < p_ptr->x) ? (x + 1) : (x > p_ptr->x) ? (x - 1) : x; /* Check for "local" illumination */ + +#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 */ } -/* - * Update "local" illumination +/*! 対象座標のマスの照明状態を更新する際の補助処理マクロ */ +#define update_local_illumination_aux(Y, X) \ +{ \ + if (player_has_los_bold((Y), (X))) \ + { \ + /* Update the monster */ \ + if (cave[(Y)][(X)].m_idx) update_monster(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) +void update_local_illumination(POSITION y, POSITION x) { - int i, yy, xx; + int i; + POSITION yy, xx; if (!in_bounds(y, x)) return; - if ((y != py) && (x != px)) - { - yy = (y < py) ? (y - 1) : (y + 1); - xx = (x < px) ? (x - 1) : (x + 1); +#ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */ - if (player_has_los_bold(yy, xx)) + 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++) { - /* Update the monster */ - if (cave[yy][xx].m_idx) update_mon(cave[yy][xx].m_idx, FALSE); - - /* Notice and redraw */ - note_spot(yy, xx); - lite_spot(yy, xx); + 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 (x != px) /* y == py */ + else if (y != p_ptr->y) /* x == p_ptr->x */ { - xx = (x < px) ? (x - 1) : (x + 1); - + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); for (i = -1; i <= 1; i++) { - yy = y + i; - if (!player_has_los_bold(yy, xx)) continue; + 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); + } + } - /* Update the monster */ - if (cave[yy][xx].m_idx) update_mon(cave[yy][xx].m_idx, FALSE); +#else /* COMPLEX_WALL_ILLUMINATION */ - /* Notice and redraw */ - note_spot(yy, xx); - lite_spot(yy, xx); + 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 != py) /* x == px */ + else if (y != p_ptr->y) /* x == p_ptr->x */ { - yy = (y < py) ? (y - 1) : (y + 1); - + yy = (y < p_ptr->y) ? (y - 1) : (y + 1); for (i = -1; i <= 1; i++) { xx = x + i; - if (!player_has_los_bold(yy, xx)) continue; - - /* Update the monster */ - if (cave[yy][xx].m_idx) update_mon(cave[yy][xx].m_idx, FALSE); - - /* Notice and redraw */ - note_spot(yy, xx); - lite_spot(yy, xx); + update_local_illumination_aux(yy, xx); } } else /* Player's grid */ @@ -446,52 +524,50 @@ void update_local_illumination(int y, int x) { yy = y + ddy_cdd[i]; xx = x + ddx_cdd[i]; - if (!player_has_los_bold(yy, xx)) continue; - - /* Update the monster */ - if (cave[yy][xx].m_idx) update_mon(cave[yy][xx].m_idx, FALSE); - - /* Notice and redraw */ - note_spot(yy, xx); - lite_spot(yy, xx); + update_local_illumination_aux(yy, xx); } } + +#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. +/*! + * @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) +bool player_can_see_bold(POSITION y, POSITION x) { cave_type *c_ptr; @@ -521,65 +597,29 @@ bool player_can_see_bold(int y, int x) 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) +bool cave_valid_bold(POSITION y, POSITION x) { cave_type *c_ptr = &cave[y][x]; - - 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 (object_is_artifact(o_ptr)) return (FALSE); - } - - /* Accept */ - return (TRUE); -} - - - - -/* - * 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; - + OBJECT_IDX this_o_idx, next_o_idx = 0; /* Forbid perma-grids */ if (cave_perma_grid(c_ptr)) return (FALSE); @@ -588,8 +628,6 @@ bool cave_valid_grid(cave_type *c_ptr) 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 */ @@ -606,21 +644,24 @@ bool cave_valid_grid(cave_type *c_ptr) -/* - * 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) +static void image_monster(TERM_COLOR *ap, char *cp) { /* Random symbol from set above */ if (use_graphics) @@ -642,11 +683,13 @@ 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) +static void image_object(TERM_COLOR *ap, char *cp) { if (use_graphics) { @@ -667,11 +710,13 @@ 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) +static void image_random(TERM_COLOR *ap, char *cp) { /* Normally, assume monsters */ if (randint0(100) < 75) @@ -686,15 +731,15 @@ 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 */ - static byte lighting_colours[16][2] = { /* TERM_DARK */ @@ -746,14 +791,14 @@ static byte lighting_colours[16][2] = {TERM_L_UMBER, TERM_UMBER} }; - -/* - * Apply "default" feature lighting effects +/*! + * @brief 調査中 + * @todo コメントを付加すること */ -void apply_default_feat_lighting(byte f_attr[F_LIT_MAX], byte f_char[F_LIT_MAX]) +void apply_default_feat_lighting(TERM_COLOR f_attr[F_LIT_MAX], SYMBOL_CODE f_char[F_LIT_MAX]) { - byte s_attr = f_attr[F_LIT_STANDARD]; - byte s_char = f_char[F_LIT_STANDARD]; + TERM_COLOR s_attr = f_attr[F_LIT_STANDARD]; + SYMBOL_CODE s_char = f_char[F_LIT_STANDARD]; int i; if (is_ascii_graphics(s_attr)) /* For ASCII */ @@ -771,144 +816,146 @@ void apply_default_feat_lighting(byte f_attr[F_LIT_MAX], byte f_char[F_LIT_MAX]) } -/* 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) -/* - * 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 +/*! + * @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) +void map_info(POSITION y, POSITION x, TERM_COLOR *ap, char *cp, TERM_COLOR *tap, char *tcp) { /* Get the cave */ cave_type *c_ptr = &cave[y][x]; - s16b this_o_idx, next_o_idx = 0; + OBJECT_IDX this_o_idx, next_o_idx = 0; /* Feature code (applying "mimic" field) */ - s16b feat = get_feat_mimic(c_ptr); + FEAT_IDX feat = get_feat_mimic(c_ptr); /* Access floor */ feature_type *f_ptr = &f_info[feat]; - byte a; + TERM_COLOR a; byte c; /* Boring grids (floors, etc) */ @@ -949,7 +996,7 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) else if (darkened_grid(c_ptr)) { /* Unsafe cave grid -- idea borrowed from Unangband */ - feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? FEAT_UNDETECTED : FEAT_NONE; + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; /* Access darkness */ f_ptr = &f_info[feat]; @@ -1000,10 +1047,7 @@ 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]; @@ -1042,7 +1086,7 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) 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; + feat = (view_unsafe_grids && (c_ptr->info & CAVE_UNSAFE)) ? feat_undetected : feat_none; /* Access darkness */ f_ptr = &f_info[feat]; @@ -1116,10 +1160,7 @@ 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]; @@ -1154,15 +1195,13 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) 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; /* Memorized objects */ - if (o_ptr->marked) + if (o_ptr->marked & OM_FOUND) { if (display_autopick) { @@ -1195,7 +1234,6 @@ void map_info(int y, int x, byte *ap, char *cp, byte *tap, char *tcp) /* Hack -- hallucination */ if (p_ptr->image) image_object(ap, cp); - /* Done */ break; } } @@ -1363,7 +1401,7 @@ void move_cursor_relative(int row, int col) /* * Place an attr/char pair at the given map coordinate, if legal. */ -void print_rel(char c, byte a, int y, int x) +void print_rel(char c, byte a, TERM_LEN y, TERM_LEN x) { /* Only do "legal" locations */ if (panel_contains(y, x)) @@ -1424,12 +1462,10 @@ void print_rel(char c, byte a, int y, int x) * optimized primarily for the most common cases, that is, for the * non-marked floor grids. */ -void note_spot(int y, int x) +void note_spot(POSITION y, POSITION x) { cave_type *c_ptr = &cave[y][x]; - - s16b this_o_idx, next_o_idx = 0; - + OBJECT_IDX this_o_idx, next_o_idx = 0; /* Blind players see nothing */ if (p_ptr->blind) return; @@ -1515,21 +1551,24 @@ void note_spot(int y, int x) c_ptr->info |= (CAVE_MARK); } } + + /* Memorize terrain of the grid */ + c_ptr->info |= (CAVE_KNOWN); } void display_dungeon(void) { - int x, y; - byte a; + TERM_LEN x, y; + TERM_COLOR a; char c; - byte ta; - char tc; + TERM_COLOR 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)) { @@ -1546,14 +1585,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]; @@ -1562,7 +1601,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); } } } @@ -1574,15 +1613,15 @@ void display_dungeon(void) * * This function should only be called on "legal" grids */ -void lite_spot(int y, int x) +void lite_spot(POSITION y, POSITION x) { /* Redraw if on screen */ if (panel_contains(y, x) && in_bounds2(y, x)) { - byte a; + TERM_COLOR a; char c; - byte ta; + TERM_COLOR ta; char tc; /* Examine the grid */ @@ -1614,15 +1653,14 @@ void lite_spot(int y, int x) */ void prt_map(void) { - int x, y; - int v; + POSITION x, y; + int v; /* map bounds */ - s16b xmin, xmax, ymin, ymax; + POSITION xmin, xmax, ymin, ymax; - int wid, hgt; + TERM_LEN wid, hgt; - /* Get size */ Term_get_size(&wid, &hgt); /* Remove map offset */ @@ -1661,11 +1699,11 @@ void prt_map(void) /* Scan the columns of row "y" */ for (x = xmin; x <= xmax; x++) { - byte a; - char c; + TERM_COLOR a; + SYMBOL_CODE c; - byte ta; - char tc; + TERM_COLOR ta; + SYMBOL_CODE tc; /* Determine what is there */ map_info(y, x, &a, &c, &ta, &tc); @@ -1684,7 +1722,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); @@ -1695,40 +1733,37 @@ void prt_map(void) /* * print project path */ -void prt_path(int y, int x) +void prt_path(POSITION y, POSITION 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); - - /* Redraw stuff */ - redraw_stuff(); + handle_stuff(); /* Draw path */ for (i = 0; i < path_n; i++) { - int ny = GRID_Y(path_g[i]); - int nx = GRID_X(path_g[i]); + POSITION ny = GRID_Y(path_g[i]); + POSITION nx = GRID_X(path_g[i]); cave_type *c_ptr = &cave[ny][nx]; if (panel_contains(ny, nx)) { - byte a = default_color; + TERM_COLOR a = default_color; char c; - byte ta; - char tc; + TERM_COLOR ta = default_color; + char tc = '*'; if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) { @@ -1765,10 +1800,10 @@ void prt_path(int y, int x) } -static cptr simplify_list[][2] = +static concptr simplify_list[][2] = { #ifdef JP - {"¤ÎËâË¡½ñ", ""}, + {"の魔法書", ""}, {NULL, NULL} #else {"^Ring of ", "="}, @@ -1795,7 +1830,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) char buf[MAX_NLEN]; char *c = buf; int len = 0; - byte attr; + TERM_COLOR attr; object_desc(buf, o_ptr, (OD_NO_FLAVOR | OD_OMIT_PREFIX | OD_NAME_ONLY)); attr = tval_to_attr[o_ptr->tval % 128]; @@ -1803,11 +1838,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++) @@ -1815,7 +1846,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) int i; for (i = 0; simplify_list[i][1]; i++) { - cptr org_w = simplify_list[i][0]; + concptr org_w = simplify_list[i][0]; if (*org_w == '^') { @@ -1828,7 +1859,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) if (!strncmp(c, org_w, strlen(org_w))) { char *s = c; - cptr tmp = simplify_list[i][1]; + concptr tmp = simplify_list[i][1]; while (*tmp) *s++ = *tmp++; tmp = c + strlen(org_w); @@ -1841,7 +1872,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y) c = buf; len = 0; - /* Ⱦ³Ñ 12 ʸ»úʬ¤ÇÀÚ¤ë */ + /* 半角 12 文字分で切る */ while(*c) { #ifdef JP @@ -1870,16 +1901,16 @@ void display_map(int *cy, int *cx) { int i, j, x, y; - byte ta; + TERM_COLOR ta; char tc; byte tp; - byte **bigma; + TERM_COLOR **bigma; char **bigmc; byte **bigmp; - byte **ma; + TERM_COLOR **ma; char **mc; byte **mp; @@ -1892,7 +1923,6 @@ void display_map(int *cy, int *cx) int **match_autopick_yx; object_type ***object_autopick_yx; - /* Get size */ Term_get_size(&wid, &hgt); hgt -= 2; wid -= 14; @@ -1906,7 +1936,7 @@ void display_map(int *cy, int *cx) view_granite_lite = FALSE; /* Allocate the maps */ - C_MAKE(ma, (hgt + 2), byte_ptr); + C_MAKE(ma, (hgt + 2), TERM_COLOR *); C_MAKE(mc, (hgt + 2), char_ptr); C_MAKE(mp, (hgt + 2), byte_ptr); C_MAKE(match_autopick_yx, (hgt + 2), sint_ptr); @@ -1916,7 +1946,7 @@ void display_map(int *cy, int *cx) for (y = 0; y < (hgt + 2); y++) { /* Allocate one row each array */ - C_MAKE(ma[y], (wid + 2), byte); + C_MAKE(ma[y], (wid + 2), TERM_COLOR); C_MAKE(mc[y], (wid + 2), char); C_MAKE(mp[y], (wid + 2), byte); C_MAKE(match_autopick_yx[y], (wid + 2), int); @@ -1937,7 +1967,7 @@ void display_map(int *cy, int *cx) } /* Allocate the maps */ - C_MAKE(bigma, (cur_hgt + 2), byte_ptr); + C_MAKE(bigma, (cur_hgt + 2), TERM_COLOR *); C_MAKE(bigmc, (cur_hgt + 2), char_ptr); C_MAKE(bigmp, (cur_hgt + 2), byte_ptr); @@ -1945,7 +1975,7 @@ void display_map(int *cy, int *cx) for (y = 0; y < (cur_hgt + 2); y++) { /* Allocate one row each array */ - C_MAKE(bigma[y], (cur_wid + 2), byte); + C_MAKE(bigma[y], (cur_wid + 2), TERM_COLOR); C_MAKE(bigmc[y], (cur_wid + 2), char); C_MAKE(bigmp[y], (cur_wid + 2), byte); @@ -1965,7 +1995,6 @@ void display_map(int *cy, int *cx) { for (j = 0; j < cur_hgt; ++j) { - /* Location */ x = i / xrat + 1; y = j / yrat + 1; @@ -1977,7 +2006,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 @@ -1999,7 +2028,6 @@ void display_map(int *cy, int *cx) { for (i = 0; i < cur_wid; ++i) { - /* Location */ x = i / xrat + 1; y = j / yrat + 1; @@ -2105,11 +2133,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; @@ -2119,60 +2147,51 @@ 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), TERM_COLOR); + 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), TERM_COLOR *); + 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), TERM_COLOR); + 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), TERM_COLOR *); + C_KILL(bigmc, (cur_hgt + 2), char_ptr); + C_KILL(bigmp, (cur_hgt + 2), byte_ptr); } /* * Display a "small-scale" map of the dungeon for the player * - * Currently, the "player" is displayed on the map. XXX XXX XXX + * Currently, the "player" is displayed on the map. */ void do_cmd_view_map(void) { int cy, cx; - - /* Save the screen */ screen_save(); /* Note */ -#ifdef JP -prt("¤ªÂÔ¤Á²¼¤µ¤¤...", 0, 0); -#else - prt("Please wait...", 0, 0); -#endif + prt(_("お待ち下さい...", "Please wait..."), 0, 0); - /* Flush */ Term_fresh(); - - /* Clear the screen */ Term_clear(); display_autopick = 0; @@ -2195,11 +2214,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); @@ -2232,17 +2248,12 @@ 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(); } - - /* Restore the screen */ screen_load(); } @@ -2482,7 +2493,6 @@ void forget_lite(void) /* Forget "LITE" flag */ cave[y][x].info &= ~(CAVE_LITE); - /* Redraw */ /* lite_spot(y, x); Perhaps don't need? */ } @@ -2516,8 +2526,6 @@ void forget_lite(void) /* - * XXX XXX XXX - * * This macro allows us to efficiently add a grid to the "lite" array, * note that we are never called for illegal grids, or for grids which * have already been placed into the "lite" array, and we are never @@ -2574,7 +2582,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 @@ -2608,54 +2616,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); } } @@ -2668,43 +2676,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 */ @@ -2712,8 +2720,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; @@ -2725,7 +2733,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); @@ -2779,15 +2787,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; */ @@ -2802,11 +2811,11 @@ static void mon_lite_hack(int y, int x) /* 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) @@ -2823,11 +2832,11 @@ static void mon_lite_hack(int y, int x) } /* 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) @@ -2870,7 +2879,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; @@ -2888,11 +2897,11 @@ static void mon_dark_hack(int y, int x) /* 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) @@ -2909,11 +2918,11 @@ static void mon_dark_hack(int y, int x) } /* 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) @@ -2957,8 +2966,8 @@ 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; @@ -3014,14 +3023,14 @@ void update_mon_lite(void) 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 (!(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)) && (m_ptr->csleep || (!dun_level && !is_daytime()))) continue; + 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 */ @@ -3191,8 +3200,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++; } @@ -3251,7 +3260,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) { @@ -3259,19 +3268,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.")); } } } @@ -3314,16 +3315,14 @@ void forget_view(void) /* Clear them all */ for (i = 0; i < view_n; i++) { - int y = view_y[i]; - int x = view_x[i]; - - /* Access the grid */ + POSITION y = view_y[i]; + POSITION x = view_x[i]; c_ptr = &cave[y][x]; /* 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? */ @@ -3359,8 +3358,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()". @@ -3369,7 +3368,7 @@ void forget_view(void) * * This function now returns "TRUE" if vision is "blocked" by grid (y,x). */ -static bool update_view_aux(int y, int x, int y1, int x1, int y2, int x2) +static bool update_view_aux(POSITION y, POSITION x, POSITION y1, POSITION x1, POSITION y2, POSITION x2) { bool f1, f2, v1, v2, z1, z2, wall; @@ -3398,8 +3397,6 @@ static bool update_view_aux(int y, int x, int y1, int x1, int y2, int x2) /* Totally blocked by "unviewable neighbors" */ if (!v1 && !v2) return (TRUE); - - /* Access the grid */ c_ptr = &cave[y][x]; @@ -3450,7 +3447,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); @@ -3557,14 +3554,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; @@ -3598,8 +3596,6 @@ void update_view(void) { y = view_y[n]; x = view_x[n]; - - /* Access the grid */ c_ptr = &cave[y][x]; /* Mark the grid as not in "view" */ @@ -3620,10 +3616,8 @@ void update_view(void) /*** Step 1 -- adjacent grids ***/ /* Now start on the player */ - y = py; - x = px; - - /* Access the grid */ + y = p_ptr->y; + x = p_ptr->x; c_ptr = &cave[y][x]; /* Assume the player grid is easily viewable */ @@ -3971,8 +3965,6 @@ void update_view(void) { y = view_y[n]; x = view_x[n]; - - /* Access the grid */ c_ptr = &cave[y][x]; /* Clear the "CAVE_XTRA" flag */ @@ -3990,8 +3982,6 @@ void update_view(void) { y = temp_y[n]; x = temp_x[n]; - - /* Access the grid */ c_ptr = &cave[y][x]; /* No longer in the array */ @@ -4026,8 +4016,6 @@ void delayed_visual_update(void) { y = redraw_y[i]; x = redraw_x[i]; - - /* Access the grid */ c_ptr = &cave[y][x]; /* Update only needed grids (prevent multiple updating) */ @@ -4036,11 +4024,10 @@ void delayed_visual_update(void) /* If required, note */ if (c_ptr->info & CAVE_NOTE) note_spot(y, x); - /* Redraw */ lite_spot(y, x); /* Hack -- Visual update of monster on this grid */ - if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE); + if (c_ptr->m_idx) update_monster(c_ptr->m_idx, FALSE); /* No longer in the array */ c_ptr->info &= ~(CAVE_NOTE | CAVE_REDRAW); @@ -4056,7 +4043,7 @@ void delayed_visual_update(void) */ void forget_flow(void) { - int x, y; + POSITION x, y; /* Check the entire dungeon */ for (y = 0; y < cur_hgt; y++) @@ -4077,8 +4064,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; @@ -4097,7 +4084,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; @@ -4122,12 +4109,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) @@ -4145,8 +4132,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 */ @@ -4207,8 +4194,8 @@ static int scent_when = 0; */ void update_smell(void) { - int i, j; - int y, x; + POSITION i, j; + POSITION y, x; /* Create a table that controls the spread of scent */ const int scent_adjust[5][5] = @@ -4246,8 +4233,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; @@ -4273,12 +4260,13 @@ 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; - s16b feat; - feature_type *f_ptr; + int i; + POSITION x, y; + cave_type *c_ptr; + FEAT_IDX feat; + feature_type *f_ptr; if (d_info[dungeon_type].flags1 & DF1_DARKNESS) range /= 3; @@ -4287,10 +4275,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]; @@ -4325,10 +4316,8 @@ void map_area(int range) } } - /* Redraw map */ p_ptr->redraw |= (PR_MAP); - /* Window stuff */ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON); } @@ -4352,8 +4341,9 @@ void map_area(int range) */ void wiz_lite(bool ninja) { - int i, y, x; - s16b feat; + OBJECT_IDX i; + POSITION y, x; + FEAT_IDX feat; feature_type *f_ptr; /* Memorize objects */ @@ -4379,6 +4369,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]; @@ -4389,8 +4382,8 @@ void wiz_lite(bool ninja) /* Scan all neighbors */ for (i = 0; i < 9; i++) { - int yy = y + ddy_ddd[i]; - int xx = x + ddx_ddd[i]; + POSITION yy = y + ddy_ddd[i]; + POSITION xx = x + ddx_ddd[i]; /* Get the grid */ c_ptr = &cave[yy][xx]; @@ -4426,18 +4419,13 @@ void wiz_lite(bool ninja) } } - /* Update the monsters */ p_ptr->update |= (PU_MONSTERS); - - /* Redraw map */ p_ptr->redraw |= (PR_MAP); - - /* Window stuff */ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON); if (p_ptr->special_defense & NINJA_S_STEALTH) { - if (cave[py][px].info & CAVE_GLOW) set_superstealth(FALSE); + if (cave[p_ptr->y][p_ptr->x].info & CAVE_GLOW) set_superstealth(FALSE); } } @@ -4447,8 +4435,8 @@ void wiz_lite(bool ninja) */ void wiz_dark(void) { - int i, y, x; - + OBJECT_IDX i; + POSITION y, x; /* Forget every grid */ for (y = 1; y < cur_hgt - 1; y++) @@ -4458,7 +4446,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); } } @@ -4489,36 +4477,56 @@ void wiz_dark(void) if (o_ptr->held_m_idx) continue; /* Forget the object */ - o_ptr->marked = 0; + o_ptr->marked &= OM_TOUCHED; } - /* Mega-Hack -- Forget the view and lite */ - p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE); + /* Forget travel route when we have forgotten map */ + forget_travel_flow(); - /* Update the view and lite */ + p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE); p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE); - - /* Update the monsters */ p_ptr->update |= (PU_MONSTERS); - - /* Redraw map */ p_ptr->redraw |= (PR_MAP); - - /* Window stuff */ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON); } - - - - /* * 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, FEAT_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)) + { + DIRECTION i; + POSITION 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; @@ -4526,36 +4534,44 @@ void cave_set_feat(int y, int x, int feat) /* Change the feature */ c_ptr->feat = feat; - if (character_dungeon) + /* Remove flag for mirror/glyph */ + c_ptr->info &= ~(CAVE_OBJECT); + + if (old_mirror && (d_info[dungeon_type].flags1 & DF1_DARKNESS)) { - if (is_mirror_grid(c_ptr) && (d_info[dungeon_type].flags1 & DF1_DARKNESS)) - { - c_ptr->info &= ~(CAVE_GLOW); - if (!view_torch_grids) c_ptr->info &= ~(CAVE_MARK); + c_ptr->info &= ~(CAVE_GLOW); + if (!view_torch_grids) c_ptr->info &= ~(CAVE_MARK); - update_local_illumination(y, x); - } + update_local_illumination(y, x); + } + + /* Check for change to boring grid */ + if (!have_flag(f_ptr->flags, FF_REMEMBER)) c_ptr->info &= ~(CAVE_MARK); + if (c_ptr->m_idx) update_monster(c_ptr->m_idx, FALSE); + + note_spot(y, x); - /* Remove flag for mirror/glyph */ - c_ptr->info &= ~(CAVE_OBJECT); + lite_spot(y, x); - /* Check for change to boring grid */ - if (!have_flag(f_ptr->flags, FF_REMEMBER)) c_ptr->info &= ~(CAVE_MARK); + /* Check if los has changed */ + if (old_los ^ have_flag(f_ptr->flags, FF_LOS)) + { - /* Update the monster */ - if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE); +#ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */ - /* Notice */ - note_spot(y, x); + update_local_illumination(y, x); - /* Redraw */ - lite_spot(y, x); +#endif /* COMPLEX_WALL_ILLUMINATION */ + + /* Update the visuals */ + p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE | PU_MONSTERS); } - /* Hack -- glow the deep lava */ + /* Hack -- glow the GLOW terrain */ if (have_flag(f_ptr->flags, FF_GLOW) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) { - int i, yy, xx; + DIRECTION i; + POSITION yy, xx; cave_type *cc_ptr; for (i = 0; i < 9; i++) @@ -4565,39 +4581,34 @@ void cave_set_feat(int y, int x, int feat) if (!in_bounds2(yy, xx)) continue; cc_ptr = &cave[yy][xx]; cc_ptr->info |= CAVE_GLOW; - if (character_dungeon) - { - 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); + if (player_has_los_grid(cc_ptr)) + { + if (cc_ptr->m_idx) update_monster(cc_ptr->m_idx, FALSE); - /* Redraw */ - lite_spot(yy, xx); - } + note_spot(yy, xx); - update_local_illumination(yy, xx); + lite_spot(yy, xx); } + + update_local_illumination(yy, xx); } if (p_ptr->special_defense & NINJA_S_STEALTH) { - if (character_dungeon && (cave[py][px].info & CAVE_GLOW)) set_superstealth(FALSE); + if (cave[p_ptr->y][p_ptr->x].info & CAVE_GLOW) set_superstealth(FALSE); } } } -int conv_dungeon_feat(int newfeat) +FEAT_IDX conv_dungeon_feat(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)]; @@ -4625,7 +4636,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) +FEAT_IDX feat_state(FEAT_IDX feat, int action) { feature_type *f_ptr = &f_info[feat]; int i; @@ -4645,13 +4656,13 @@ int feat_state(int feat, int action) * Takes a location and action and changes the feature at that * location through applying the given action. */ -void cave_alter_feat(int y, int x, int action) +void cave_alter_feat(POSITION y, POSITION x, int action) { /* Set old feature */ - int oldfeat = cave[y][x].feat; + FEAT_IDX oldfeat = cave[y][x].feat; /* Get the new feat */ - int newfeat = feat_state(oldfeat, action); + FEAT_IDX newfeat = feat_state(oldfeat, action); /* No change */ if (newfeat == oldfeat) return; @@ -4683,18 +4694,25 @@ 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); } } } /* Remove a mirror */ -void remove_mirror(int y, int x) +void remove_mirror(POSITION y, POSITION x) { cave_type *c_ptr = &cave[y][x]; @@ -4706,17 +4724,13 @@ void remove_mirror(int y, int x) { 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); + if (c_ptr->m_idx) update_monster(c_ptr->m_idx, FALSE); update_local_illumination(y, x); } - /* Notice */ note_spot(y, x); - /* Redraw */ lite_spot(y, x); } @@ -4761,9 +4775,9 @@ bool is_explosive_rune_grid(cave_type *c_ptr) * Calculate "incremental motion". Used by project() and shoot(). * Assumes that (*y,*x) lies on the path from (y1,x1) to (y2,x2). */ -void mmove2(int *y, int *x, int y1, int x1, int y2, int x2) +void mmove2(POSITION *y, POSITION *x, POSITION y1, POSITION x1, POSITION y2, POSITION x2) { - int dy, dx, dist, shift; + POSITION dy, dx, dist, shift; /* Extract the distance travelled */ dy = (*y < y1) ? y1 - *y : *y - y1; @@ -4819,9 +4833,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]; @@ -4855,12 +4869,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, BIT_FLAGS mode) { - int nx, ny; - - /* Unused */ - m = m; + POSITION nx, ny; /* Pick a location */ while (TRUE) @@ -4875,8 +4886,15 @@ 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 projection" */ - if (projectable(y, x, ny, nx)) break; + if (mode & PROJECT_LOS) + { + if(los(y, x, ny, nx)) break; + } + else + { + if(projectable(y, x, ny, nx)) break; + } + } /* Save the location */ @@ -4890,7 +4908,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; @@ -4907,12 +4925,11 @@ 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; - /* Window stuff */ p_ptr->window |= (PW_MONSTER); } @@ -4921,12 +4938,11 @@ void monster_race_track(int r_idx) /* * Hack -- track the given object kind */ -void object_kind_track(int k_idx) +void object_kind_track(KIND_OBJECT_IDX k_idx) { /* Save this monster ID */ p_ptr->object_kind_idx = k_idx; - /* Window stuff */ p_ptr->window |= (PW_OBJECT); } @@ -4941,10 +4957,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(bool stop_search, bool stop_travel) { +#ifndef TRAVEL /* Unused */ - unused_flag = unused_flag; + stop_travel = stop_travel; +#endif /* Cancel auto-commands */ /* command_new = 0; */ @@ -4982,6 +5000,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(); } @@ -4992,7 +5024,8 @@ void disturb(int stop_search, int unused_flag) */ void glow_deep_lava_and_bldg(void) { - int y, x, i, yy, xx; + POSITION y, x, yy, xx; + DIRECTION i; cave_type *c_ptr; /* Not in the darkness dungeon */ @@ -5022,6 +5055,83 @@ void glow_deep_lava_and_bldg(void) /* Update the view and lite */ p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE); - /* Redraw map */ p_ptr->redraw |= (PR_MAP); } + +/*! +* @brief 指定されたマスがモンスターのテレポート可能先かどうかを判定する。 +* @param m_idx モンスターID +* @param y 移動先Y座標 +* @param x 移動先X座標 +* @param mode オプション +* @return テレポート先として妥当ならばtrue +*/ +bool cave_monster_teleportable_bold(MONSTER_IDX m_idx, POSITION y, POSITION x, BIT_FLAGS mode) +{ + monster_type *m_ptr = &m_list[m_idx]; + cave_type *c_ptr = &cave[y][x]; + feature_type *f_ptr = &f_info[c_ptr->feat]; + + /* Require "teleportable" space */ + if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) return FALSE; + + if (c_ptr->m_idx && (c_ptr->m_idx != m_idx)) return FALSE; + if (player_bold(y, x)) return FALSE; + + /* Hack -- no teleport onto glyph of warding */ + if (is_glyph_grid(c_ptr)) return FALSE; + if (is_explosive_rune_grid(c_ptr)) return FALSE; + + if (!(mode & TELEPORT_PASSIVE)) + { + if (!monster_can_cross_terrain(c_ptr->feat, &r_info[m_ptr->r_idx], 0)) return FALSE; + } + + return TRUE; +} + +/*! +* @brief 指定されたマスにプレイヤーがテレポート可能かどうかを判定する。 +* @param y 移動先Y座標 +* @param x 移動先X座標 +* @param mode オプション +* @return テレポート先として妥当ならばtrue +*/ +bool cave_player_teleportable_bold(POSITION y, POSITION x, BIT_FLAGS mode) +{ + cave_type *c_ptr = &cave[y][x]; + feature_type *f_ptr = &f_info[c_ptr->feat]; + + /* Require "teleportable" space */ + if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) return FALSE; + + /* No magical teleporting into vaults and such */ + if (!(mode & TELEPORT_NONMAGICAL) && (c_ptr->info & CAVE_ICKY)) return FALSE; + + if (c_ptr->m_idx && (c_ptr->m_idx != p_ptr->riding)) return FALSE; + + /* don't teleport on a trap. */ + if (have_flag(f_ptr->flags, FF_HIT_TRAP)) return FALSE; + + if (!(mode & TELEPORT_PASSIVE)) + { + if (!player_can_enter(c_ptr->feat, 0)) return FALSE; + + if (have_flag(f_ptr->flags, FF_WATER) && have_flag(f_ptr->flags, FF_DEEP)) + { + if (!p_ptr->levitation && !p_ptr->can_swim) return FALSE; + } + + if (have_flag(f_ptr->flags, FF_LAVA) && !p_ptr->immune_fire && !IS_INVULN()) + { + /* Always forbid deep lava */ + if (have_flag(f_ptr->flags, FF_DEEP)) return FALSE; + + /* Forbid shallow lava when the player don't have levitation */ + if (!p_ptr->levitation) return FALSE; + } + + } + + return TRUE; +}