X-Git-Url: http://git.osdn.net/view?p=hengband%2Fhengband.git;a=blobdiff_plain;f=src%2Fcave.c;h=068557a18cadae701063f375586b63ae7c91186c;hp=2fde3a58d0591405f2a05697cccc71b925091144;hb=422ec96ba410bfde3e64405f9ea0fe3ef2b4352f;hpb=371374ac9e5ec9321a0597541ae26cb35ce28bd2

diff --git a/src/cave.c b/src/cave.c
index 2fde3a58d..068557a18 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,18 +62,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(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 +85,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(IDX feat)
 {
 	feature_type *f_ptr = &f_info[feat];
 
@@ -91,9 +98,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,46 +112,52 @@ 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;
@@ -363,21 +377,20 @@ bool los(int y1, int x1, int y2, int x2)
 	return TRUE;
 }
 
+#define COMPLEX_WALL_ILLUMINATION /*!< 照明状態を壁により影響を受ける、より複雑な判定に切り替えるマクロ */
 
 
-
-
-
-#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 */
 
@@ -404,12 +417,13 @@ static bool check_local_illumination(int y, int x)
 }
 
 
+/*! 対象座標のマスの照明状態を更新する際の補助処理マクロ */
 #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); \
+		if (cave[(Y)][(X)].m_idx) update_monster(cave[(Y)][(X)].m_idx, FALSE); \
 \
 		/* Notice and redraw */ \
 		note_spot((Y), (X)); \
@@ -417,29 +431,32 @@ static bool check_local_illumination(int y, int x)
 	} \
 }
 
-
-/*
- * Update "local" illumination
+/*!
+ * @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;
 
 #ifdef COMPLEX_WALL_ILLUMINATION /* COMPLEX_WALL_ILLUMINATION */
 
-	if ((y != py) && (x != px))
+	if ((y != p_ptr->y) && (x != p_ptr->x))
 	{
-		yy = (y < py) ? (y - 1) : (y + 1);
-		xx = (x < px) ? (x - 1) : (x + 1);
+		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 != px) /* y == py */
+	else if (x != p_ptr->x) /* y == p_ptr->y */
 	{
-		xx = (x < px) ? (x - 1) : (x + 1);
+		xx = (x < p_ptr->x) ? (x - 1) : (x + 1);
 		for (i = -1; i <= 1; i++)
 		{
 			yy = y + i;
@@ -450,9 +467,9 @@ void update_local_illumination(int y, int x)
 		yy = y + 1;
 		update_local_illumination_aux(yy, x);
 	}
-	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;
@@ -475,24 +492,24 @@ void update_local_illumination(int y, int x)
 
 #else /* COMPLEX_WALL_ILLUMINATION */
 
-	if ((y != py) && (x != px))
+	if ((y != p_ptr->y) && (x != p_ptr->x))
 	{
-		yy = (y < py) ? (y - 1) : (y + 1);
-		xx = (x < px) ? (x - 1) : (x + 1);
+		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 != px) /* y == py */
+	else if (x != p_ptr->x) /* y == p_ptr->y */
 	{
-		xx = (x < px) ? (x - 1) : (x + 1);
+		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;
@@ -513,39 +530,42 @@ void update_local_illumination(int y, int x)
 }
 
 
-/*
- * 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;
 
@@ -575,30 +595,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;
-
+	OBJECT_IDX this_o_idx, next_o_idx = 0;
 
 	/* Forbid perma-grids */
 	if (cave_perma_grid(c_ptr)) return (FALSE);
@@ -607,8 +626,6 @@ bool cave_valid_bold(int y, int x)
 	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 */
@@ -625,21 +642,24 @@ bool cave_valid_bold(int y, int x)
 
 
 
-/*
- * 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)
@@ -661,11 +681,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)
 	{
@@ -686,11 +708,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)
@@ -705,15 +729,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 */
@@ -765,13 +789,13 @@ 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], byte f_char[F_LIT_MAX])
 {
-	byte s_attr = f_attr[F_LIT_STANDARD];
+	TERM_COLOR s_attr = f_attr[F_LIT_STANDARD];
 	byte s_char = f_char[F_LIT_STANDARD];
 	int i;
 
@@ -790,144 +814,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) */
@@ -1167,8 +1193,6 @@ 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 */
@@ -1208,7 +1232,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;
 		}
 	}
@@ -1376,7 +1399,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))
@@ -1437,12 +1460,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;
@@ -1528,21 +1549,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))
 			{
@@ -1559,7 +1583,7 @@ 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
 			{
@@ -1575,7 +1599,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);
 			}
 		}
 	}
@@ -1587,15 +1611,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 */
@@ -1635,7 +1659,6 @@ void prt_map(void)
 
 	int wid, hgt;
 
-	/* Get size */
 	Term_get_size(&wid, &hgt);
 
 	/* Remove map offset */
@@ -1674,10 +1697,10 @@ void prt_map(void)
 		/* Scan the columns of row "y" */
 		for (x = xmin; x <= xmax; x++)
 		{
-			byte a;
+			TERM_COLOR a;
 			char c;
 
-			byte ta;
+			TERM_COLOR ta;
 			char tc;
 
 			/* Determine what is there */
@@ -1697,7 +1720,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);
@@ -1708,39 +1731,36 @@ 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();
 
 	/* 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;
+			TERM_COLOR ta;
 			char tc;
 
 			if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml)
@@ -1781,7 +1801,7 @@ void prt_path(int y, int x)
 static cptr simplify_list[][2] =
 {
 #ifdef JP
-	{"¤ÎËâË¡½ñ", ""},
+	{"の魔法書", ""},
 	{NULL, NULL}
 #else
 	{"^Ring of ",   "="},
@@ -1808,7 +1828,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];
@@ -1816,11 +1836,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++)
@@ -1854,7 +1870,7 @@ static void display_shortened_item_name(object_type *o_ptr, int y)
 
 	c = buf;
 	len = 0;
-	/* Ⱦ³Ñ 12 ʸ»úʬ¤ÇÀÚ¤ë */
+	/* 半角 12 文字分で切る */
 	while(*c)
 	{
 #ifdef JP
@@ -1883,16 +1899,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;
 
@@ -1905,7 +1921,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;
@@ -1919,7 +1934,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);
@@ -1929,7 +1944,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);
@@ -1950,7 +1965,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);
 
@@ -1958,7 +1973,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);
 
@@ -1978,7 +1993,6 @@ void display_map(int *cy, int *cx)
 	{
 		for (j = 0; j < cur_hgt; ++j)
 		{
-			/* Location */
 			x = i / xrat + 1;
 			y = j / yrat + 1;
 
@@ -1990,7 +2004,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
@@ -2012,7 +2026,6 @@ void display_map(int *cy, int *cx)
 	{
 		for (i = 0; i < cur_wid; ++i)
 		{
-			/* Location */
 			x = i / xrat + 1;
 			y = j / yrat + 1;
 
@@ -2118,11 +2131,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;
@@ -2132,40 +2145,40 @@ 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)
 {
@@ -2176,13 +2189,8 @@ 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();
 
 	/* Clear the screen */
@@ -2208,11 +2216,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);
@@ -2245,11 +2250,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();
@@ -2495,7 +2497,6 @@ void forget_lite(void)
 		/* Forget "LITE" flag */
 		cave[y][x].info &= ~(CAVE_LITE);
 
-		/* Redraw */
 		/* lite_spot(y, x); Perhaps don't need? */
 	}
 
@@ -2529,8 +2530,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
@@ -2587,7 +2586,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
 
@@ -2621,54 +2620,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);
 		}
 	}
 
@@ -2681,43 +2680,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 */
@@ -2725,8 +2724,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;
@@ -2792,15 +2791,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; */
@@ -2815,11 +2815,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)
@@ -2836,11 +2836,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)
@@ -2883,7 +2883,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;
@@ -2901,11 +2901,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)
@@ -2922,11 +2922,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)
@@ -2970,8 +2970,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;
@@ -3204,8 +3204,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++;
 	}
 
@@ -3264,7 +3264,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)
 	{
@@ -3272,19 +3272,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."));
 			}
 		}
 	}
@@ -3327,10 +3319,8 @@ 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 */
@@ -3357,7 +3347,7 @@ void forget_view(void)
 #define cave_view_hack(C,Y,X) \
 {\
     if (!((C)->info & (CAVE_VIEW))){\
-    (C)->info |= (CAVE_VIEW | CAVE_KNOWN); \
+    (C)->info |= (CAVE_VIEW); \
     view_y[view_n] = (Y); \
     view_x[view_n] = (X); \
     view_n++;}\
@@ -3372,8 +3362,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()".
@@ -3382,7 +3372,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;
 
@@ -3411,8 +3401,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];
 
 
@@ -3463,7 +3451,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);
 
@@ -3570,14 +3558,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;
 
@@ -3611,8 +3600,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" */
@@ -3633,10 +3620,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 */
@@ -3984,8 +3969,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 */
@@ -4003,8 +3986,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 */
@@ -4039,8 +4020,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) */
@@ -4049,11 +4028,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);
@@ -4069,7 +4047,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++)
@@ -4090,8 +4068,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;
 
 
 
@@ -4110,7 +4088,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;
 
@@ -4135,12 +4113,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)
@@ -4158,8 +4136,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 */
@@ -4220,8 +4198,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] = 
@@ -4259,8 +4237,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;
@@ -4286,12 +4264,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;
 
@@ -4300,7 +4279,7 @@ 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];
 
@@ -4341,10 +4320,8 @@ void map_area(int range)
 		}
 	}
 
-	/* Redraw map */
 	p_ptr->redraw |= (PR_MAP);
 
-	/* Window stuff */
 	p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 }
 
@@ -4368,8 +4345,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 */
@@ -4408,8 +4386,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];
@@ -4445,18 +4423,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);
 	}
 }
 
@@ -4466,8 +4439,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++)
@@ -4514,30 +4487,17 @@ void wiz_dark(void)
 	/* 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);
-
-	/* Update the view and 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];
@@ -4554,7 +4514,8 @@ void cave_set_feat(int y, int x, int 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;
+			DIRECTION i;
+			POSITION yy, xx;
 
 			for (i = 0; i < 9; i++)
 			{
@@ -4590,14 +4551,10 @@ void cave_set_feat(int y, int x, int feat)
 
 	/* 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);
 
-	/* Update the monster */
-	if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE);
-
-	/* Notice */
 	note_spot(y, x);
 
-	/* Redraw */
 	lite_spot(y, x);
 
 	/* Check if los has changed */
@@ -4617,7 +4574,8 @@ void cave_set_feat(int y, int x, int 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;
+		DIRECTION i;
+		POSITION yy, xx;
 		cave_type *cc_ptr;
 
 		for (i = 0; i < 9; i++)
@@ -4630,13 +4588,10 @@ void cave_set_feat(int y, int x, int feat)
 
 			if (player_has_los_grid(cc_ptr))
 			{
-				/* Update the monster */
-				if (cc_ptr->m_idx) update_mon(cc_ptr->m_idx, FALSE);
+				if (cc_ptr->m_idx) update_monster(cc_ptr->m_idx, FALSE);
 
-				/* Notice */
 				note_spot(yy, xx);
 
-				/* Redraw */
 				lite_spot(yy, xx);
 			}
 
@@ -4645,13 +4600,13 @@ void cave_set_feat(int y, int x, int feat)
 
 		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);
 		}
 	}
 }
 
 
-int conv_dungeon_feat(int newfeat)
+FEAT_IDX conv_dungeon_feat(FEAT_IDX newfeat)
 {
 	feature_type *f_ptr = &f_info[newfeat];
 
@@ -4685,7 +4640,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;
@@ -4705,13 +4660,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;
+	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;
@@ -4743,11 +4698,7 @@ 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!"));
 		}
 	}
 
@@ -4765,7 +4716,7 @@ void cave_alter_feat(int y, int x, int action)
 
 
 /* Remove a mirror */
-void remove_mirror(int y, int x)
+void remove_mirror(POSITION y, POSITION x)
 {
 	cave_type *c_ptr = &cave[y][x];
 
@@ -4777,17 +4728,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);
 }
 
@@ -4832,9 +4779,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;
@@ -4890,9 +4837,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];
@@ -4926,12 +4873,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)
@@ -4946,8 +4890,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 */
@@ -4961,7 +4912,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;
@@ -4978,12 +4929,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);
 }
 
@@ -4992,12 +4942,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);
 }
 
@@ -5012,7 +4961,7 @@ void object_kind_track(int k_idx)
  *
  * All disturbance cancels repeated commands, resting, and running.
  */
-void disturb(int stop_search, int stop_travel)
+void disturb(bool stop_search, bool stop_travel)
 {
 #ifndef TRAVEL
 	/* Unused */
@@ -5079,7 +5028,8 @@ void disturb(int stop_search, int stop_travel)
  */
 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 */
@@ -5109,6 +5059,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;
+}