#include "angband.h"
+#include "world.h"
static byte display_autopick; /*!< 自動拾い状態の設定フラグ */
static int match_autopick;
* @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;
* @param feat 地形情報のID
* @return 罠持ちの地形ならばTRUEを返す。
*/
-bool is_trap(int feat)
+bool is_trap(FEAT_IDX feat)
{
return have_flag(f_info[feat].flags, FF_TRAP);
}
* @param feat 地形情報のID
* @return 閉じたドアのある地形ならばTRUEを返す。
*/
-bool is_closed_door(int feat)
+bool is_closed_door(FEAT_IDX feat)
{
feature_type *f_ptr = &f_info[feat];
*\n
* Use the "update_view()" function to determine player line-of-sight.\n
*/
-bool los(int y1, int x1, int y2, int x2)
+bool los(POSITION y1, POSITION x1, POSITION y2, POSITION x2)
{
/* Delta */
- int dx, dy;
+ POSITION dx, dy;
/* Absolute */
- int ax, ay;
+ POSITION ax, ay;
/* Signs */
- int sx, sy;
+ POSITION sx, sy;
/* Fractions */
- int qx, qy;
+ POSITION qx, qy;
/* Scanners */
- int tx, ty;
+ POSITION tx, ty;
/* Scale factors */
- int f1, f2;
+ POSITION f1, f2;
/* Slope, or 1/Slope, of LOS */
- int m;
+ POSITION m;
/* Extract the offset */
* @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 < p_ptr->y) ? (y + 1) : (y > p_ptr->y) ? (y - 1) : y;
- int xx = (x < p_ptr->x) ? (x + 1) : (x > p_ptr->x) ? (x - 1) : x;
+ 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 */
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)); \
* @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;
* "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;
* @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);
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 */
* @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)
* @param cp 本来のシンボル
* @return なし
*/
-static void image_object(byte *ap, char *cp)
+static void image_object(TERM_COLOR *ap, char *cp)
{
if (use_graphics)
{
* @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)
* @brief 調査中
* @todo コメントを付加すること
*/
-void apply_default_feat_lighting(byte f_attr[F_LIT_MAX], byte f_char[F_LIT_MAX])
+void apply_default_feat_lighting(TERM_COLOR f_attr[F_LIT_MAX], SYMBOL_CODE f_char[F_LIT_MAX])
{
- byte s_attr = f_attr[F_LIT_STANDARD];
- byte s_char = f_char[F_LIT_STANDARD];
+ TERM_COLOR s_attr = f_attr[F_LIT_STANDARD];
+ SYMBOL_CODE s_char = f_char[F_LIT_STANDARD];
int i;
if (is_ascii_graphics(s_attr)) /* For ASCII */
* "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) */
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 */
/* Hack -- hallucination */
if (p_ptr->image) image_object(ap, cp);
- /* Done */
break;
}
}
/*
* 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))
* 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;
void display_dungeon(void)
{
- int x, y;
- byte a;
+ TERM_LEN x, y;
+ TERM_COLOR a;
char c;
- byte ta = 0;
+ TERM_COLOR ta = 0;
char tc = '\0';
for (x = p_ptr->x - Term->wid / 2 + 1; x <= p_ptr->x + Term->wid / 2; x++)
*
* 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 */
*/
void prt_map(void)
{
- int x, y;
- int v;
+ POSITION x, y;
+ int v;
/* map bounds */
- s16b xmin, xmax, ymin, ymax;
+ POSITION xmin, xmax, ymin, ymax;
- int wid, hgt;
+ TERM_LEN wid, hgt;
- /* Get size */
Term_get_size(&wid, &hgt);
/* Remove map offset */
/* Scan the columns of row "y" */
for (x = xmin; x <= xmax; x++)
{
- byte a;
- char c;
+ TERM_COLOR a;
+ SYMBOL_CODE c;
- byte ta;
- char tc;
+ TERM_COLOR ta;
+ SYMBOL_CODE tc;
/* Determine what is there */
map_info(y, x, &a, &c, &ta, &tc);
/*
* 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)
/* Get projection path */
path_n = project_path(path_g, (project_length ? project_length : MAX_RANGE), p_ptr->y, p_ptr->x, y, x, PROJECT_PATH|PROJECT_THRU);
- /* Redraw map */
p_ptr->redraw |= (PR_MAP);
-
- /* Redraw stuff */
- redraw_stuff();
+ handle_stuff();
/* Draw path */
for (i = 0; i < path_n; i++)
{
- int ny = GRID_Y(path_g[i]);
- int nx = GRID_X(path_g[i]);
+ POSITION ny = GRID_Y(path_g[i]);
+ POSITION nx = GRID_X(path_g[i]);
cave_type *c_ptr = &cave[ny][nx];
if (panel_contains(ny, nx))
{
- byte a = default_color;
+ TERM_COLOR a = default_color;
char c;
- byte ta;
- char tc;
+ TERM_COLOR ta = default_color;
+ char tc = '*';
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml)
{
}
-static cptr simplify_list[][2] =
+static concptr simplify_list[][2] =
{
#ifdef JP
{"の魔法書", ""},
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];
int i;
for (i = 0; simplify_list[i][1]; i++)
{
- cptr org_w = simplify_list[i][0];
+ concptr org_w = simplify_list[i][0];
if (*org_w == '^')
{
if (!strncmp(c, org_w, strlen(org_w)))
{
char *s = c;
- cptr tmp = simplify_list[i][1];
+ concptr tmp = simplify_list[i][1];
while (*tmp)
*s++ = *tmp++;
tmp = c + strlen(org_w);
{
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;
int **match_autopick_yx;
object_type ***object_autopick_yx;
- /* Get size */
Term_get_size(&wid, &hgt);
hgt -= 2;
wid -= 14;
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);
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);
}
/* 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);
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);
{
for (j = 0; j < cur_hgt; ++j)
{
- /* Location */
x = i / xrat + 1;
y = j / yrat + 1;
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
{
for (i = 0; i < cur_wid; ++i)
{
- /* Location */
x = i / xrat + 1;
y = j / yrat + 1;
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);
}
/* 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);
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);
}
/*
* Display a "small-scale" map of the dungeon for the player
*
- * Currently, the "player" is displayed on the map. XXX XXX XXX
+ * Currently, the "player" is displayed on the map.
*/
void do_cmd_view_map(void)
{
int cy, cx;
-
- /* Save the screen */
screen_save();
/* Note */
prt(_("お待ち下さい...", "Please wait..."), 0, 0);
- /* Flush */
Term_fresh();
-
- /* Clear the screen */
Term_clear();
display_autopick = 0;
/* Get any key */
inkey();
}
-
- /* Restore the screen */
screen_load();
}
/* Forget "LITE" flag */
cave[y][x].info &= ~(CAVE_LITE);
- /* Redraw */
/* lite_spot(y, x); Perhaps don't need? */
}
/*
- * 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
/*
* 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;
cave_type *c_ptr;
POSITION fx, fy;
- void (*add_mon_lite)(int, int);
+ void (*add_mon_lite)(POSITION, POSITION);
int f_flag;
s16b end_temp;
/* 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 */
*
* 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;
/* Totally blocked by "unviewable neighbors" */
if (!v1 && !v2) return (TRUE);
-
- /* Access the grid */
c_ptr = &cave[y][x];
{
y = view_y[n];
x = view_x[n];
-
- /* Access the grid */
c_ptr = &cave[y][x];
/* Mark the grid as not in "view" */
/* Now start on the player */
y = p_ptr->y;
x = p_ptr->x;
-
- /* Access the grid */
c_ptr = &cave[y][x];
/* Assume the player grid is easily viewable */
{
y = view_y[n];
x = view_x[n];
-
- /* Access the grid */
c_ptr = &cave[y][x];
/* Clear the "CAVE_XTRA" flag */
{
y = temp_y[n];
x = temp_x[n];
-
- /* Access the grid */
c_ptr = &cave[y][x];
/* No longer in the array */
{
y = redraw_y[i];
x = redraw_x[i];
-
- /* Access the grid */
c_ptr = &cave[y][x];
/* Update only needed grids (prevent multiple updating) */
/* 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);
*/
void forget_flow(void)
{
- int x, y;
+ POSITION x, y;
/* Check the entire dungeon */
for (y = 0; y < cur_hgt; y++)
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 */
*/
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] =
/*
* 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;
}
}
- /* Redraw map */
p_ptr->redraw |= (PR_MAP);
- /* Window stuff */
p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
}
*/
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 */
/* 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];
}
}
- /* 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)
*/
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++)
/* 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(POSITION y, POSITION x, IDX 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];
/* 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++)
{
/* 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 */
/* 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++)
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);
}
}
-int conv_dungeon_feat(int newfeat)
+FEAT_IDX conv_dungeon_feat(FEAT_IDX newfeat)
{
feature_type *f_ptr = &f_info[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;
* Takes a location and action and changes the feature at that
* location through applying the given action.
*/
-void cave_alter_feat(int y, int x, int action)
+void cave_alter_feat(POSITION y, POSITION x, int action)
{
/* Set old feature */
- int oldfeat = cave[y][x].feat;
+ FEAT_IDX oldfeat = cave[y][x].feat;
/* Get the new feat */
- int newfeat = feat_state(oldfeat, action);
+ FEAT_IDX newfeat = feat_state(oldfeat, action);
/* No change */
if (newfeat == oldfeat) return;
/* Remove a mirror */
-void remove_mirror(int y, int x)
+void remove_mirror(POSITION y, POSITION x)
{
cave_type *c_ptr = &cave[y][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);
}
* 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;
*
* 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];
*
* Currently the "m" parameter is unused.
*/
-void scatter(POSITION *yp, POSITION *xp, POSITION y, POSITION x, POSITION d, int m)
+void scatter(POSITION *yp, POSITION *xp, POSITION y, POSITION x, POSITION d, BIT_FLAGS mode)
{
POSITION nx, ny;
- /* Unused */
- m = m;
-
/* Pick a location */
while (TRUE)
{
/* 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 */
/*
* 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;
/*
* 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);
}
/*
* 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);
}
*
* 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 */
*/
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 */
/* 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;
+}