#include "player-status.h"
#include "player-effects.h"
#include "player-class.h"
+#include "player-inventory.h"
#include "player-personality.h"
#include "spells-floor.h"
#include "feature.h"
#include "autopick.h"
#include "targeting.h"
-
#ifdef TRAVEL
/* for travel */
travel_type travel;
*/
static void discover_hidden_things(player_type *creature_ptr, POSITION y, POSITION x)
{
- OBJECT_IDX this_o_idx, next_o_idx = 0;
grid_type *g_ptr;
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
g_ptr = &floor_ptr->grid_array[y][x];
- /* Invisible trap */
if (g_ptr->mimic && is_trap(g_ptr->feat))
{
disclose_grid(creature_ptr, y, x);
disturb(creature_ptr, FALSE, TRUE);
}
- /* Secret door */
if (is_hidden_door(g_ptr))
{
msg_print(_("隠しドアを発見した。", "You have found a secret door."));
}
/* Scan all objects in the grid */
- for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
+ OBJECT_IDX next_o_idx = 0;
+ for (OBJECT_IDX this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
{
object_type *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
/*!
* @brief プレイヤーの探索処理判定
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @return なし
*/
void search(player_type *creature_ptr)
{
- DIRECTION i;
- PERCENTAGE chance;
-
/* Start with base search ability */
- chance = creature_ptr->skill_srh;
+ PERCENTAGE chance = creature_ptr->skill_srh;
/* Penalize various conditions */
if (creature_ptr->blind || no_lite(creature_ptr)) chance = chance / 10;
if (creature_ptr->confused || creature_ptr->image) chance = chance / 10;
/* Search the nearby grids, which are always in bounds */
- for (i = 0; i < 9; ++ i)
+ for (DIRECTION i = 0; i < 9; ++ i)
{
/* Sometimes, notice things */
if (randint0(100) < chance)
/*!
* @brief プレイヤーがオブジェクトを拾った際のメッセージ表示処理 /
* Helper routine for py_pickup() and py_pickup_floor().
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param o_idx 取得したオブジェクトの参照ID
* @return なし
* @details
*/
void py_pickup_aux(player_type *owner_ptr, OBJECT_IDX o_idx)
{
- INVENTORY_IDX slot;
-
#ifdef JP
GAME_TEXT o_name[MAX_NLEN];
GAME_TEXT old_name[MAX_NLEN];
#endif
object_type *o_ptr;
-
o_ptr = &owner_ptr->current_floor_ptr->o_list[o_idx];
#ifdef JP
object_desc_kosuu(kazu_str, o_ptr);
hirottakazu = o_ptr->number;
#endif
+
/* Carry the object */
- slot = inven_carry(owner_ptr, o_ptr);
+ INVENTORY_IDX slot = inven_carry(owner_ptr, o_ptr);
/* Get the object again */
o_ptr = &owner_ptr->inventory_list[slot];
}
}
}
+
strcpy(record_o_name, old_name);
#else
msg_format("You have %s (%c).", o_name, index_to_label(slot));
strcpy(record_o_name, o_name);
#endif
record_turn = current_world_ptr->game_turn;
-
-
check_find_art_quest_completion(owner_ptr, o_ptr);
}
/*!
* @brief プレイヤーがオブジェクト上に乗った際の表示処理
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param pickup 自動拾い処理を行うならばTRUEとする
* @return なし
* @details
*/
void carry(player_type *creature_ptr, bool pickup)
{
- grid_type *g_ptr = &creature_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x];
-
- OBJECT_IDX this_o_idx, next_o_idx = 0;
-
- GAME_TEXT o_name[MAX_NLEN];
-
/* Recenter the map around the player */
- verify_panel();
+ verify_panel(creature_ptr);
creature_ptr->update |= (PU_MONSTERS);
creature_ptr->redraw |= (PR_MAP);
handle_stuff(creature_ptr);
/* Automatically pickup/destroy/inscribe items */
+ grid_type *g_ptr = &creature_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x];
autopick_pickup_items(creature_ptr, g_ptr);
if (easy_floor)
}
/* Scan the pile of objects */
- for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
+ OBJECT_IDX next_o_idx = 0;
+ for (OBJECT_IDX this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
{
object_type *o_ptr;
o_ptr = &creature_ptr->current_floor_ptr->o_list[this_o_idx];
#endif /* ALLOW_EASY_SENSE -- TNB */
+ GAME_TEXT o_name[MAX_NLEN];
object_desc(o_name, o_ptr, 0);
next_o_idx = o_ptr->next_o_idx;
disturb(creature_ptr, FALSE, FALSE);
- /* Pick up gold */
if (o_ptr->tval == TV_GOLD)
{
int value = (long)o_ptr->pval;
-
- /* Delete the gold */
delete_object_idx(creature_ptr->current_floor_ptr, this_o_idx);
-
msg_format(_(" $%ld の価値がある%sを見つけた。", "You collect %ld gold pieces worth of %s."),
(long)value, o_name);
sound(SOUND_SELL);
- /* Collect the gold */
creature_ptr->au += value;
-
- /* Redraw gold */
creature_ptr->redraw |= (PR_GOLD);
creature_ptr->window |= (PW_PLAYER);
+ continue;
}
- /* Pick up objects */
- else
+ /* Hack - some objects were handled in autopick_pickup_items(). */
+ if (o_ptr->marked & OM_NOMSG)
{
- /* Hack - some objects were handled in autopick_pickup_items(). */
- if (o_ptr->marked & OM_NOMSG)
- {
- /* Clear the flag. */
- o_ptr->marked &= ~OM_NOMSG;
- }
- else if (!pickup)
- {
- msg_format(_("%sがある。", "You see %s."), o_name);
- }
-
- /* Note that the pack is too full */
- else if (!inven_carry_okay(o_ptr))
- {
- msg_format(_("ザックには%sを入れる隙間がない。", "You have no room for %s."), o_name);
- }
-
- /* Pick up the item (if requested and allowed) */
- else
- {
- int okay = TRUE;
+ o_ptr->marked &= ~OM_NOMSG;
+ continue;
+ }
+
+ if (!pickup)
+ {
+ msg_format(_("%sがある。", "You see %s."), o_name);
+ continue;
+ }
+
+ if (!inven_carry_okay(o_ptr))
+ {
+ msg_format(_("ザックには%sを入れる隙間がない。", "You have no room for %s."), o_name);
+ continue;
+ }
- /* Hack -- query every item */
- if (carry_query_flag)
- {
- char out_val[MAX_NLEN+20];
- sprintf(out_val, _("%sを拾いますか? ", "Pick up %s? "), o_name);
- okay = get_check(out_val);
- }
+ int is_pickup_successful = TRUE;
+ if (carry_query_flag)
+ {
+ char out_val[MAX_NLEN + 20];
+ sprintf(out_val, _("%sを拾いますか? ", "Pick up %s? "), o_name);
+ is_pickup_successful = get_check(out_val);
+ }
- /* Attempt to pick up an object. */
- if (okay)
- {
- /* Pick up the object */
- py_pickup_aux(creature_ptr, this_o_idx);
- }
- }
+ if (is_pickup_successful)
+ {
+ py_pickup_aux(creature_ptr, this_o_idx);
}
}
}
/*!
* @brief パターンによる移動制限処理
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param c_y プレイヤーの移動元Y座標
* @param c_x プレイヤーの移動元X座標
* @param n_y プレイヤーの移動先Y座標
feature_type *new_f_ptr = &f_info[creature_ptr->current_floor_ptr->grid_array[n_y][n_x].feat];
bool is_pattern_tile_cur = have_flag(cur_f_ptr->flags, FF_PATTERN);
bool is_pattern_tile_new = have_flag(new_f_ptr->flags, FF_PATTERN);
- int pattern_type_cur, pattern_type_new;
if (!is_pattern_tile_cur && !is_pattern_tile_new) return TRUE;
- pattern_type_cur = is_pattern_tile_cur ? cur_f_ptr->subtype : NOT_PATTERN_TILE;
- pattern_type_new = is_pattern_tile_new ? new_f_ptr->subtype : NOT_PATTERN_TILE;
+ int pattern_type_cur = is_pattern_tile_cur ? cur_f_ptr->subtype : NOT_PATTERN_TILE;
+ int pattern_type_new = is_pattern_tile_new ? new_f_ptr->subtype : NOT_PATTERN_TILE;
if (pattern_type_new == PATTERN_TILE_START)
{
else
return TRUE;
}
- else if ((pattern_type_new == PATTERN_TILE_OLD) ||
+
+ if ((pattern_type_new == PATTERN_TILE_OLD) ||
(pattern_type_new == PATTERN_TILE_END) ||
(pattern_type_new == PATTERN_TILE_WRECKED))
{
return FALSE;
}
}
- else if ((pattern_type_new == PATTERN_TILE_TELEPORT) ||
+
+ if ((pattern_type_new == PATTERN_TILE_TELEPORT) ||
(pattern_type_cur == PATTERN_TILE_TELEPORT))
{
return TRUE;
}
- else if (pattern_type_cur == PATTERN_TILE_START)
+
+ if (pattern_type_cur == PATTERN_TILE_START)
{
if (is_pattern_tile_new)
return TRUE;
return FALSE;
}
}
- else if ((pattern_type_cur == PATTERN_TILE_OLD) ||
+
+ if ((pattern_type_cur == PATTERN_TILE_OLD) ||
(pattern_type_cur == PATTERN_TILE_END) ||
(pattern_type_cur == PATTERN_TILE_WRECKED))
{
return TRUE;
}
}
- else
+
+ if (!is_pattern_tile_cur)
{
- if (!is_pattern_tile_cur)
- {
- msg_print(_("パターンの上を歩くにはスタート地点から歩き始めなくてはなりません。",
- "You must start walking the Pattern from the startpoint."));
+ msg_print(_("パターンの上を歩くにはスタート地点から歩き始めなくてはなりません。",
+ "You must start walking the Pattern from the startpoint."));
- return FALSE;
- }
- else
- {
- byte ok_move = PATTERN_TILE_START;
- switch (pattern_type_cur)
- {
- case PATTERN_TILE_1:
- ok_move = PATTERN_TILE_2;
- break;
- case PATTERN_TILE_2:
- ok_move = PATTERN_TILE_3;
- break;
- case PATTERN_TILE_3:
- ok_move = PATTERN_TILE_4;
- break;
- case PATTERN_TILE_4:
- ok_move = PATTERN_TILE_1;
- break;
- default:
- if (current_world_ptr->wizard)
- msg_format(_("おかしなパターン歩行、%d。", "Funny Pattern walking, %d."), pattern_type_cur);
-
- return TRUE; /* Goof-up */
- }
+ return FALSE;
+ }
+
+ byte ok_move = PATTERN_TILE_START;
+ switch (pattern_type_cur)
+ {
+ case PATTERN_TILE_1:
+ ok_move = PATTERN_TILE_2;
+ break;
+ case PATTERN_TILE_2:
+ ok_move = PATTERN_TILE_3;
+ break;
+ case PATTERN_TILE_3:
+ ok_move = PATTERN_TILE_4;
+ break;
+ case PATTERN_TILE_4:
+ ok_move = PATTERN_TILE_1;
+ break;
+ default:
+ if (current_world_ptr->wizard)
+ msg_format(_("おかしなパターン歩行、%d。", "Funny Pattern walking, %d."), pattern_type_cur);
+ return TRUE;
+ }
- if ((pattern_type_new == ok_move) || (pattern_type_new == pattern_type_cur))
- return TRUE;
- else
- {
- if (!is_pattern_tile_new)
- msg_print(_("パターンを踏み外してはいけません。", "You may not step off from the Pattern."));
- else
- msg_print(_("パターンの上は正しい順序で歩かねばなりません。", "You must walk the Pattern in correct order."));
+ if ((pattern_type_new == ok_move) || (pattern_type_new == pattern_type_cur)) return TRUE;
+
+ if (!is_pattern_tile_new)
+ msg_print(_("パターンを踏み外してはいけません。", "You may not step off from the Pattern."));
+ else
+ msg_print(_("パターンの上は正しい順序で歩かねばなりません。", "You must walk the Pattern in correct order."));
- return FALSE;
- }
- }
- }
+ return FALSE;
}
/*!
* @brief 移動に伴うプレイヤーのステータス変化処理
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param ny 移動先Y座標
* @param nx 移動先X座標
* @param mpe_mode 移動オプションフラグ
lite_spot(ny, nx);
/* Check for new panel (redraw map) */
- verify_panel();
+ verify_panel(creature_ptr);
if (mpe_mode & MPE_FORGET_FLOW)
{
/*!
* @brief 該当地形のトラップがプレイヤーにとって無効かどうかを判定して返す
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param feat 地形ID
* @return トラップが自動的に無効ならばTRUEを返す
*/
/*
+ * todo 負論理なので反転させたい
* Determine if a "boundary" grid is "floor mimic"
+ * @param grid_type *g_ptr
+ * @param feature_type *f_ptr
+ * @param feature_type *mimic_f_ptr
+ * @return 移動不能であればTRUE
*/
-#define boundary_floor(C, F, MF) \
- ((C)->mimic && permanent_wall(F) && \
- (have_flag((MF)->flags, FF_MOVE) || have_flag((MF)->flags, FF_CAN_FLY)) && \
- have_flag((MF)->flags, FF_PROJECT) && \
- !have_flag((MF)->flags, FF_OPEN))
+bool boundary_floor(grid_type *g_ptr, feature_type *f_ptr, feature_type *mimic_f_ptr)
+{
+ bool is_boundary_floor = g_ptr->mimic > 0;
+ is_boundary_floor &= permanent_wall(f_ptr);
+ is_boundary_floor &= have_flag((mimic_f_ptr)->flags, FF_MOVE) || have_flag((mimic_f_ptr)->flags, FF_CAN_FLY);
+ is_boundary_floor &= have_flag((mimic_f_ptr)->flags, FF_PROJECT);
+ is_boundary_floor &= !have_flag((mimic_f_ptr)->flags, FF_OPEN);
+ return is_boundary_floor;
+}
/*!
* @brief 該当地形のトラップがプレイヤーにとって無効かどうかを判定して返す /
* Move player in the given direction, with the given "pickup" flag.
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param dir 移動方向ID
* @param do_pickup 罠解除を試みながらの移動ならばTRUE
* @param break_trap トラップ粉砕処理を行うならばTRUE
*/
void move_player(player_type *creature_ptr, DIRECTION dir, bool do_pickup, bool break_trap)
{
- /* Find the result of moving */
POSITION y = creature_ptr->y + ddy[dir];
POSITION x = creature_ptr->x + ddx[dir];
- /* Examine the destination */
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
grid_type *g_ptr = &floor_ptr->grid_array[y][x];
-
- feature_type *f_ptr = &f_info[g_ptr->feat];
-
- monster_type *m_ptr;
-
- monster_type *riding_m_ptr = &floor_ptr->m_list[creature_ptr->riding];
- monster_race *riding_r_ptr = &r_info[creature_ptr->riding ? riding_m_ptr->r_idx : 0];
-
- GAME_TEXT m_name[MAX_NLEN];
-
bool p_can_enter = player_can_enter(creature_ptr, g_ptr->feat, CEM_P_CAN_ENTER_PATTERN);
- bool p_can_kill_walls = FALSE;
bool stormbringer = FALSE;
- bool oktomove = TRUE;
- bool do_past = FALSE;
-
/* Exit the area */
if (!floor_ptr->dun_level && !creature_ptr->wild_mode &&
((x == 0) || (x == MAX_WID - 1) ||
p_can_enter = FALSE;
}
+ monster_type *m_ptr;
m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
if (creature_ptr->inventory_list[INVEN_RARM].name1 == ART_STORMBRINGER) stormbringer = TRUE;
/* Player can not walk through "walls"... */
/* unless in Shadow Form */
- p_can_kill_walls = creature_ptr->kill_wall && have_flag(f_ptr->flags, FF_HURT_DISI) &&
+ feature_type *f_ptr = &f_info[g_ptr->feat];
+ bool p_can_kill_walls = creature_ptr->kill_wall && have_flag(f_ptr->flags, FF_HURT_DISI) &&
(!p_can_enter || !have_flag(f_ptr->flags, FF_LOS)) &&
!have_flag(f_ptr->flags, FF_PERMANENT);
/* Hack -- attack monsters */
+ GAME_TEXT m_name[MAX_NLEN];
+ bool can_move = TRUE;
+ bool do_past = FALSE;
if (g_ptr->m_idx && (m_ptr->ml || p_can_enter || p_can_kill_walls))
{
monster_race *r_ptr = &r_info[m_ptr->r_idx];
pattern_seq(creature_ptr, creature_ptr->y, creature_ptr->x, y, x) && (p_can_enter || p_can_kill_walls))
{
/* Disturb the monster */
- (void)set_monster_csleep(g_ptr->m_idx, 0);
+ (void)set_monster_csleep(creature_ptr, g_ptr->m_idx, 0);
- monster_desc(m_name, m_ptr, 0);
+ monster_desc(creature_ptr, m_name, m_ptr, 0);
if (m_ptr->ml)
{
/* Auto-Recall if possible and visible */
- if (!creature_ptr->image) monster_race_track(m_ptr->ap_r_idx);
- health_track(g_ptr->m_idx);
+ if (!creature_ptr->image) monster_race_track(creature_ptr, m_ptr->ap_r_idx);
+ health_track(creature_ptr, g_ptr->m_idx);
}
/* displace? */
if ((stormbringer && (randint1(1000) > 666)) || (creature_ptr->pclass == CLASS_BERSERKER))
{
py_attack(creature_ptr, y, x, 0);
- oktomove = FALSE;
+ can_move = FALSE;
}
else if (monster_can_cross_terrain(floor_ptr->grid_array[creature_ptr->y][creature_ptr->x].feat, r_ptr, 0))
{
{
msg_format(_("%^sが邪魔だ！", "%^s is in your way!"), m_name);
free_turn(creature_ptr);
- oktomove = FALSE;
+ can_move = FALSE;
}
/* now continue on to 'movement' */
else
{
py_attack(creature_ptr, y, x, 0);
- oktomove = FALSE;
+ can_move = FALSE;
}
}
- if (oktomove && creature_ptr->riding)
+ monster_type *riding_m_ptr = &floor_ptr->m_list[creature_ptr->riding];
+ monster_race *riding_r_ptr = &r_info[creature_ptr->riding ? riding_m_ptr->r_idx : 0];
+ if (can_move && creature_ptr->riding)
{
if (riding_r_ptr->flags1 & RF1_NEVER_MOVE)
{
msg_print(_("動けない！", "Can't move!"));
free_turn(creature_ptr);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
else if (MON_MONFEAR(riding_m_ptr))
{
GAME_TEXT steed_name[MAX_NLEN];
- monster_desc(steed_name, riding_m_ptr, 0);
+ monster_desc(creature_ptr, steed_name, riding_m_ptr, 0);
msg_format(_("%sが恐怖していて制御できない。", "%^s is too scared to control."), steed_name);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
else if (creature_ptr->riding_ryoute)
{
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
else if (have_flag(f_ptr->flags, FF_CAN_FLY) && (riding_r_ptr->flags7 & RF7_CAN_FLY))
{
msg_format(_("%sの上に行けない。", "Can't swim."), f_name + f_info[get_feat_mimic(g_ptr)].name);
free_turn(creature_ptr);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
else if (!have_flag(f_ptr->flags, FF_WATER) && (riding_r_ptr->flags7 & RF7_AQUATIC))
{
msg_format(_("%sから上がれない。", "Can't land."), f_name + f_info[get_feat_mimic(&floor_ptr->grid_array[creature_ptr->y][creature_ptr->x])].name);
free_turn(creature_ptr);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
else if (have_flag(f_ptr->flags, FF_LAVA) && !(riding_r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK))
{
msg_format(_("%sの上に行けない。", "Too hot to go through."), f_name + f_info[get_feat_mimic(g_ptr)].name);
free_turn(creature_ptr);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
- if (oktomove && MON_STUNNED(riding_m_ptr) && one_in_(2))
+ if (can_move && MON_STUNNED(riding_m_ptr) && one_in_(2))
{
GAME_TEXT steed_name[MAX_NLEN];
- monster_desc(steed_name, riding_m_ptr, 0);
+ monster_desc(creature_ptr, steed_name, riding_m_ptr, 0);
msg_format(_("%sが朦朧としていてうまく動けない！", "You cannot control stunned %s!"), steed_name);
- oktomove = FALSE;
+ can_move = FALSE;
disturb(creature_ptr, FALSE, TRUE);
}
}
- if (!oktomove)
+ if (!can_move)
{
}
msg_format(_("空を飛ばないと%sの上には行けない。", "You need to fly to go through the %s."), f_name + f_info[get_feat_mimic(g_ptr)].name);
free_turn(creature_ptr);
creature_ptr->running = 0;
- oktomove = FALSE;
+ can_move = FALSE;
}
/*
if ((creature_ptr->pclass != CLASS_RANGER) && !creature_ptr->levitation && (!creature_ptr->riding || !(riding_r_ptr->flags8 & RF8_WILD_WOOD))) creature_ptr->energy_use *= 2;
}
-
/* Disarm a visible trap */
else if ((do_pickup != easy_disarm) && have_flag(f_ptr->flags, FF_DISARM) && !g_ptr->mimic)
{
}
}
-
/* Player can not walk through "walls" unless in wraith form...*/
else if (!p_can_enter && !p_can_kill_walls)
{
feature_type *mimic_f_ptr = &f_info[feat];
concptr name = f_name + mimic_f_ptr->name;
- oktomove = FALSE;
+ can_move = FALSE;
/* Notice things in the dark */
if (!(g_ptr->info & CAVE_MARK) && !player_can_see_bold(creature_ptr, y, x))
}
/* Normal movement */
- if (oktomove && !pattern_seq(creature_ptr, creature_ptr->y, creature_ptr->x, y, x))
+ if (can_move && !pattern_seq(creature_ptr, creature_ptr->y, creature_ptr->x, y, x))
{
if (!(creature_ptr->confused || creature_ptr->stun || creature_ptr->image))
{
/* To avoid a loop with running */
disturb(creature_ptr, FALSE, TRUE);
- oktomove = FALSE;
+ can_move = FALSE;
}
- /* Normal movement */
- if (oktomove)
- {
- u32b mpe_mode = MPE_ENERGY_USE;
-
- if (creature_ptr->warning)
- {
- if (!process_warning(creature_ptr, x, y))
- {
- creature_ptr->energy_use = 25;
- return;
- }
- }
+ if (!can_move) return;
- if (do_past)
+ if (creature_ptr->warning)
+ {
+ if (!process_warning(creature_ptr, x, y))
{
- msg_format(_("%sを押し退けた。", "You push past %s."), m_name);
+ creature_ptr->energy_use = 25;
+ return;
}
+ }
- /* Change oldpx and oldpy to place the player well when going back to big mode */
- if (creature_ptr->wild_mode)
- {
- if (ddy[dir] > 0) creature_ptr->oldpy = 1;
- if (ddy[dir] < 0) creature_ptr->oldpy = MAX_HGT - 2;
- if (ddy[dir] == 0) creature_ptr->oldpy = MAX_HGT / 2;
- if (ddx[dir] > 0) creature_ptr->oldpx = 1;
- if (ddx[dir] < 0) creature_ptr->oldpx = MAX_WID - 2;
- if (ddx[dir] == 0) creature_ptr->oldpx = MAX_WID / 2;
- }
+ if (do_past)
+ {
+ msg_format(_("%sを押し退けた。", "You push past %s."), m_name);
+ }
- if (p_can_kill_walls)
- {
- cave_alter_feat(creature_ptr, y, x, FF_HURT_DISI);
+ /* Change oldpx and oldpy to place the player well when going back to big mode */
+ if (creature_ptr->wild_mode)
+ {
+ if (ddy[dir] > 0) creature_ptr->oldpy = 1;
+ if (ddy[dir] < 0) creature_ptr->oldpy = MAX_HGT - 2;
+ if (ddy[dir] == 0) creature_ptr->oldpy = MAX_HGT / 2;
+ if (ddx[dir] > 0) creature_ptr->oldpx = 1;
+ if (ddx[dir] < 0) creature_ptr->oldpx = MAX_WID - 2;
+ if (ddx[dir] == 0) creature_ptr->oldpx = MAX_WID / 2;
+ }
- /* Update some things -- similar to GF_KILL_WALL */
- creature_ptr->update |= (PU_FLOW);
- }
+ if (p_can_kill_walls)
+ {
+ cave_alter_feat(creature_ptr, y, x, FF_HURT_DISI);
- /* sound(SOUND_WALK); */
+ /* Update some things -- similar to GF_KILL_WALL */
+ creature_ptr->update |= (PU_FLOW);
+ }
- if (do_pickup != always_pickup) mpe_mode |= MPE_DO_PICKUP;
- if (break_trap) mpe_mode |= MPE_BREAK_TRAP;
+ u32b mpe_mode = MPE_ENERGY_USE;
+ if (do_pickup != always_pickup) mpe_mode |= MPE_DO_PICKUP;
+ if (break_trap) mpe_mode |= MPE_BREAK_TRAP;
- (void)move_player_effect(creature_ptr, y, x, mpe_mode);
- }
+ (void)move_player_effect(creature_ptr, y, x, mpe_mode);
}
*/
static bool see_wall(player_type *creature_ptr, DIRECTION dir, POSITION y, POSITION x)
{
- grid_type *g_ptr;
-
/* Get the new location */
y += ddy[dir];
x += ddx[dir];
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
if (!in_bounds2(floor_ptr, y, x)) return FALSE;
- /* Access grid */
+ grid_type *g_ptr;
g_ptr = &floor_ptr->grid_array[y][x];
/* Must be known to the player */
- if (g_ptr->info & (CAVE_MARK))
- {
- /* Feature code (applying "mimic" field) */
- s16b feat = get_feat_mimic(g_ptr);
- feature_type *f_ptr = &f_info[feat];
+ if (!(g_ptr->info & CAVE_MARK)) return FALSE;
- /* Wall grids are known walls */
- if (!player_can_enter(creature_ptr, feat, 0)) return !have_flag(f_ptr->flags, FF_DOOR);
+ /* Feature code (applying "mimic" field) */
+ s16b feat = get_feat_mimic(g_ptr);
+ feature_type *f_ptr = &f_info[feat];
- /* Don't run on a tree unless explicitly requested */
- if (have_flag(f_ptr->flags, FF_AVOID_RUN) && !ignore_avoid_run)
- return TRUE;
+ /* Wall grids are known walls */
+ if (!player_can_enter(creature_ptr, feat, 0))
+ return !have_flag(f_ptr->flags, FF_DOOR);
- /* Don't run in a wall */
- if (!have_flag(f_ptr->flags, FF_MOVE) && !have_flag(f_ptr->flags, FF_CAN_FLY))
- return !have_flag(f_ptr->flags, FF_DOOR);
- }
+ /* Don't run on a tree unless explicitly requested */
+ if (have_flag(f_ptr->flags, FF_AVOID_RUN) && !ignore_avoid_run)
+ return TRUE;
+
+ /* Don't run in a wall */
+ if (!have_flag(f_ptr->flags, FF_MOVE) && !have_flag(f_ptr->flags, FF_CAN_FLY))
+ return !have_flag(f_ptr->flags, FF_DOOR);
return FALSE;
}
*/
static void run_init(player_type *creature_ptr, DIRECTION dir)
{
- int row, col, deepleft, deepright;
- int i, shortleft, shortright;
-
/* Save the direction */
find_current = dir;
find_breakright = find_breakleft = FALSE;
/* Assume no nearby walls */
- deepleft = deepright = FALSE;
- shortright = shortleft = FALSE;
+ bool deepleft = FALSE;
+ bool deepright = FALSE;
+ bool shortright = FALSE;
+ bool shortleft = FALSE;
creature_ptr->run_py = creature_ptr->y;
creature_ptr->run_px = creature_ptr->x;
/* Find the destination grid */
- row = creature_ptr->y + ddy[dir];
- col = creature_ptr->x + ddx[dir];
+ int row = creature_ptr->y + ddy[dir];
+ int col = creature_ptr->x + ddx[dir];
ignore_avoid_run = cave_have_flag_bold(creature_ptr->current_floor_ptr, row, col, FF_AVOID_RUN);
/* Extract cycle index */
- i = chome[dir];
+ int i = chome[dir];
/* Check for walls */
if (see_wall(creature_ptr, cycle[i+1], creature_ptr->y, creature_ptr->x))
}
/* Looking for a break */
- if (find_breakleft && find_breakright)
- {
- /* Not looking for open area */
- find_openarea = FALSE;
+ if (!find_breakleft || !find_breakright) return;
- /* Hack -- allow angled corridor entry */
- if (dir & 0x01)
+ /* Not looking for open area */
+ find_openarea = FALSE;
+
+ /* Hack -- allow angled corridor entry */
+ if (dir & 0x01)
+ {
+ if (deepleft && !deepright)
{
- if (deepleft && !deepright)
- {
- find_prevdir = cycle[i - 1];
- }
- else if (deepright && !deepleft)
- {
- find_prevdir = cycle[i + 1];
- }
+ find_prevdir = cycle[i - 1];
}
-
- /* Hack -- allow blunt corridor entry */
- else if (see_wall(creature_ptr, cycle[i], row, col))
+ else if (deepright && !deepleft)
{
- if (shortleft && !shortright)
- {
- find_prevdir = cycle[i - 2];
- }
- else if (shortright && !shortleft)
- {
- find_prevdir = cycle[i + 2];
- }
+ find_prevdir = cycle[i + 1];
}
+
+ return;
+ }
+
+ /* Hack -- allow blunt corridor entry */
+ if (!see_wall(creature_ptr, cycle[i], row, col)) return;
+
+ if (shortleft && !shortright)
+ {
+ find_prevdir = cycle[i - 2];
+ }
+ else if (shortright && !shortleft)
+ {
+ find_prevdir = cycle[i + 2];
}
}
*/
static bool run_test(player_type *creature_ptr)
{
- DIRECTION prev_dir, new_dir, check_dir = 0;
- int row, col;
- int i, max, inv;
- int option = 0, option2 = 0;
- grid_type *g_ptr;
- FEAT_IDX feat;
- feature_type *f_ptr;
-
- /* Where we came from */
- prev_dir = find_prevdir;
-
+ DIRECTION prev_dir = find_prevdir;
/* Range of newly adjacent grids */
- max = (prev_dir & 0x01) + 1;
+ int max = (prev_dir & 0x01) + 1;
/* break run when leaving trap detected region */
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
if (disturb_trap_detect)
{
/* Break Run */
- return(TRUE);
+ return TRUE;
}
}
}
/* Look at every newly adjacent square. */
- for (i = -max; i <= max; i++)
+ DIRECTION check_dir = 0;
+ int option = 0, option2 = 0;
+ for (int i = -max; i <= max; i++)
{
OBJECT_IDX this_o_idx, next_o_idx = 0;
/* New direction */
- new_dir = cycle[chome[prev_dir] + i];
+ DIRECTION new_dir = cycle[chome[prev_dir] + i];
/* New location */
- row = creature_ptr->y + ddy[new_dir];
- col = creature_ptr->x + ddx[new_dir];
+ int row = creature_ptr->y + ddy[new_dir];
+ int col = creature_ptr->x + ddx[new_dir];
- /* Access grid */
+ grid_type *g_ptr;
g_ptr = &floor_ptr->grid_array[row][col];
/* Feature code (applying "mimic" field) */
- feat = get_feat_mimic(g_ptr);
+ FEAT_IDX feat = get_feat_mimic(g_ptr);
+ feature_type *f_ptr;
f_ptr = &f_info[feat];
/* Visible monsters abort running */
}
/* Assume unknown */
- inv = TRUE;
+ bool inv = TRUE;
/* Check memorized grids */
if (g_ptr->info & (CAVE_MARK))
}
/* Analyze unknown grids and floors considering mimic */
- if (inv || !see_wall(creature_ptr, 0, row, col))
- {
- /* Looking for open area */
- if (find_openarea)
- {
- /* Nothing */
- }
-
- /* The first new direction. */
- else if (!option)
- {
- option = new_dir;
- }
-
- /* Three new directions. Stop running. */
- else if (option2)
- {
- return TRUE;
- }
-
- /* Two non-adjacent new directions. Stop running. */
- else if (option != cycle[chome[prev_dir] + i - 1])
- {
- return TRUE;
- }
-
- /* Two new (adjacent) directions (case 1) */
- else if (new_dir & 0x01)
- {
- check_dir = cycle[chome[prev_dir] + i - 2];
- option2 = new_dir;
- }
-
- /* Two new (adjacent) directions (case 2) */
- else
- {
- check_dir = cycle[chome[prev_dir] + i + 1];
- option2 = option;
- option = new_dir;
- }
- }
-
- /* Obstacle, while looking for open area */
- else
+ if (!inv && see_wall(creature_ptr, 0, row, col))
{
if (find_openarea)
{
find_breakleft = TRUE;
}
}
+
+ continue;
+ }
+
+ /* Looking for open area */
+ if (find_openarea) continue;
+
+ /* The first new direction. */
+ if (!option)
+ {
+ option = new_dir;
+ continue;
+ }
+
+ /* Three new directions. Stop running. */
+ if (option2)
+ {
+ return TRUE;
+ }
+
+ /* Two non-adjacent new directions. Stop running. */
+ if (option != cycle[chome[prev_dir] + i - 1])
+ {
+ return TRUE;
}
+
+ /* Two new (adjacent) directions (case 1) */
+ if (new_dir & 0x01)
+ {
+ check_dir = cycle[chome[prev_dir] + i - 2];
+ option2 = new_dir;
+ continue;
+ }
+
+ /* Two new (adjacent) directions (case 2) */
+ check_dir = cycle[chome[prev_dir] + i + 1];
+ option2 = option;
+ option = new_dir;
}
/* Looking for open area */
if (find_openarea)
{
/* Hack -- look again */
- for (i = -max; i < 0; i++)
+ for (int i = -max; i < 0; i++)
{
/* Unknown grid or non-wall */
if (!see_wall(creature_ptr, cycle[chome[prev_dir] + i], creature_ptr->y, creature_ptr->x))
}
/* Hack -- look again */
- for (i = max; i > 0; i--)
+ for (int i = max; i > 0; i--)
{
/* Unknown grid or non-wall */
if (!see_wall(creature_ptr, cycle[chome[prev_dir] + i], creature_ptr->y, creature_ptr->x))
}
}
}
+
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
}
- /* Not looking for open area */
- else
+ /* No options */
+ if (!option)
{
- /* No options */
- if (!option)
- {
- return TRUE;
- }
+ return TRUE;
+ }
- /* One option */
- else if (!option2)
- {
- /* Primary option */
- find_current = option;
+ /* One option */
+ if (!option2)
+ {
+ find_current = option;
+ find_prevdir = option;
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
+ }
- /* No other options */
- find_prevdir = option;
- }
+ /* Two options, examining corners */
+ else if (!find_cut)
+ {
+ find_current = option;
+ find_prevdir = option2;
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
+ }
- /* Two options, examining corners */
- else if (!find_cut)
+ /* Two options, pick one */
+ /* Get next location */
+ int row = creature_ptr->y + ddy[option];
+ int col = creature_ptr->x + ddx[option];
+
+ /* Don't see that it is closed off. */
+ /* This could be a potential corner or an intersection. */
+ if (!see_wall(creature_ptr, option, row, col) ||
+ !see_wall(creature_ptr, check_dir, row, col))
+ {
+ /* Can not see anything ahead and in the direction we */
+ /* are turning, assume that it is a potential corner. */
+ if (see_nothing(creature_ptr, option, row, col) &&
+ see_nothing(creature_ptr, option2, row, col))
{
- /* Primary option */
find_current = option;
-
- /* Hack -- allow curving */
find_prevdir = option2;
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
}
- /* Two options, pick one */
- else
- {
- /* Get next location */
- row = creature_ptr->y + ddy[option];
- col = creature_ptr->x + ddx[option];
-
- /* Don't see that it is closed off. */
- /* This could be a potential corner or an intersection. */
- if (!see_wall(creature_ptr, option, row, col) ||
- !see_wall(creature_ptr, check_dir, row, col))
- {
- /* Can not see anything ahead and in the direction we */
- /* are turning, assume that it is a potential corner. */
- if (see_nothing(creature_ptr, option, row, col) &&
- see_nothing(creature_ptr, option2, row, col))
- {
- find_current = option;
- find_prevdir = option2;
- }
-
- /* STOP: we are next to an intersection or a room */
- else
- {
- return TRUE;
- }
- }
-
- /* This corner is seen to be enclosed; we cut the corner. */
- else if (find_cut)
- {
- find_current = option2;
- find_prevdir = option2;
- }
-
- /* This corner is seen to be enclosed, and we */
- /* deliberately go the long way. */
- else
- {
- find_current = option;
- find_prevdir = option2;
- }
- }
+ /* STOP: we are next to an intersection or a room */
+ return TRUE;
}
- /* About to hit a known wall, stop */
- if (see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x))
+ /* This corner is seen to be enclosed; we cut the corner. */
+ if (find_cut)
{
- return TRUE;
+ find_current = option2;
+ find_prevdir = option2;
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
}
- /* Failure */
- return FALSE;
+ /* This corner is seen to be enclosed, and we */
+ /* deliberately go the long way. */
+ find_current = option;
+ find_prevdir = option2;
+ return see_wall(creature_ptr, find_current, creature_ptr->y, creature_ptr->x);
}
*/
static DIRECTION travel_test(player_type *creature_ptr, DIRECTION prev_dir)
{
- DIRECTION new_dir = 0;
- int i, max;
- const grid_type *g_ptr;
- int cost;
-
/* Cannot travel when blind */
if (creature_ptr->blind || no_lite(creature_ptr))
{
msg_print(_("目が見えない！", "You cannot see!"));
- return (0);
+ return 0;
}
/* break run when leaving trap detected region */
if (disturb_trap_detect)
{
/* Break Run */
- return (0);
+ return 0;
}
}
}
/* Range of newly adjacent grids */
- max = (prev_dir & 0x01) + 1;
+ int max = (prev_dir & 0x01) + 1;
/* Look at every newly adjacent square. */
- for (i = -max; i <= max; i++)
+ const grid_type *g_ptr;
+ for (int i = -max; i <= max; i++)
{
/* New direction */
DIRECTION dir = cycle[chome[prev_dir] + i];
POSITION row = creature_ptr->y + ddy[dir];
POSITION col = creature_ptr->x + ddx[dir];
- /* Access grid */
g_ptr = &floor_ptr->grid_array[row][col];
/* Visible monsters abort running */
monster_type *m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
/* Visible monster */
- if (m_ptr->ml) return (0);
+ if (m_ptr->ml) return 0;
}
}
/* Travel cost of current grid */
- cost = travel.cost[creature_ptr->y][creature_ptr->x];
+ int cost = travel.cost[creature_ptr->y][creature_ptr->x];
/* Determine travel direction */
- for (i = 0; i < 8; ++ i) {
+ DIRECTION new_dir = 0;
+ for (int i = 0; i < 8; ++ i)
+ {
int dir_cost = travel.cost[creature_ptr->y+ddy_ddd[i]][creature_ptr->x+ddx_ddd[i]];
if (dir_cost < cost)
}
}
- if (!new_dir) return (0);
+ if (!new_dir) return 0;
/* Access newly move grid */
g_ptr = &floor_ptr->grid_array[creature_ptr->y+ddy[new_dir]][creature_ptr->x+ddx[new_dir]];
/* Close door abort traveling */
- if (!easy_open && is_closed_door(g_ptr->feat)) return (0);
+ if (!easy_open && is_closed_door(g_ptr->feat)) return 0;
/* Visible and unignorable trap abort tarveling */
- if (!g_ptr->mimic && !trap_can_be_ignored(creature_ptr, g_ptr->feat)) return (0);
+ if (!g_ptr->mimic && !trap_can_be_ignored(creature_ptr, g_ptr->feat)) return 0;
/* Move new grid */
- return (new_dir);
+ return new_dir;
}
/*!
* @brief トラベル機能の実装 /
* Travel command
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @return なし
*/
void travel_step(player_type *creature_ptr)
msg_print(_("道筋が見つかりません！", "No route is found!"));
travel.y = travel.x = 0;
}
+
disturb(creature_ptr, FALSE, TRUE);
return;
}
travel.y = travel.x = 0;
}
else if (travel.run > 0)
+ {
travel.run--;
+ }
/* Travel Delay */
Term_xtra(TERM_XTRA_DELAY, delay_factor);
/*!
* @brief トラベル処理の記憶配列を初期化する Hack: forget the "flow" information
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @return なし
*/
void forget_travel_flow(floor_type *floor_ptr)
{
- POSITION x, y;
/* Check the entire dungeon / Forget the old data */
- for (y = 0; y < floor_ptr->height; y++)
+ for (POSITION y = 0; y < floor_ptr->height; y++)
{
- for (x = 0; x < floor_ptr->width; x++)
+ for (POSITION x = 0; x < floor_ptr->width; x++)
{
-
travel.cost[y][x] = MAX_SHORT;
}
}
+
travel.y = travel.x = 0;
}
/*!
* @brief トラベル処理中に地形に応じた移動コスト基準を返す
+ * @param creature_ptr プレーヤーへの参照ポインタ
* @param y 該当地点のY座標
* @param x 該当地点のX座標
* @return コスト値
*/
static int travel_flow_cost(player_type *creature_ptr, POSITION y, POSITION x)
{
- feature_type *f_ptr = &f_info[creature_ptr->current_floor_ptr->grid_array[y][x].feat];
- int cost = 1;
-
/* Avoid obstacles (ex. trees) */
+ int cost = 1;
+ feature_type *f_ptr = &f_info[creature_ptr->current_floor_ptr->grid_array[y][x].feat];
if (have_flag(f_ptr->flags, FF_AVOID_RUN)) cost += 1;
/* Water */
*/
static void travel_flow_aux(player_type *creature_ptr, POSITION y, POSITION x, int n, bool wall)
{
+ /* Ignore out of bounds */
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
grid_type *g_ptr = &floor_ptr->grid_array[y][x];
feature_type *f_ptr = &f_info[g_ptr->feat];
- int old_head = flow_head;
- int add_cost = 1;
- int base_cost = (n % TRAVEL_UNABLE);
- int from_wall = (n / TRAVEL_UNABLE);
- int cost;
-
- /* Ignore out of bounds */
if (!in_bounds(floor_ptr, y, x)) return;
/* Ignore unknown grid except in wilderness */
if (floor_ptr->dun_level > 0 && !(g_ptr->info & CAVE_KNOWN)) return;
/* Ignore "walls" and "rubble" (include "secret doors") */
+ int add_cost = 1;
+ int from_wall = (n / TRAVEL_UNABLE);
if (have_flag(f_ptr->flags, FF_WALL) ||
have_flag(f_ptr->flags, FF_CAN_DIG) ||
(have_flag(f_ptr->flags, FF_DOOR) && floor_ptr->grid_array[y][x].mimic) ||
add_cost = travel_flow_cost(creature_ptr, y, x);
}
- cost = base_cost + add_cost;
+ int base_cost = (n % TRAVEL_UNABLE);
+ int cost = base_cost + add_cost;
/* Ignore lower cost entries */
if (travel.cost[y][x] <= cost) return;
travel.cost[y][x] = cost;
/* Enqueue that entry */
+ int old_head = flow_head;
temp2_y[flow_head] = y;
temp2_x[flow_head] = x;
*/
static void travel_flow(player_type *creature_ptr, POSITION ty, POSITION tx)
{
- POSITION x, y;
- DIRECTION d;
- bool wall = FALSE;
- feature_type *f_ptr = &f_info[creature_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x].feat];
-
- /* Reset the "queue" */
flow_head = flow_tail = 0;
/* is player in the wall? */
+ bool wall = FALSE;
+ feature_type *f_ptr = &f_info[creature_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x].feat];
if (!have_flag(f_ptr->flags, FF_MOVE)) wall = TRUE;
/* Start at the target grid */
travel_flow_aux(creature_ptr, ty, tx, 0, wall);
/* Now process the queue */
+ POSITION x, y;
while (flow_head != flow_tail)
{
/* Extract the next entry */
/* Forget that entry */
if (++flow_tail == MAX_SHORT) flow_tail = 0;
- /* Ignore too far entries */
- //if (distance(ty, tx, y, x) > 100) continue;
-
/* Add the "children" */
- for (d = 0; d < 8; d++)
+ for (DIRECTION d = 0; d < 8; d++)
{
/* Add that child if "legal" */
travel_flow_aux(creature_ptr, y + ddy_ddd[d], x + ddx_ddd[d], travel.cost[y][x], wall);
}
}
- /* Forget the flow info */
flow_head = flow_tail = 0;
}
void do_cmd_travel(player_type *creature_ptr)
{
POSITION x, y;
- int i;
- POSITION dx, dy, sx, sy;
- feature_type *f_ptr;
-
if (travel.x != 0 && travel.y != 0 &&
get_check(_("トラベルを継続しますか？", "Do you continue to travel?")))
{
}
floor_type *floor_ptr = creature_ptr->current_floor_ptr;
+ feature_type *f_ptr;
f_ptr = &f_info[floor_ptr->grid_array[y][x].feat];
if ((floor_ptr->grid_array[y][x].info & CAVE_MARK) &&
travel.dir = 0;
/* Decides first direction */
- dx = abs(creature_ptr->x - x);
- dy = abs(creature_ptr->y - y);
- sx = ((x == creature_ptr->x) || (dx < dy)) ? 0 : ((x > creature_ptr->x) ? 1 : -1);
- sy = ((y == creature_ptr->y) || (dy < dx)) ? 0 : ((y > creature_ptr->y) ? 1 : -1);
+ POSITION dx = abs(creature_ptr->x - x);
+ POSITION dy = abs(creature_ptr->y - y);
+ POSITION sx = ((x == creature_ptr->x) || (dx < dy)) ? 0 : ((x > creature_ptr->x) ? 1 : -1);
+ POSITION sy = ((y == creature_ptr->y) || (dy < dx)) ? 0 : ((y > creature_ptr->y) ? 1 : -1);
- for (i = 1; i <= 9; i++)
+ for (int i = 1; i <= 9; i++)
{
if ((sx == ddx[i]) && (sy == ddy[i])) travel.dir = i;
}
stop_travel = stop_travel;
#endif
- /* Cancel auto-commands */
- /* command_new = 0; */
-
/* Cancel repeated commands */
if (command_rep)
{
creature_ptr->running = 0;
/* Check for new panel if appropriate */
- if (center_player && !center_running) verify_panel();
+ if (center_player && !center_running) verify_panel(creature_ptr);
/* Calculate torch radius */
creature_ptr->update |= (PU_TORCH);
travel.run = 0;
/* Check for new panel if appropriate */
- if (center_player && !center_running) verify_panel();
+ if (center_player && !center_running) verify_panel(creature_ptr);
/* Calculate torch radius */
creature_ptr->update |= (PU_TORCH);
}
#endif
- /* Flush the input if requested */
if (flush_disturb) flush();
}
OSDN Git Service
