bool deepright = false;
bool shortright = false;
bool shortleft = false;
- player_ptr->run_py = player_ptr->y;
- player_ptr->run_px = player_ptr->x;
- int row = player_ptr->y + ddy[dir];
- int col = player_ptr->x + ddx[dir];
- ignore_avoid_run = cave_has_flag_bold(player_ptr->current_floor_ptr, row, col, TerrainCharacteristics::AVOID_RUN);
+ const auto pos = player_ptr->get_position();
+ player_ptr->run_py = pos.y;
+ player_ptr->run_px = pos.x;
+ const auto pos_neighbor = player_ptr->get_neighbor(dir);
+ ignore_avoid_run = cave_has_flag_bold(player_ptr->current_floor_ptr, pos_neighbor.y, pos_neighbor.x, TerrainCharacteristics::AVOID_RUN);
int i = chome[dir];
- if (see_wall(player_ptr, cycle[i + 1], player_ptr->y, player_ptr->x)) {
+ if (see_wall(player_ptr, cycle[i + 1], pos.y, pos.x)) {
find_breakleft = true;
shortleft = true;
- } else if (see_wall(player_ptr, cycle[i + 1], row, col)) {
+ } else if (see_wall(player_ptr, cycle[i + 1], pos_neighbor.y, pos_neighbor.x)) {
find_breakleft = true;
deepleft = true;
}
- if (see_wall(player_ptr, cycle[i - 1], player_ptr->y, player_ptr->x)) {
+ if (see_wall(player_ptr, cycle[i - 1], pos.y, pos.x)) {
find_breakright = true;
shortright = true;
- } else if (see_wall(player_ptr, cycle[i - 1], row, col)) {
+ } else if (see_wall(player_ptr, cycle[i - 1], pos_neighbor.y, pos_neighbor.x)) {
find_breakright = true;
deepright = true;
}
return;
}
- if (!see_wall(player_ptr, cycle[i], row, col)) {
+ if (!see_wall(player_ptr, cycle[i], pos_neighbor.y, pos_neighbor.x)) {
return;
}
auto option2 = 0;
for (auto i = -max; i <= max; i++) {
int new_dir = cycle[chome[prev_dir] + i];
- const Pos2D pos(player_ptr->y + ddy[new_dir], player_ptr->x + ddx[new_dir]);
+ const auto pos = player_ptr->get_neighbor(new_dir);
const auto &grid = floor.get_grid(pos);
if (grid.has_monster()) {
const auto &monster = floor.m_list[grid.m_idx];
return see_wall(player_ptr, find_current, player_ptr->y, player_ptr->x);
}
- int row = player_ptr->y + ddy[option];
- int col = player_ptr->x + ddx[option];
- if (!see_wall(player_ptr, option, row, col) || !see_wall(player_ptr, check_dir, row, col)) {
- if (see_nothing(player_ptr, option, row, col) && see_nothing(player_ptr, option2, row, col)) {
+ const auto pos = player_ptr->get_neighbor(option);
+ if (!see_wall(player_ptr, option, pos.y, pos.x) || !see_wall(player_ptr, check_dir, pos.y, pos.x)) {
+ if (see_nothing(player_ptr, option, pos.y, pos.x) && see_nothing(player_ptr, option2, pos.y, pos.x)) {
find_current = option;
find_prevdir = option2;
return see_wall(player_ptr, find_current, player_ptr->y, player_ptr->x);
}
int max = (prev_dir & 0x01) + 1;
- const Grid *g_ptr;
for (int i = -max; i <= max; i++) {
DIRECTION dir = cycle[chome[prev_dir] + i];
- POSITION row = player_ptr->y + ddy[dir];
- POSITION col = player_ptr->x + ddx[dir];
- g_ptr = &floor_ptr->grid_array[row][col];
- if (g_ptr->has_monster()) {
- auto *m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
- if (m_ptr->ml) {
+ const auto pos = player_ptr->get_neighbor(dir);
+ const auto &grid = floor_ptr->get_grid(pos);
+ if (grid.has_monster()) {
+ const auto &monster = floor_ptr->m_list[grid.m_idx];
+ if (monster.ml) {
return 0;
}
}
return 0;
}
- g_ptr = &floor_ptr->grid_array[player_ptr->y + ddy[new_dir]][player_ptr->x + ddx[new_dir]];
- if (!easy_open && is_closed_door(player_ptr, g_ptr->feat)) {
+ const auto pos_new = player_ptr->get_neighbor(new_dir);
+ const auto &grid = floor_ptr->get_grid(pos_new);
+ if (!easy_open && is_closed_door(player_ptr, grid.feat)) {
return 0;
}
- if (!g_ptr->mimic && !trap_can_be_ignored(player_ptr, g_ptr->feat)) {
+ if (!grid.mimic && !trap_can_be_ignored(player_ptr, grid.feat)) {
return 0;
}
int dir;
if (get_rep_dir(player_ptr, &dir, true)) {
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
const auto o_idx = chest_check(player_ptr->current_floor_ptr, pos, false);
if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::OPEN) && !o_idx) {
auto more = false;
int dir;
if (get_rep_dir(player_ptr, &dir)) {
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::CLOSE)) {
msg_print(_("そこには閉じるものが見当たらない。", "You see nothing there to close."));
int dir;
auto more = false;
if (get_rep_dir(player_ptr, &dir, true)) {
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
const auto feat = grid.get_feat_mimic();
const auto o_idx = chest_check(player_ptr->current_floor_ptr, pos, true);
int dir;
if (get_rep_dir(player_ptr, &dir)) {
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const Grid &grid = player_ptr->current_floor_ptr->get_grid(pos);
if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::BASH)) {
msg_print(_("そこには体当たりするものが見当たらない。", "You see nothing there to bash."));
return;
}
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
const auto &terrain_mimic = grid.get_terrain_mimic();
INVENTORY_IDX i_idx;
return false;
}
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
const auto &terrain = grid.get_terrain_mimic();
PlayerEnergy(player_ptr).set_player_turn_energy(100);
}
auto more = false;
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
const auto &terrain_mimic = grid.get_terrain_mimic();
if (terrain_mimic.flags.has(TerrainCharacteristics::DOOR)) {
const auto r_idx = get_mon_num(player_ptr, 0, level, PM_NONE);
msg_print(nullptr);
if (MonsterRace(r_idx).is_valid() && one_in_(2)) {
- POSITION y, x;
- y = player_ptr->y + ddy[player_ptr->fishing_dir];
- x = player_ptr->x + ddx[player_ptr->fishing_dir];
- if (place_specific_monster(player_ptr, 0, y, x, r_idx, PM_NO_KAGE)) {
- const auto m_name = monster_desc(player_ptr, &floor_ptr->m_list[floor_ptr->grid_array[y][x].m_idx], 0);
+ const auto pos = player_ptr->get_neighbor(player_ptr->fishing_dir);
+ if (place_specific_monster(player_ptr, 0, pos.y, pos.x, r_idx, PM_NO_KAGE)) {
+ const auto m_name = monster_desc(player_ptr, &floor_ptr->m_list[floor_ptr->get_grid(pos).m_idx], 0);
msg_print(_(format("%sが釣れた!", m_name.data()), "You have a good catch!"));
success = true;
}
return false;
}
- const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+ const auto pos = player_ptr->get_neighbor(dir);
const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::CAN_DIG)) {
msg_print(_("そこには岩石がない。", "You need a pile of rubble."));
return false;
}
- POSITION y = player_ptr->y + ddy[dir];
- POSITION x = player_ptr->x + ddx[dir];
+ auto pos = player_ptr->get_neighbor(dir);
PLAYER_LEVEL plev = player_ptr->lev;
int dam = damroll(8 + ((plev - 5) / 4) + boost / 12, 8);
fire_beam(player_ptr, AttributeType::MISSILE, dir, dam);
- if (!player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+ auto &floor = *player_ptr->current_floor_ptr;
+ const auto &grid = floor.get_grid(pos);
+ if (!grid.has_monster()) {
return true;
}
- POSITION ty = y, tx = x;
- POSITION oy = y, ox = x;
- MONSTER_IDX m_idx = player_ptr->current_floor_ptr->grid_array[y][x].m_idx;
- auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
- auto *r_ptr = &m_ptr->get_monrace();
- const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+ auto pos_target = pos;
+ const auto pos_origin = pos;
+ const auto m_idx = grid.m_idx;
+ auto &monster = floor.m_list[m_idx];
+ const auto &monrace = monster.get_monrace();
+ const auto m_name = monster_desc(player_ptr, &monster, 0);
- if (randint1(r_ptr->level * 3 / 2) > randint0(dam / 2) + dam / 2) {
+ if (randint1(monrace.level * 3 / 2) > randint0(dam / 2) + dam / 2) {
msg_format(_("%sは飛ばされなかった。", "%s^ was not blown away."), m_name.data());
return true;
}
for (int i = 0; i < 5; i++) {
- y += ddy[dir];
- x += ddx[dir];
- if (is_cave_empty_bold(player_ptr, y, x)) {
- ty = y;
- tx = x;
+ pos = Pos2D(pos.y + ddy[dir], pos.x + ddx[dir]);
+ if (is_cave_empty_bold(player_ptr, pos.y, pos.x)) {
+ pos_target = pos;
} else {
break;
}
}
- bool is_shock_successful = ty != oy;
- is_shock_successful |= tx != ox;
- if (is_shock_successful) {
+ if (pos_target == pos_origin) {
return true;
}
msg_format(_("%sを吹き飛ばした!", "You blow %s away!"), m_name.data());
- player_ptr->current_floor_ptr->grid_array[oy][ox].m_idx = 0;
- player_ptr->current_floor_ptr->grid_array[ty][tx].m_idx = m_idx;
- m_ptr->fy = ty;
- m_ptr->fx = tx;
+ floor.get_grid(pos_origin).m_idx = 0;
+ floor.get_grid(pos_target).m_idx = m_idx;
+ monster.fy = pos_target.y;
+ monster.fx = pos_target.x;
update_monster(player_ptr, m_idx, true);
- lite_spot(player_ptr, oy, ox);
- lite_spot(player_ptr, ty, tx);
+ lite_spot(player_ptr, pos_origin.y, pos_origin.x);
+ lite_spot(player_ptr, pos_target.y, pos_target.x);
- if (r_ptr->brightness_flags.has_any_of(ld_mask)) {
+ if (monrace.brightness_flags.has_any_of(ld_mask)) {
RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_LITE);
}
if (!get_rep_dir(player_ptr, &dir)) {
return false;
}
- POSITION y = player_ptr->y + ddy[dir];
- POSITION x = player_ptr->x + ddx[dir];
- if (!player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+
+ const auto pos = player_ptr->get_neighbor(dir);
+ const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+ const auto has_monster = grid.has_monster();
+ if (!has_monster) {
msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));
msg_print(nullptr);
return true;
msg_print(_("オラオラオラオラオラオラオラオラオラオラオラオラ!!!", "Oraoraoraoraoraoraoraoraoraoraoraoraoraoraoraoraora!!!!"));
}
- do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
- if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+ do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
+ if (has_monster) {
handle_stuff(player_ptr);
- do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
+ do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
}
player_ptr->energy_need += ENERGY_NEED();
if (grid.has_monster()) {
Pos2D target(pos.y, pos.x);
Pos2D origin(pos.y, pos.x);
- auto m_idx = grid.m_idx;
- auto *m_ptr = &floor.m_list[m_idx];
- const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+ const auto m_idx = grid.m_idx;
+ auto &monster = floor.m_list[m_idx];
+ const auto m_name = monster_desc(player_ptr, &monster, 0);
Pos2D neighbor(pos.y, pos.x);
for (auto i = 0; i < 5; i++) {
neighbor.y += ddy[dir];
msg_format(_("%sを吹き飛ばした!", "You blow %s away!"), m_name.data());
floor.get_grid(origin).m_idx = 0;
floor.get_grid(target).m_idx = m_idx;
- m_ptr->fy = target.y;
- m_ptr->fx = target.x;
+ monster.fy = target.y;
+ monster.fx = target.x;
update_monster(player_ptr, m_idx, true);
lite_spot(player_ptr, origin.y, origin.x);
lite_spot(player_ptr, target.y, target.x);
- if (m_ptr->get_monrace().brightness_flags.has_any_of(ld_mask)) {
+ if (monster.get_monrace().brightness_flags.has_any_of(ld_mask)) {
RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_LITE);
}
}
}
if (cast) {
- POSITION x, y;
-
if (!get_rep_dir(player_ptr, &dir)) {
return std::nullopt;
}
- y = player_ptr->y + ddy[dir];
- x = player_ptr->x + ddx[dir];
-
- if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
- do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
- if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+ const auto pos = player_ptr->get_neighbor(dir);
+ const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+ if (grid.has_monster()) {
+ do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
+ if (grid.has_monster()) {
handle_stuff(player_ptr);
- do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
+ do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
}
} else {
msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));
static bool release_monster(PlayerType *player_ptr, ItemEntity &item, DIRECTION dir)
{
- auto r_idx = i2enum<MonsterRaceId>(item.pval);
- if (!monster_can_enter(player_ptr, player_ptr->y + ddy[dir], player_ptr->x + ddx[dir], &monraces_info[r_idx], 0)) {
+ const auto r_idx = i2enum<MonsterRaceId>(item.pval);
+ const auto pos = player_ptr->get_neighbor(dir);
+ if (!monster_can_enter(player_ptr, pos.y, pos.x, &monraces_info[r_idx], 0)) {
return false;
}
- if (!place_specific_monster(player_ptr, 0, player_ptr->y + ddy[dir], player_ptr->x + ddx[dir], r_idx, PM_FORCE_PET | PM_NO_KAGE)) {
+ if (!place_specific_monster(player_ptr, 0, pos.y, pos.x, r_idx, PM_FORCE_PET | PM_NO_KAGE)) {
return false;
}
void SpellsMirrorMaster::seeker_ray(int dir, int dam)
{
- POSITION tx = this->player_ptr->x + ddx[dir];
- POSITION ty = this->player_ptr->y + ddy[dir];
- if ((dir == 5) && target_okay(this->player_ptr)) {
- tx = target_col;
- ty = target_row;
- }
-
- project_seeker_ray(tx, ty, dam);
+ const auto pos = ((dir == 5) && target_okay(this->player_ptr)) ? Pos2D(target_row, target_col) : this->player_ptr->get_neighbor(dir);
+ project_seeker_ray(pos.x, pos.y, dam);
}
void SpellsMirrorMaster::super_ray(int dir, int dam)
{
- POSITION tx = this->player_ptr->x + ddx[dir];
- POSITION ty = this->player_ptr->y + ddy[dir];
- if ((dir == 5) && target_okay(this->player_ptr)) {
- tx = target_col;
- ty = target_row;
- }
-
- project_super_ray(tx, ty, dam);
+ const auto pos = ((dir == 5) && target_okay(this->player_ptr)) ? Pos2D(target_row, target_col) : this->player_ptr->get_neighbor(dir);
+ project_super_ray(pos.x, pos.y, dam);
}
/*!
- * @brief 配置した鏡リストの次を取得する /
- * Get another mirror. for SEEKER
- * @param next_y 次の鏡のy座標を返す参照ポインタ
- * @param next_x 次の鏡のx座標を返す参照ポインタ
- * @param cury 現在の鏡のy座標
- * @param curx 現在の鏡のx座標
+ * @brief 配置した鏡リストの次を取得する
+ * @param pos_current 現在の鏡位置
+ * @return 次の鏡位置
*/
-void SpellsMirrorMaster::next_mirror(int *next_y, int *next_x, int cury, int curx)
+Pos2D SpellsMirrorMaster::get_next_mirror_position(const Pos2D &pos_current) const
{
- POSITION mirror_x[10], mirror_y[10]; /* 鏡はもっと少ない */
- int mirror_num = 0; /* 鏡の数 */
-
- auto *floor_ptr = this->player_ptr->current_floor_ptr;
-
- for (POSITION x = 0; x < floor_ptr->width; x++) {
- for (POSITION y = 0; y < floor_ptr->height; y++) {
- if (floor_ptr->grid_array[y][x].is_mirror()) {
- mirror_y[mirror_num] = y;
- mirror_x[mirror_num] = x;
- mirror_num++;
+ std::vector<Pos2D> mirror_positions;
+ const auto &floor = *this->player_ptr->current_floor_ptr;
+ for (auto x = 0; x < floor.width; x++) {
+ for (auto y = 0; y < floor.height; y++) {
+ const Pos2D pos(y, x);
+ if (floor.get_grid(pos).is_mirror()) {
+ mirror_positions.push_back(pos);
}
}
}
- if (mirror_num) {
- int num = randint0(mirror_num);
- *next_y = mirror_y[num];
- *next_x = mirror_x[num];
- return;
+ if (!mirror_positions.empty()) {
+ return rand_choice(mirror_positions);
}
- do {
- *next_y = cury + randint0(5) - 2;
- *next_x = curx + randint0(5) - 2;
- } while ((*next_y == cury) && (*next_x == curx));
+ while (true) {
+ const Pos2D next_mirror(pos_current.y + randint0(5) - 2, pos_current.x + randint0(5) - 2);
+ if (next_mirror != pos_current) {
+ return next_mirror;
+ }
+ }
}
void SpellsMirrorMaster::project_seeker_ray(int target_x, int target_y, int dam)
monster_target_y = y;
monster_target_x = x;
this->remove_mirror(y, x);
- this->next_mirror(&y2, &x2, y, x);
+ const auto pos = this->get_next_mirror_position({ y, x });
+ y2 = pos.y;
+ x2 = pos.x;
y1 = y;
x1 = x;
}
#pragma once
+#include "util/point-2d.h"
+
class PlayerType;
struct ProjectResult;
class SpellsMirrorMaster {
private:
PlayerType *player_ptr;
- void next_mirror(int *next_y, int *next_x, int cury, int curx);
+ Pos2D get_next_mirror_position(const Pos2D &pos_current) const;
void project_seeker_ray(int target_x, int target_y, int dam);
void project_super_ray(int target_x, int target_y, int dam);
};
bool project_hook(PlayerType *player_ptr, AttributeType typ, DIRECTION dir, int dam, BIT_FLAGS flg)
{
flg |= (PROJECT_THRU);
- POSITION tx = player_ptr->x + ddx[dir];
- POSITION ty = player_ptr->y + ddy[dir];
- if ((dir == 5) && target_okay(player_ptr)) {
- tx = target_col;
- ty = target_row;
- }
-
- return project(player_ptr, 0, 0, ty, tx, dam, typ, flg).notice;
+ const auto pos = ((dir == 5) && target_okay(player_ptr)) ? Pos2D(target_row, target_col) : player_ptr->get_neighbor(dir);
+ return project(player_ptr, 0, 0, pos.y, pos.x, dam, typ, flg).notice;
}
*/
bool teleport_swap(PlayerType *player_ptr, DIRECTION dir)
{
- POSITION tx, ty;
- if ((dir == 5) && target_okay(player_ptr)) {
- tx = target_col;
- ty = target_row;
- } else {
- tx = player_ptr->x + ddx[dir];
- ty = player_ptr->y + ddy[dir];
- }
-
+ const auto pos = ((dir == 5) && target_okay(player_ptr)) ? Pos2D(target_row, target_col) : player_ptr->get_neighbor(dir);
if (player_ptr->anti_tele) {
msg_print(_("不思議な力がテレポートを防いだ!", "A mysterious force prevents you from teleporting!"));
return false;
}
- Grid *g_ptr;
- g_ptr = &player_ptr->current_floor_ptr->grid_array[ty][tx];
- if (!g_ptr->has_monster() || (g_ptr->m_idx == player_ptr->riding)) {
+ const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+ if (!grid.has_monster() || (grid.m_idx == player_ptr->riding)) {
msg_print(_("それとは場所を交換できません。", "You can't trade places with that!"));
return false;
}
- if ((g_ptr->is_icky()) || (distance(ty, tx, player_ptr->y, player_ptr->x) > player_ptr->lev * 3 / 2 + 10)) {
+ if ((grid.is_icky()) || (distance(pos.y, pos.x, player_ptr->y, player_ptr->x) > player_ptr->lev * 3 / 2 + 10)) {
msg_print(_("失敗した。", "Failed to swap."));
return false;
}
- MonsterEntity *m_ptr;
- MonsterRaceInfo *r_ptr;
- m_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
- r_ptr = &m_ptr->get_monrace();
+ const auto &monster = player_ptr->current_floor_ptr->m_list[grid.m_idx];
+ auto &monrace = monster.get_monrace();
- (void)set_monster_csleep(player_ptr, g_ptr->m_idx, 0);
+ (void)set_monster_csleep(player_ptr, grid.m_idx, 0);
- if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+ if (monrace.resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
msg_print(_("テレポートを邪魔された!", "Your teleportation is blocked!"));
- if (is_original_ap_and_seen(player_ptr, m_ptr)) {
- r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
+ if (is_original_ap_and_seen(player_ptr, &monster)) {
+ monrace.r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
}
return false;
}
sound(SOUND_TELEPORT);
- (void)move_player_effect(player_ptr, ty, tx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
+ (void)move_player_effect(player_ptr, pos.y, pos.x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
return true;
}