X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=src%2Fcave.c;h=815f960aa31ae79c3db863927493e8e834ffe4ac;hb=06755ee0e4bd561506eae751bcda51d65d858138;hp=a15d71c449a37c581cddcf02607c99b2fbbf56b2;hpb=3116f77b04c8c90e2201836617c7b9ce2ef65907;p=hengband%2Fhengband.git

diff --git a/src/cave.c b/src/cave.c
index a15d71c44..815f960aa 100644
--- a/src/cave.c
+++ b/src/cave.c
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @file cave.c
  * @brief ダンジョンの基礎部分実装(主にマスの実装) / low level dungeon routines -BEN-
  * @date 2013/12/30
@@ -31,18 +31,18 @@ static int feat_priority; /*!< マップ縮小表示時に表示すべき地形
  * @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;
@@ -67,7 +67,7 @@ int distance (int y1, int x1, int y2, int x2)
  * @param feat 地形情報のID
  * @return 罠持ちの地形ならばTRUEを返す。
  */
-bool is_trap(int feat)
+bool is_trap(IDX feat)
 {
 	return have_flag(f_info[feat].flags, FF_TRAP);
 }
@@ -90,7 +90,7 @@ bool is_known_trap(cave_type *c_ptr)
  * @param feat 地形情報のID
  * @return 閉じたドアのある地形ならばTRUEを返す。
  */
-bool is_closed_door(int feat)
+bool is_closed_door(IDX feat)
 {
 	feature_type *f_ptr = &f_info[feat];
 
@@ -154,10 +154,10 @@ bool is_hidden_door(cave_type *c_ptr)
  *\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;
@@ -386,11 +386,11 @@ bool los(int y1, int x1, int y2, int x2)
  * @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 */
 
@@ -437,25 +437,26 @@ static bool check_local_illumination(int y, int x)
  * @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;
@@ -466,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;
@@ -491,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;
@@ -564,7 +565,7 @@ void update_local_illumination(int y, int x)
  * "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;
 
@@ -601,7 +602,7 @@ bool player_can_see_bold(int y, int x)
  */
 bool no_lite(void)
 {
-	return (!player_can_see_bold(py, px));
+	return (!player_can_see_bold(p_ptr->y, p_ptr->x));
 }
 
 
@@ -613,12 +614,10 @@ bool no_lite(void)
  * @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);
@@ -662,7 +661,7 @@ static char image_object_hack[] = "?/|\\\"!$()_-=[]{},~";
  * @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)
@@ -690,7 +689,7 @@ static void image_monster(byte *ap, char *cp)
  * @param cp 本来のシンボル
  * @return なし
  */
-static void image_object(byte *ap, char *cp)
+static void image_object(TERM_COLOR *ap, char *cp)
 {
 	if (use_graphics)
 	{
@@ -717,7 +716,7 @@ static void image_object(byte *ap, char *cp)
  * @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)
@@ -796,9 +795,9 @@ static byte lighting_colours[16][2] =
  * @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;
 
@@ -943,20 +942,20 @@ void apply_default_feat_lighting(byte f_attr[F_LIT_MAX], byte f_char[F_LIT_MAX])
  * "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) */
@@ -1237,7 +1236,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;
 		}
 	}
@@ -1405,7 +1403,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))
@@ -1466,12 +1464,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;
@@ -1565,16 +1561,16 @@ void note_spot(int y, int x)
 
 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))
 			{
@@ -1591,7 +1587,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
 			{
@@ -1607,7 +1603,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);
 			}
 		}
 	}
@@ -1619,15 +1615,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 */
@@ -1667,7 +1663,6 @@ void prt_map(void)
 
 	int wid, hgt;
 
-	/* Get size */
 	Term_get_size(&wid, &hgt);
 
 	/* Remove map offset */
@@ -1706,10 +1701,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 */
@@ -1729,7 +1724,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);
@@ -1740,19 +1735,19 @@ 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);
@@ -1769,10 +1764,10 @@ void prt_path(int y, int x)
 
 		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)
@@ -1840,7 +1835,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];
@@ -1911,16 +1906,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;
 
@@ -1933,7 +1928,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;
@@ -1947,7 +1941,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);
@@ -1957,7 +1951,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);
@@ -1978,7 +1972,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);
 
@@ -1986,7 +1980,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);
 
@@ -2006,7 +2000,6 @@ void display_map(int *cy, int *cx)
 	{
 		for (j = 0; j < cur_hgt; ++j)
 		{
-			/* Location */
 			x = i / xrat + 1;
 			y = j / yrat + 1;
 
@@ -2018,7 +2011,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
@@ -2040,7 +2033,6 @@ void display_map(int *cy, int *cx)
 	{
 		for (i = 0; i < cur_wid; ++i)
 		{
-			/* Location */
 			x = i / xrat + 1;
 			y = j / yrat + 1;
 
@@ -2146,11 +2138,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;
@@ -2160,7 +2152,7 @@ void display_map(int *cy, int *cx)
 	for (y = 0; y < (hgt + 2); y++)
 	{
 		/* Free one row each array */
-		C_KILL(ma[y], (wid + 2), byte);
+		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);
@@ -2168,7 +2160,7 @@ void display_map(int *cy, int *cx)
 	}
 
 	/* Free each line map */
-	C_KILL(ma, (hgt + 2), byte_ptr);
+	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);
@@ -2178,13 +2170,13 @@ void display_map(int *cy, int *cx)
 	for (y = 0; y < (cur_hgt + 2); y++)
 	{
 		/* Free one row each array */
-		C_KILL(bigma[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_KILL(bigma, (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);
 }
@@ -2193,7 +2185,7 @@ void display_map(int *cy, int *cx)
 /*
  * 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)
 {
@@ -2547,8 +2539,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
@@ -2605,7 +2595,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
 
@@ -2639,54 +2629,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);
 		}
 	}
 
@@ -2699,43 +2689,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 */
@@ -2743,8 +2733,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;
@@ -2810,15 +2800,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; */
@@ -2833,11 +2824,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)
@@ -2854,11 +2845,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)
@@ -2901,7 +2892,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;
@@ -2919,11 +2910,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)
@@ -2940,11 +2931,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)
@@ -2988,8 +2979,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;
@@ -3222,8 +3213,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++;
 	}
 
@@ -3282,7 +3273,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)
 	{
@@ -3337,10 +3328,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 */
@@ -3382,8 +3371,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()".
@@ -3392,7 +3381,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;
 
@@ -3421,8 +3410,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];
 
 
@@ -3473,7 +3460,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);
 
@@ -3580,14 +3567,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;
 
@@ -3621,8 +3609,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" */
@@ -3643,10 +3629,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 */
@@ -3994,8 +3978,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 */
@@ -4013,8 +3995,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 */
@@ -4049,8 +4029,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) */
@@ -4079,7 +4057,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++)
@@ -4100,8 +4078,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;
 
 
 
@@ -4120,7 +4098,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;
 
@@ -4145,12 +4123,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)
@@ -4168,8 +4146,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 */
@@ -4230,8 +4208,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] = 
@@ -4269,8 +4247,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;
@@ -4296,12 +4274,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;
 
@@ -4310,7 +4289,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];
 
@@ -4354,7 +4333,6 @@ void map_area(int range)
 	/* Redraw map */
 	p_ptr->redraw |= (PR_MAP);
 
-	/* Window stuff */
 	p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 }
 
@@ -4378,8 +4356,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 */
@@ -4418,8 +4397,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];
@@ -4461,12 +4440,11 @@ void wiz_lite(bool ninja)
 	/* 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);
 	}
 }
 
@@ -4476,8 +4454,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++)
@@ -4536,18 +4514,13 @@ void wiz_dark(void)
 	/* 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];
@@ -4564,7 +4537,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++)
 			{
@@ -4604,7 +4578,6 @@ void cave_set_feat(int y, int x, int feat)
 	/* Update the monster */
 	if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE);
 
-	/* Notice */
 	note_spot(y, x);
 
 	/* Redraw */
@@ -4627,7 +4600,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++)
@@ -4643,7 +4617,6 @@ void cave_set_feat(int y, int x, int feat)
 				/* Update the monster */
 				if (cc_ptr->m_idx) update_mon(cc_ptr->m_idx, FALSE);
 
-				/* Notice */
 				note_spot(yy, xx);
 
 				/* Redraw */
@@ -4655,13 +4628,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];
 
@@ -4695,7 +4668,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;
@@ -4715,13 +4688,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;
@@ -4771,7 +4744,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];
 
@@ -4790,7 +4763,6 @@ void remove_mirror(int y, int x)
 		update_local_illumination(y, x);
 	}
 
-	/* Notice */
 	note_spot(y, x);
 
 	/* Redraw */
@@ -4838,9 +4810,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;
@@ -4896,9 +4868,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];
@@ -4932,12 +4904,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)
@@ -4952,8 +4921,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 */
@@ -4967,7 +4943,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;
@@ -4984,12 +4960,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);
 }
 
@@ -4998,12 +4973,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);
 }
 
@@ -5018,7 +4992,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 */
@@ -5085,7 +5059,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 */
@@ -5118,3 +5093,81 @@ void glow_deep_lava_and_bldg(void)
 	/* 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;
+}