}
}
- monster_type *riding_m_ptr = &floor_ptr->m_list[player_ptr->riding];
+ MonsterEntity *riding_m_ptr = &floor_ptr->m_list[player_ptr->riding];
PlayerEnergy energy(player_ptr);
if (can_move && player_ptr->riding) {
const auto *riding_r_ptr = &monraces_info[riding_m_ptr->r_idx];
return true;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
monster_race *r_ptr;
r_ptr = &monraces_info[m_ptr->r_idx];
/*!
* @brief AvaterChangerコンストラクタ
*/
-AvatarChanger::AvatarChanger(PlayerType *player_ptr, monster_type *m_ptr)
+AvatarChanger::AvatarChanger(PlayerType *player_ptr, MonsterEntity *m_ptr)
: player_ptr(player_ptr)
, m_ptr(m_ptr)
{
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
class AvatarChanger {
public:
- AvatarChanger(PlayerType *player_ptr, monster_type *m_ptr);
+ AvatarChanger(PlayerType *player_ptr, MonsterEntity *m_ptr);
virtual ~AvatarChanger() = default;
void change_virtue();
private:
PlayerType *player_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
void change_virtue_non_beginner();
void change_virtue_unique();
void change_virtue_good_evil();
static bool exe_blue_teleport_back(PlayerType *player_ptr, GAME_TEXT *m_name)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
auto *floor_ptr = player_ptr->current_floor_ptr;
if ((floor_ptr->grid_array[target_row][target_col].m_idx == 0) || !player_has_los_bold(player_ptr, target_row, target_col) || !projectable(player_ptr, player_ptr->y, player_ptr->x, target_row, target_col)) {
case MonsterAbilityType::SPECIAL:
break;
case MonsterAbilityType::TELE_TO: {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
GAME_TEXT m_name[MAX_NLEN];
*/
void do_cmd_pet_dismiss(PlayerType *player_ptr)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
bool all_pets = false;
int Dismissed = 0;
POSITION x, y;
DIRECTION dir = 0;
grid_type *g_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
if (!get_direction(player_ptr, &dir, false, false)) {
return false;
*/
static void do_name_pet(PlayerType *player_ptr)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
char out_val[20];
GAME_TEXT m_name[MAX_NLEN];
bool old_name = false;
bool flag, redraw;
char choice;
int pet_ctr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
auto command_idx = 0;
int menu_line = use_menu ? 1 : 0;
auto num = 0;
* @return スレイ倍率をかけたダメージ量
*/
static MULTIPLY calc_shot_damage_with_slay(
- PlayerType *player_ptr, ItemEntity *bow_ptr, ItemEntity *arrow_ptr, int tdam, monster_type *monster_ptr, SPELL_IDX snipe_type)
+ PlayerType *player_ptr, ItemEntity *bow_ptr, ItemEntity *arrow_ptr, int tdam, MonsterEntity *monster_ptr, SPELL_IDX snipe_type)
{
MULTIPLY mult = 10;
* @return 命中と判定された場合TRUEを返す
* @note Always miss 5%, always hit 5%, otherwise random.
*/
-bool test_hit_fire(PlayerType *player_ptr, int chance, monster_type *m_ptr, int vis, char *o_name)
+bool test_hit_fire(PlayerType *player_ptr, int chance, MonsterEntity *m_ptr, int vis, char *o_name)
{
int k;
ARMOUR_CLASS ac;
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class PlayerType;
-bool test_hit_fire(PlayerType *player_ptr, int chance, monster_type *m_ptr, int vis, char *o_name);
+bool test_hit_fire(PlayerType *player_ptr, int chance, MonsterEntity *m_ptr, int vis, char *o_name);
int critical_shot(PlayerType *player_ptr, WEIGHT weight, int plus_ammo, int plus_bow, int dam);
ENERGY bow_energy(OBJECT_SUBTYPE_VALUE sval);
int bow_tmul(OBJECT_SUBTYPE_VALUE sval);
* @param m_ptr 目標モンスターの構造体参照ポインタ
* @return スレイング加味後の倍率(/10倍)
*/
-MULTIPLY mult_slaying(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr)
+MULTIPLY mult_slaying(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, MonsterEntity *m_ptr)
{
static const struct slay_table_t {
tr_type slay_flag;
* @param m_ptr 目標モンスターの構造体参照ポインタ
* @return スレイング加味後の倍率(/10倍)
*/
-MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr)
+MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, MonsterEntity *m_ptr)
{
static const struct brand_table_t {
tr_type brand_flag;
* Note that most brands and slays are x3, except Slay Animal (x2),\n
* Slay Evil (x2), and Kill dragon (x5).\n
*/
-int calc_attack_damage_with_slay(PlayerType *player_ptr, ItemEntity *o_ptr, int tdam, monster_type *m_ptr, combat_options mode, bool thrown)
+int calc_attack_damage_with_slay(PlayerType *player_ptr, ItemEntity *o_ptr, int tdam, MonsterEntity *m_ptr, combat_options mode, bool thrown)
{
auto flgs = object_flags(o_ptr);
torch_flags(o_ptr, flgs); /* torches has secret flags */
#include "effect/attribute-types.h"
#include "object-enchant/tr-flags.h"
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class PlayerType;
-MULTIPLY mult_slaying(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
-MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
-int calc_attack_damage_with_slay(PlayerType *player_ptr, ItemEntity *o_ptr, int tdam, monster_type *m_ptr, combat_options mode, bool thrown);
+MULTIPLY mult_slaying(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, MonsterEntity *m_ptr);
+MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, MonsterEntity *m_ptr);
+int calc_attack_damage_with_slay(PlayerType *player_ptr, ItemEntity *o_ptr, int tdam, MonsterEntity *m_ptr, combat_options mode, bool thrown);
AttributeFlags melee_attribute(PlayerType *player_ptr, ItemEntity *o_ptr, combat_options mode);
POSITION y, x;
if (o_ptr->is_held_by_monster()) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &floor_ptr->m_list[o_ptr->held_m_idx];
y = m_ptr->fy;
x = m_ptr->fx;
}
for (MONSTER_IDX m_idx = 1; m_idx < player_ptr->current_floor_ptr->m_max; m_idx++) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
if (!m_ptr->is_valid()) {
#include "view/display-messages.h"
#include <algorithm>
-QuestCompletionChecker::QuestCompletionChecker(PlayerType *player_ptr, monster_type *m_ptr)
+QuestCompletionChecker::QuestCompletionChecker(PlayerType *player_ptr, MonsterEntity *m_ptr)
: player_ptr(player_ptr)
, m_ptr(m_ptr)
{
this->make_reward(pos);
}
-static bool check_quest_completion(PlayerType *player_ptr, const quest_type &q_ref, monster_type *m_ptr)
+static bool check_quest_completion(PlayerType *player_ptr, const quest_type &q_ref, MonsterEntity *m_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
if (q_ref.status != QuestStatusType::TAKEN) {
#include "util/point-2d.h"
#include <tuple>
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class PlayerType;
struct quest_type;
class QuestCompletionChecker {
public:
- QuestCompletionChecker(PlayerType *player_ptr, monster_type *m_ptr);
+ QuestCompletionChecker(PlayerType *player_ptr, MonsterEntity *m_ptr);
virtual ~QuestCompletionChecker() = default;
void complete();
private:
PlayerType *player_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
QuestId quest_idx;
quest_type *q_ptr = nullptr;
* @param hp 計算対象のHP
* @return 捕まえられる最大HP
*/
-static int calcutate_capturable_hp(PlayerType *player_ptr, monster_type *m_ptr, int hp)
+static int calcutate_capturable_hp(PlayerType *player_ptr, MonsterEntity *m_ptr, int hp)
{
if (m_ptr->is_pet()) {
return hp * 4L;
struct grid_type;
;
-struct monster_type;
+class MonsterEntity;
struct monster_race;
struct effect_monster_type {
grid_type *g_ptr;
- monster_type *m_ptr;
- monster_type *m_caster_ptr;
+ MonsterEntity *m_ptr;
+ MonsterEntity *m_caster_ptr;
monster_race *r_ptr;
char killer[MAX_MONSTER_NAME];
bool seen;
#include "system/angband.h"
#include <optional>
-struct monster_type;
+class MonsterEntity;
class EffectPlayerType {
public:
DEPTH rlev; // モンスターのレベル (但し0のモンスターは1になる).
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
char killer[MAX_MONSTER_NAME];
GAME_TEXT m_name[MAX_NLEN];
int get_damage;
}
}
- std::fill(std::begin(party_mon), std::end(party_mon), monster_type{});
+ std::fill(std::begin(party_mon), std::end(party_mon), MonsterEntity{});
}
/*!
r_ref.cur_num = 0;
}
- std::fill_n(floor_ptr->m_list.begin(), floor_ptr->m_max, monster_type{});
+ std::fill_n(floor_ptr->m_list.begin(), floor_ptr->m_max, MonsterEntity{});
floor_ptr->m_max = 1;
floor_ptr->m_cnt = 0;
for (int i = 0; i < MAX_MTIMED; i++) {
}
}
-static bool check_pet_preservation_conditions(PlayerType *player_ptr, monster_type *m_ptr)
+static bool check_pet_preservation_conditions(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
if (reinit_wilderness) {
return false;
}
while (true) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
POSITION ny = rand_spread(oy, dis);
POSITION nx = rand_spread(ox, dis);
tries++;
FLOOR_IDX max_floor_id; /*!< Number of floor_id used from birth */
FLOOR_IDX new_floor_id; /*!<次のフロアのID / floor_id of the destination */
uint32_t latest_visit_mark; /*!<フロアを渡った回数？(確認中) / Max number of visit_mark */
-monster_type party_mon[MAX_PARTY_MON]; /*!< フロア移動に保存するペットモンスターの配列 */
+MonsterEntity party_mon[MAX_PARTY_MON]; /*!< フロア移動に保存するペットモンスターの配列 */
extern FLOOR_IDX new_floor_id;
extern uint32_t latest_visit_mark;
-extern monster_type party_mon[MAX_PARTY_MON];
+extern MonsterEntity party_mon[MAX_PARTY_MON];
*/
void precalc_cur_num_of_pet(PlayerType *player_ptr)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
int max_num = player_ptr->wild_mode ? 1 : MAX_PARTY_MON;
for (int i = 0; i < max_num; i++) {
m_ptr = &party_mon[i];
* @return 個々のモンスターがプレイヤーが見えたらTRUE
* @todo is_seen() の関数マクロをバラそうとしたがインクルード関係のコンパイルエラーで失敗
*/
-bool is_seen(PlayerType *player_ptr, monster_type *m_ptr)
+bool is_seen(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
bool is_inside_view = !ignore_unview;
is_inside_view |= player_ptr->phase_out;
void mmove2(POSITION *y, POSITION *x, POSITION y1, POSITION x1, POSITION y2, POSITION x2);
bool player_can_see_bold(PlayerType *player_ptr, POSITION y, POSITION x);
-struct monster_type;
-bool is_seen(PlayerType *player_ptr, monster_type *m_ptr);
+class MonsterEntity;
+bool is_seen(PlayerType *player_ptr, MonsterEntity *m_ptr);
/* Let them fight each other */
if (evil_idx && good_idx) {
- monster_type *evil_ptr = &player_ptr->current_floor_ptr->m_list[evil_idx];
- monster_type *good_ptr = &player_ptr->current_floor_ptr->m_list[good_idx];
+ MonsterEntity *evil_ptr = &player_ptr->current_floor_ptr->m_list[evil_idx];
+ MonsterEntity *good_ptr = &player_ptr->current_floor_ptr->m_list[good_idx];
evil_ptr->target_y = good_ptr->fy;
evil_ptr->target_x = good_ptr->fx;
good_ptr->target_y = evil_ptr->fy;
return;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
GAME_TEXT pet_name[MAX_NLEN];
int t_friends = 0;
for (int i = player_ptr->current_floor_ptr->m_max - 1; i >= 1; i--) {
}
auto tmp16s = rd_s16b();
- monster_type dummy_mon;
+ MonsterEntity dummy_mon;
auto monster_loader = MonsterLoaderFactory::create_loader(player_ptr);
for (int i = 0; i < tmp16s; i++) {
monster_loader->rd_monster(&dummy_mon);
#pragma once
-struct monster_type;
+class MonsterEntity;
class PlayerType;
class MonsterLoaderBase {
public:
virtual ~MonsterLoaderBase() = default;
- virtual void rd_monster(monster_type *m_ptr) = 0;
+ virtual void rd_monster(MonsterEntity *m_ptr) = 0;
protected:
MonsterLoaderBase() = default;
enum class MonsterLoaderVersionType;
class PlayerType;
-struct monster_type;
+class MonsterEntity;
class MonsterLoaderBase;
class MonsterLoaderFactory {
public:
* @param player_ptr プレイヤーへの参照ポインタ
* @param m_ptr モンスター保存先ポインタ
*/
-void rd_monster_old(PlayerType *player_ptr, monster_type *m_ptr)
+void rd_monster_old(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
m_ptr->r_idx = i2enum<MonsterRaceId>(rd_s16b());
class ItemEntity;
class PlayerType;
void rd_item_old(ItemEntity *o_ptr);
-void rd_monster_old(PlayerType *player_ptr, monster_type *m_ptr);
+void rd_monster_old(PlayerType *player_ptr, MonsterEntity *m_ptr);
void set_old_lore(monster_race *r_ptr, BIT_FLAGS f4, const MonsterRaceId r_idx);
errr rd_dungeon_old(PlayerType *player_ptr);
/*!
* @brief モンスターを読み込む(v3.0.0 Savefile ver50まで)
*/
-void MonsterLoader50::rd_monster(monster_type *m_ptr_)
+void MonsterLoader50::rd_monster(MonsterEntity *m_ptr_)
{
this->m_ptr = m_ptr_;
if (h_older_than(1, 5, 0, 0)) {
#include "load/monster/monster-loader-base.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
class MonsterLoader50 : public MonsterLoaderBase {
public:
MonsterLoader50(PlayerType *player_ptr);
- void rd_monster(monster_type *m_ptr) override;
+ void rd_monster(MonsterEntity *m_ptr) override;
private:
PlayerType *player_ptr;
- monster_type *m_ptr = nullptr;
+ MonsterEntity *m_ptr = nullptr;
};
scene_monster_info scene_target_monster;
-inline static bool has_shadower_flag(monster_type *m_ptr)
+inline static bool has_shadower_flag(MonsterEntity *m_ptr)
{
return m_ptr->mflag2.has(MonsterConstantFlagType::KAGE);
}
// Melee-post-process-type
struct mam_pp_type {
MONSTER_IDX m_idx;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
bool seen;
GAME_TEXT m_name[160];
int dam;
#include "util/flag-group.h"
struct monster_race;
-struct monster_type;
+class MonsterEntity;
struct melee_spell_type {
MONSTER_IDX m_idx;
POSITION y;
char m_poss[160];
#endif
- monster_type *m_ptr;
- monster_type *t_ptr;
+ MonsterEntity *m_ptr;
+ MonsterEntity *t_ptr;
monster_race *r_ptr;
bool see_m;
bool maneable;
enum class BlowEffectType;
/* monster-attack-monster type*/
-struct monster_type;
+class MonsterEntity;
struct mam_type {
BlowEffectType attribute;
MONSTER_IDX m_idx;
MONSTER_IDX t_idx;
- monster_type *m_ptr;
- monster_type *t_ptr;
+ MonsterEntity *m_ptr;
+ MonsterEntity *t_ptr;
GAME_TEXT m_name[MAX_NLEN];
GAME_TEXT t_name[MAX_NLEN];
int damage;
bool rodeo(PlayerType *player_ptr)
{
GAME_TEXT m_name[MAX_NLEN];
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
int rlev;
bool tmp_mdeath = false;
bool moved = false;
for (const auto &[ny, nx] : path_g) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
if (is_cave_empty_bold(player_ptr, ny, nx) && player_can_enter(player_ptr, floor_ptr->grid_array[ny][nx].feat, 0)) {
ty = ny;
struct samurai_slaying_type {
MULTIPLY mult;
TrFlags flags;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
combat_options mode;
monster_race *r_ptr;
};
static samurai_slaying_type *initialize_samurai_slaying_type(
- samurai_slaying_type *samurai_slaying_ptr, MULTIPLY mult, const TrFlags &flags, monster_type *m_ptr, combat_options mode, monster_race *r_ptr)
+ samurai_slaying_type *samurai_slaying_ptr, MULTIPLY mult, const TrFlags &flags, MonsterEntity *m_ptr, combat_options mode, monster_race *r_ptr)
{
samurai_slaying_ptr->mult = mult;
samurai_slaying_ptr->flags = flags;
* @param mode 剣術のスレイ型ID
* @return スレイの倍率(/10倍)
*/
-MULTIPLY mult_hissatsu(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flags, monster_type *m_ptr, combat_options mode)
+MULTIPLY mult_hissatsu(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flags, MonsterEntity *m_ptr, combat_options mode)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
samurai_slaying_type tmp_slaying;
#include "object-enchant/tr-flags.h"
class MonsterAttackPlayer;
-struct monster_type;
+class MonsterEntity;
struct player_attack_type;
class PlayerType;
-MULTIPLY mult_hissatsu(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr, combat_options mode);
+MULTIPLY mult_hissatsu(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs, MonsterEntity *m_ptr, combat_options mode);
void concentration(PlayerType *player_ptr);
bool choose_samurai_stance(PlayerType *player_ptr);
int calc_attack_quality(PlayerType *player_ptr, player_attack_type *pa_ptr);
* @param m_ptr 目標となるモンスターの構造体参照ポインタ
* @return スレイの倍率(/10倍)
*/
-MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, monster_type *m_ptr, SPELL_IDX snipe_type)
+MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, MonsterEntity *m_ptr, SPELL_IDX snipe_type)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
bool seen = is_seen(player_ptr, m_ptr);
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
void reset_concentration(PlayerType *player_ptr, bool msg);
void display_snipe_list(PlayerType *player_ptr);
-MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, monster_type *m_ptr, SPELL_IDX snipe_type);
+MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, MonsterEntity *m_ptr, SPELL_IDX snipe_type);
void do_cmd_snipe(PlayerType *player_ptr);
void do_cmd_snipe_browse(PlayerType *player_ptr);
int boost_concentration_damage(PlayerType *player_ptr, int tdam);
enum class RaceBlowEffectType;
enum class RaceBlowMethodType;
class PlayerType;
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class MonsterAttackPlayer {
public:
int abbreviate = 0; // 2回目以降の省略表現フラグ.
#endif
short m_idx;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
RaceBlowMethodType method;
RaceBlowEffectType effect;
bool do_silly_attack;
{
auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
auto *r_ptr = &monraces_info[m_ptr->r_idx];
- monster_type *y_ptr;
+ MonsterEntity *y_ptr;
y_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
if (r_ptr->behavior_flags.has(MonsterBehaviorType::NEVER_BLOW)) {
return false;
{
auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
auto *r_ptr = &monraces_info[m_ptr->r_idx];
- monster_type *y_ptr;
+ MonsterEntity *y_ptr;
y_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
if (!turn_flags_ptr->do_move || (g_ptr->m_idx == 0)) {
return false;
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
struct monster_race;
struct monster_death_type {
MONSTER_IDX m_idx;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
bool do_gold;
bool do_item;
* @param plus モンスターIDの増減 (1/2 の確率で+1、1/2の確率で-1)
* @return ペットがモンスターに近づくならばTRUE
*/
-static bool decide_pet_approch_direction(PlayerType *player_ptr, monster_type *m_ptr, monster_type *t_ptr)
+static bool decide_pet_approch_direction(PlayerType *player_ptr, MonsterEntity *m_ptr, MonsterEntity *t_ptr)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (!m_ptr->is_pet()) {
}
MONSTER_IDX t_idx = dummy;
- monster_type *t_ptr;
+ MonsterEntity *t_ptr;
t_ptr = &floor_ptr->m_list[t_idx];
if (t_ptr == m_ptr) {
continue;
* @return 不規則な方向へ歩くことになったらTRUE
* @todo "5"とはもしかして「その場に留まる」という意味か？
*/
-static bool random_walk(PlayerType *player_ptr, DIRECTION *mm, monster_type *m_ptr)
+static bool random_walk(PlayerType *player_ptr, DIRECTION *mm, MonsterEntity *m_ptr)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (r_ptr->behavior_flags.has_all_of({ MonsterBehaviorType::RAND_MOVE_50, MonsterBehaviorType::RAND_MOVE_25 }) && (randint0(100) < 75)) {
#include "system/monster-type-definition.h"
#include "util/bit-flags-calculator.h"
-monster_lite_type *initialize_monster_lite_type(BIT_FLAGS grid_info, monster_lite_type *ml_ptr, monster_type *m_ptr)
+monster_lite_type *initialize_monster_lite_type(BIT_FLAGS grid_info, monster_lite_type *ml_ptr, MonsterEntity *m_ptr)
{
ml_ptr->mon_fx = m_ptr->fx;
ml_ptr->mon_fy = m_ptr->fy;
POSITION mon_fx;
};
-struct monster_type;
-monster_lite_type *initialize_monster_lite_type(BIT_FLAGS grid_info, monster_lite_type *ml_ptr, monster_type *m_ptr);
+class MonsterEntity;
+monster_lite_type *initialize_monster_lite_type(BIT_FLAGS grid_info, monster_lite_type *ml_ptr, MonsterEntity *m_ptr);
}
if (!w_ptr->timewalk_m_idx) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
for (int i = 1; i < floor_ptr->m_max; i++) {
m_ptr = &floor_ptr->m_list[i];
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
-static bool check_hp_for_feat_destruction(TerrainType *f_ptr, monster_type *m_ptr)
+static bool check_hp_for_feat_destruction(TerrainType *f_ptr, MonsterEntity *m_ptr)
{
return f_ptr->flags.has_not(TerrainCharacteristics::GLASS) || monraces_info[m_ptr->r_idx].behavior_flags.has(MonsterBehaviorType::STUPID) || (m_ptr->hp >= std::max(m_ptr->maxhp / 3, 200));
}
* @param can_cross モンスターが地形を踏破できるならばTRUE
* @return 透過も破壊もしなかった場合はFALSE、それ以外はTRUE
*/
-static bool process_wall(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx, bool can_cross)
+static bool process_wall(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx, bool can_cross)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
grid_type *g_ptr;
* @param nx モンスターのX座標
* @return ここではドアを開けず、ガラスのドアを開ける可能性があるならTRUE
*/
-static bool bash_normal_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx)
+static bool bash_normal_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
grid_type *g_ptr;
* @param g_ptr グリッドへの参照ポインタ
* @param f_ptr 地形への参照ポインタ
*/
-static void bash_glass_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, TerrainType *f_ptr, bool may_bash)
+static void bash_glass_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, TerrainType *f_ptr, bool may_bash)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (!may_bash || (r_ptr->behavior_flags.has_not(MonsterBehaviorType::BASH_DOOR)) || f_ptr->flags.has_not(TerrainCharacteristics::BASH) || (m_ptr->is_pet() && ((player_ptr->pet_extra_flags & PF_OPEN_DOORS) == 0))) {
* @param nx モンスターのX座標
* @return モンスターが死亡した場合のみFALSE
*/
-static bool process_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx)
+static bool process_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
const auto &g_ref = player_ptr->current_floor_ptr->grid_array[ny][nx];
* @param nx モンスターのX座標
* @return ルーンのある/なし
*/
-static bool process_protection_rune(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx)
+static bool process_protection_rune(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx)
{
grid_type *g_ptr;
g_ptr = &player_ptr->current_floor_ptr->grid_array[ny][nx];
* @param nx モンスターのX座標
* @return モンスターが死亡した場合のみFALSE
*/
-static bool process_explosive_rune(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx)
+static bool process_explosive_rune(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx)
{
grid_type *g_ptr;
g_ptr = &player_ptr->current_floor_ptr->grid_array[ny][nx];
* @param nx モンスターのX座標
* @return モンスターが死亡した場合のみFALSE
*/
-static bool process_post_dig_wall(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, POSITION ny, POSITION nx)
+static bool process_post_dig_wall(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, POSITION ny, POSITION nx)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
grid_type *g_ptr;
return can_speak_all || can_speak_specific;
}
-static std::string_view get_speak_filename(monster_type *m_ptr)
+static std::string_view get_speak_filename(MonsterEntity *m_ptr)
{
const auto &ap_r_ref = monraces_info[m_ptr->ap_r_idx];
if (m_ptr->is_fearful() && can_speak(ap_r_ref, MonsterSpeakType::SPEAK_FEAR)) {
* @param y 目標y座標
* @param x 目標x座標
*/
-void set_target(monster_type *m_ptr, POSITION y, POSITION x)
+void set_target(MonsterEntity *m_ptr, POSITION y, POSITION x)
{
m_ptr->target_y = y;
m_ptr->target_x = x;
* @brief モンスターの目標地点をリセットする / Reset the target of counter attack
* @param m_ptr モンスターの参照ポインタ
*/
-void reset_target(monster_type *m_ptr)
+void reset_target(MonsterEntity *m_ptr)
{
set_target(m_ptr, 0, 0);
}
constexpr auto BREAK_RUNE_PROTECTION = 550; /*!< 守りのルーンの強靭度 / Rune of protection resistance */
constexpr auto BREAK_RUNE_EXPLOSION = 299; /*!< 爆発のルーンの発動しやすさ / For explosive runes */
-struct monster_type;
+class MonsterEntity;
class PlayerType;
struct turn_flags;
bool process_monster_movement(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MONSTER_IDX m_idx, DIRECTION *mm, POSITION oy, POSITION ox, int *count);
void process_speak_sound(PlayerType *player_ptr, MONSTER_IDX m_idx, POSITION oy, POSITION ox, bool aware);
-void set_target(monster_type *m_ptr, POSITION y, POSITION x);
-void reset_target(monster_type *m_ptr);
+void set_target(MonsterEntity *m_ptr, POSITION y, POSITION x);
+void reset_target(MonsterEntity *m_ptr);
* @param player_ptr プレイヤーへの参照ポインタ
* @param m_ptr モンスター参照ポインタ
*/
-void monster_drop_carried_objects(PlayerType *player_ptr, monster_type *m_ptr)
+void monster_drop_carried_objects(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
for (auto it = m_ptr->hold_o_idx_list.begin(); it != m_ptr->hold_o_idx_list.end();) {
ItemEntity forge;
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
struct turn_flags;
void update_object_by_monster_movement(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MONSTER_IDX m_idx, POSITION ny, POSITION nx);
-void monster_drop_carried_objects(PlayerType *player_ptr, monster_type *m_ptr);
+void monster_drop_carried_objects(PlayerType *player_ptr, MonsterEntity *m_ptr);
// 召喚元のモンスターが消滅した時は、召喚されたモンスターのparent_m_idxが
// 召喚されたモンスター自身のm_idxを指すようにする
for (MONSTER_IDX child_m_idx = 1; child_m_idx < floor_ptr->m_max; child_m_idx++) {
- monster_type *child_m_ptr = &floor_ptr->m_list[child_m_idx];
+ MonsterEntity *child_m_ptr = &floor_ptr->m_list[child_m_idx];
if (MonsterRace(child_m_ptr->r_idx).is_valid() && child_m_ptr->parent_m_idx == i) {
child_m_ptr->parent_m_idx = child_m_idx;
}
* @param m_ptr モンスターへの参照ポインタ
* @param m_name モンスター名称
*/
-static void escape_monster(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr, GAME_TEXT *m_name)
+static void escape_monster(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr, GAME_TEXT *m_name)
{
if (turn_flags_ptr->is_riding_mon) {
msg_format(_("%sはあなたの束縛から脱出した。", "%^s succeeded to escape from your restriction!"), m_name);
* @param candidate 隠れられる地点の候補地
*/
static void sweep_hiding_candidate(
- PlayerType *player_ptr, monster_type *m_ptr, const POSITION *y_offsets, const POSITION *x_offsets, coordinate_candidate *candidate)
+ PlayerType *player_ptr, MonsterEntity *m_ptr, const POSITION *y_offsets, const POSITION *x_offsets, coordinate_candidate *candidate)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
for (POSITION i = 0, dx = x_offsets[0], dy = y_offsets[0]; dx != 0 || dy != 0; i++, dx = x_offsets[i], dy = y_offsets[i]) {
return false;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
m_ptr->r_idx = r_idx;
m_ptr->ap_r_idx = initial_r_appearance(player_ptr, r_idx, mode);
}
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &floor_ptr->m_list[i1];
POSITION y = m_ptr->fy;
if (m_ptr->is_pet()) {
for (int i = 1; i < floor_ptr->m_max; i++) {
- monster_type *m2_ptr = &floor_ptr->m_list[i];
+ MonsterEntity *m2_ptr = &floor_ptr->m_list[i];
if (m2_ptr->parent_m_idx == i1) {
m2_ptr->parent_m_idx = i2;
return this->m_idx == 0;
}
-bool MonsterDamageProcessor::process_dead_exp_virtue(concptr note, monster_type *exp_mon)
+bool MonsterDamageProcessor::process_dead_exp_virtue(concptr note, MonsterEntity *exp_mon)
{
auto *m_ptr = &this->player_ptr->current_floor_ptr->m_list[this->m_idx];
auto &r_ref = m_ptr->get_real_r_ref();
* experience point of a monster later.
* </pre>
*/
-void MonsterDamageProcessor::get_exp_from_mon(monster_type *m_ptr, int exp_dam)
+void MonsterDamageProcessor::get_exp_from_mon(MonsterEntity *m_ptr, int exp_dam)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (!m_ptr->is_valid() || m_ptr->is_pet() || this->player_ptr->phase_out) {
enum class MonsterRaceId : int16_t;
struct monster_race;
-struct monster_type;
+class MonsterEntity;
class PlayerType;
typedef std::vector<std::tuple<MonsterRaceId, MonsterRaceId, MonsterRaceId>> combined_uniques;
class MonsterDamageProcessor {
int dam;
bool *fear;
AttributeFlags attribute_flags{};
- void get_exp_from_mon(monster_type *m_ptr, int exp_dam);
+ void get_exp_from_mon(MonsterEntity *m_ptr, int exp_dam);
bool genocide_chaos_patron();
- bool process_dead_exp_virtue(concptr note, monster_type *exp_mon);
+ bool process_dead_exp_virtue(concptr note, MonsterEntity *exp_mon);
void death_special_flag_monster();
void death_unique_monster(MonsterRaceId r_idx);
bool check_combined_unique(const MonsterRaceId r_idx, std::vector<MonsterRaceId> *combined_uniques);
* @param m_ptr モンスターの参照ポインタ
* @param mode 呼称オプション
*/
-void monster_desc(PlayerType *player_ptr, char *desc, monster_type *m_ptr, BIT_FLAGS mode)
+void monster_desc(PlayerType *player_ptr, char *desc, MonsterEntity *m_ptr, BIT_FLAGS mode)
{
monster_race *r_ptr;
r_ptr = &monraces_info[m_ptr->ap_r_idx];
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
-void monster_desc(PlayerType *player_ptr, char *desc, monster_type *m_ptr, BIT_FLAGS mode);
+void monster_desc(PlayerType *player_ptr, char *desc, MonsterEntity *m_ptr, BIT_FLAGS mode);
void message_pain(PlayerType *player_ptr, MONSTER_IDX m_idx, int dam);
* @brief モンスターを友好的にする
* @param m_ptr モンスター情報構造体の参照ポインタ
*/
-void set_friendly(monster_type *m_ptr)
+void set_friendly(MonsterEntity *m_ptr)
{
m_ptr->mflag2.set(MonsterConstantFlagType::FRIENDLY);
}
* @param n_ptr モンスター2の構造体参照ポインタ
* @return 敵対関係にあるならばTRUEを返す
*/
-bool are_enemies(PlayerType *player_ptr, const monster_type &m1_ref, const monster_type &m2_ref)
+bool are_enemies(PlayerType *player_ptr, const MonsterEntity &m1_ref, const MonsterEntity &m2_ref)
{
if (player_ptr->phase_out) {
if (m1_ref.is_pet() || m2_ref.is_pet()) {
* @details
* If user is player, m_ptr == nullptr.
*/
-bool monster_has_hostile_align(PlayerType *player_ptr, monster_type *m_ptr, int pa_good, int pa_evil, monster_race *r_ptr)
+bool monster_has_hostile_align(PlayerType *player_ptr, MonsterEntity *m_ptr, int pa_good, int pa_evil, monster_race *r_ptr)
{
byte sub_align1 = SUB_ALIGN_NEUTRAL;
byte sub_align2 = SUB_ALIGN_NEUTRAL;
return false;
}
-bool is_original_ap_and_seen(PlayerType *player_ptr, const monster_type *m_ptr)
+bool is_original_ap_and_seen(PlayerType *player_ptr, const MonsterEntity *m_ptr)
{
return m_ptr->ml && !player_ptr->effects()->hallucination()->is_hallucinated() && m_ptr->is_original_ap();
}
#define CEM_P_CAN_ENTER_PATTERN 0x0002
enum class MonsterRaceId : int16_t;
struct monster_race;
-struct monster_type;
+class MonsterEntity;
class PlayerType;
bool monster_can_cross_terrain(PlayerType *player_ptr, FEAT_IDX feat, monster_race *r_ptr, BIT_FLAGS16 mode);
bool monster_can_enter(PlayerType *player_ptr, POSITION y, POSITION x, monster_race *r_ptr, BIT_FLAGS16 mode);
-bool are_enemies(PlayerType *player_ptr, const monster_type &m1_ref, const monster_type &m2_ref);
-bool monster_has_hostile_align(PlayerType *player_ptr, monster_type *m_ptr, int pa_good, int pa_evil, monster_race *r_ptr);
-bool is_original_ap_and_seen(PlayerType *player_ptr, const monster_type *m_ptr);
+bool are_enemies(PlayerType *player_ptr, const MonsterEntity &m1_ref, const MonsterEntity &m2_ref);
+bool monster_has_hostile_align(PlayerType *player_ptr, MonsterEntity *m_ptr, int pa_good, int pa_evil, monster_race *r_ptr);
+bool is_original_ap_and_seen(PlayerType *player_ptr, const MonsterEntity *m_ptr);
void monster_name(PlayerType *player_ptr, MONSTER_IDX m_idx, char *m_name);
/* Recycle dead monsters */
for (MONSTER_IDX i = 1; i < floor_ptr->m_max; i++) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &floor_ptr->m_list[i];
if (MonsterRace(m_ptr->r_idx).is_valid()) {
continue;
POSITION gdis;
};
-struct monster_type;
+class MonsterEntity;
turn_flags *init_turn_flags(MONSTER_IDX riding_idx, MONSTER_IDX m_idx, turn_flags *turn_flags_ptr);
old_race_flags *init_old_race_flags(old_race_flags *old_race_flags_ptr);
coordinate_candidate init_coordinate_candidate(void);
bool process_monster_fear(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MONSTER_IDX m_idx);
void sweep_monster_process(PlayerType *player_ptr);
-bool decide_process_continue(PlayerType *player_ptr, monster_type *m_ptr);
+bool decide_process_continue(PlayerType *player_ptr, MonsterEntity *m_ptr);
/*!
* @brief モンスター単体の1ターン行動処理メインルーチン /
{
auto *floor_ptr = player_ptr->current_floor_ptr;
for (MONSTER_IDX i = floor_ptr->m_max - 1; i >= 1; i--) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &floor_ptr->m_list[i];
if (player_ptr->leaving) {
* @param m_ptr モンスターへの参照ポインタ
* @return 後続処理が必要ならTRUE
*/
-bool decide_process_continue(PlayerType *player_ptr, monster_type *m_ptr)
+bool decide_process_continue(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
monster_race *r_ptr;
r_ptr = &monraces_info[m_ptr->r_idx];
* @param PlayerType プレイヤーへの参照ポインタ
* @param m_ptr モンスター情報構造体の参照ポインタ
*/
-void set_pet(PlayerType *player_ptr, monster_type *m_ptr)
+void set_pet(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
QuestCompletionChecker(player_ptr, m_ptr).complete();
m_ptr->mflag2.set(MonsterConstantFlagType::PET);
* Makes the monster hostile towards the player
* @param m_ptr モンスター情報構造体の参照ポインタ
*/
-void set_hostile(PlayerType *player_ptr, monster_type *m_ptr)
+void set_hostile(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
if (player_ptr->phase_out) {
return;
* Anger the monster
* @param m_ptr モンスター情報構造体の参照ポインタ
*/
-void anger_monster(PlayerType *player_ptr, monster_type *m_ptr)
+void anger_monster(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
if (player_ptr->phase_out || !m_ptr->is_friendly()) {
return;
#include "system/angband.h"
enum class MonsterRaceId : int16_t;
-struct monster_type;
+class MonsterEntity;
class PlayerType;
-void set_friendly(monster_type *m_ptr);
-void set_pet(PlayerType *player_ptr, monster_type *m_ptr);
-void set_hostile(PlayerType *player_ptr, monster_type *m_ptr);
-void anger_monster(PlayerType *player_ptr, monster_type *m_ptr);
+void set_friendly(MonsterEntity *m_ptr);
+void set_pet(PlayerType *player_ptr, MonsterEntity *m_ptr);
+void set_hostile(PlayerType *player_ptr, MonsterEntity *m_ptr);
+void anger_monster(PlayerType *player_ptr, MonsterEntity *m_ptr);
bool set_monster_csleep(PlayerType *player_ptr, MONSTER_IDX m_idx, int v);
bool set_monster_fast(PlayerType *player_ptr, MONSTER_IDX m_idx, int v);
bool set_monster_slow(PlayerType *player_ptr, MONSTER_IDX m_idx, int v);
* @return 修正を行った結果のダメージ量
* @details RES_ALL持ちはAC軽減後のダメージを1/100に補正する. 光の剣は無敵を無効化する. 一定確率で無敵は貫通できる.
*/
-int mon_damage_mod(PlayerType *player_ptr, monster_type *m_ptr, int dam, bool is_psy_spear)
+int mon_damage_mod(PlayerType *player_ptr, MonsterEntity *m_ptr, int dam, bool is_psy_spear)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL) && dam > 0) {
enum class MonsterRaceId : int16_t;
class FloorType;
class PlayerType;
-struct monster_type;
+class MonsterEntity;
bool monster_is_powerful(FloorType *floor_ptr, MONSTER_IDX m_idx);
DEPTH monster_level_idx(FloorType *floor_ptr, MONSTER_IDX m_idx);
-int mon_damage_mod(PlayerType *player_ptr, monster_type *m_ptr, int dam, bool is_psy_spear);
+int mon_damage_mod(PlayerType *player_ptr, MonsterEntity *m_ptr, int dam, bool is_psy_spear);
void dispel_monster_status(PlayerType *player_ptr, MONSTER_IDX m_idx);
void monster_gain_exp(PlayerType *player_ptr, MONSTER_IDX m_idx, MonsterRaceId s_idx);
// Update Monster.
struct um_type {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
bool do_disturb;
POSITION fy;
POSITION fx;
{
auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
auto *g_ptr = &player_ptr->current_floor_ptr->grid_array[ny][nx];
- monster_type *y_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
+ MonsterEntity *y_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
if (turn_flags_ptr->is_riding_mon) {
return move_player_effect(player_ptr, ny, nx, MPE_DONT_PICKUP);
}
* @param turn_flags_ptr ターン経過処理フラグへの参照ポインタ
* @param m_ptr モンスターへの参照ポインタ
*/
-void update_monster_race_flags(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr)
+void update_monster_race_flags(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (!is_original_ap_and_seen(player_ptr, m_ptr)) {
#include "system/angband.h"
struct monster_race;
-struct monster_type;
+class MonsterEntity;
struct old_race_flags;
;
class PlayerType;
struct turn_flags;
bool update_riding_monster(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MONSTER_IDX m_idx, POSITION oy, POSITION ox, POSITION ny, POSITION nx);
void update_player_type(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_race *r_ptr);
-void update_monster_race_flags(PlayerType *player_ptr, turn_flags *turn_flags_ptr, monster_type *m_ptr);
+void update_monster_race_flags(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MonsterEntity *m_ptr);
void update_player_window(PlayerType *player_ptr, old_race_flags *old_race_flags_ptr);
void update_monster(PlayerType *player_ptr, MONSTER_IDX m_idx, bool full);
void update_monsters(PlayerType *player_ptr, bool full);
};
// Monster Spell Attack.
-struct monster_type;
+class MonsterEntity;
struct monster_race;
struct msa_type {
MONSTER_IDX m_idx;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
bool no_inate;
EnumClassFlagGroup<MonsterAbilityType> ability_flags;
* @param m_ptr 判定を行いたいモンスターの構造体参照ポインタ
* @return 死者復活が有効な状態ならばTRUEを返す。
*/
-bool raise_possible(PlayerType *player_ptr, monster_type *m_ptr)
+bool raise_possible(PlayerType *player_ptr, MonsterEntity *m_ptr)
{
POSITION y = m_ptr->fy;
POSITION x = m_ptr->fx;
enum class MonsterAbilityType;
enum class AttributeType;
-struct monster_type;
+class MonsterEntity;
class PlayerType;
bool clean_shot(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, bool is_friend);
bool summon_possible(PlayerType *player_ptr, POSITION y1, POSITION x1);
-bool raise_possible(PlayerType *player_ptr, monster_type *m_ptr);
+bool raise_possible(PlayerType *player_ptr, MonsterEntity *m_ptr);
bool spell_is_inate(MonsterAbilityType spell);
ProjectResult beam(PlayerType *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type);
ProjectResult bolt(PlayerType *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type);
auto *floor_ptr = player_ptr->current_floor_ptr;
auto *m_ptr = &floor_ptr->m_list[m_idx];
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
mspell_cast_msg_simple msg(_("%^sがあなたを引き戻した。", "%^s commands you to return."),
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
mspell_cast_msg_simple msg(_("%^sにテレポートさせられた。", "%^s teleports you away."),
const auto res = MonsterSpellResult::make_valid();
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
* @param m_ptr 使用するモンスターの構造体参照ポインタ
* @return ビームが到達可能ならばTRUEを返す
*/
-bool direct_beam(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, monster_type *m_ptr)
+bool direct_beam(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, MonsterEntity *m_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
projection_path grid_g(player_ptr, get_max_range(player_ptr), y1, x1, y2, x2, PROJECT_THRU);
#include "effect/attribute-types.h"
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
-bool direct_beam(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, monster_type *m_ptr);
+bool direct_beam(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, MonsterEntity *m_ptr);
bool breath_direct(PlayerType *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, POSITION rad, AttributeType typ, bool is_friend);
void get_project_point(PlayerType *player_ptr, POSITION sy, POSITION sx, POSITION *ty, POSITION *tx, BIT_FLAGS flg);
bool dispel_check_monster(PlayerType *player_ptr, MONSTER_IDX m_idx, MONSTER_IDX t_idx);
* @param path_check 射線を判定するための関数ポインタ
* @return 有効な座標があった場合TRUEを返す
*/
-bool adjacent_grid_check(PlayerType *player_ptr, monster_type *m_ptr, POSITION *yp, POSITION *xp, TerrainCharacteristics f_flag, path_check_pf path_check)
+bool adjacent_grid_check(PlayerType *player_ptr, MonsterEntity *m_ptr, POSITION *yp, POSITION *xp, TerrainCharacteristics f_flag, path_check_pf path_check)
{
static int tonari_y[4][8] = { { -1, -1, -1, 0, 0, 1, 1, 1 }, { -1, -1, -1, 0, 0, 1, 1, 1 }, { 1, 1, 1, 0, 0, -1, -1, -1 }, { 1, 1, 1, 0, 0, -1, -1, -1 } };
static int tonari_x[4][8] = { { -1, 0, 1, -1, 1, -1, 0, 1 }, { 1, 0, -1, 1, -1, 1, 0, -1 }, { -1, 0, 1, -1, 1, -1, 0, 1 }, { 1, 0, -1, 1, -1, 1, 0, -1 } };
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
struct msa_type;
class PlayerType;
typedef bool (*path_check_pf)(PlayerType *, POSITION, POSITION, POSITION, POSITION);
enum class TerrainCharacteristics;
-bool adjacent_grid_check(PlayerType *player_ptr, monster_type *m_ptr, POSITION *yp, POSITION *xp, TerrainCharacteristics f_flag, path_check_pf path_check);
+bool adjacent_grid_check(PlayerType *player_ptr, MonsterEntity *m_ptr, POSITION *yp, POSITION *xp, TerrainCharacteristics f_flag, path_check_pf path_check);
void decide_lite_range(PlayerType *player_ptr, msa_type *msa_ptr);
bool decide_lite_projection(PlayerType *player_ptr, msa_type *msa_ptr);
void decide_lite_area(PlayerType *player_ptr, msa_type *msa_ptr);
mspell_cast_msg_simple msg;
auto *floor_ptr = player_ptr->current_floor_ptr;
auto *m_ptr = &floor_ptr->m_list[m_idx];
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
bool monster_to_player = (target_type == MONSTER_TO_PLAYER);
bool monster_to_monster = (target_type == MONSTER_TO_MONSTER);
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
res.learnable = target_type == MONSTER_TO_PLAYER;
auto *floor_ptr = player_ptr->current_floor_ptr;
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
monster_race *tr_ptr = &monraces_info[t_ptr->r_idx];
DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
bool resist, saving_throw;
*/
bool see_monster(PlayerType *player_ptr, MONSTER_IDX m_idx)
{
- monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
+ MonsterEntity *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
return is_seen(player_ptr, m_ptr);
}
*/
bool monster_near_player(FloorType *floor_ptr, MONSTER_IDX m_idx, MONSTER_IDX t_idx)
{
- monster_type *m_ptr = &floor_ptr->m_list[m_idx];
- monster_type *t_ptr = &floor_ptr->m_list[t_idx];
+ MonsterEntity *m_ptr = &floor_ptr->m_list[m_idx];
+ MonsterEntity *t_ptr = &floor_ptr->m_list[t_idx];
return (m_ptr->cdis <= MAX_PLAYER_SIGHT) || (t_ptr->cdis <= MAX_PLAYER_SIGHT);
}
bool activate_unique_detection(PlayerType *player_ptr)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
msg_print(_("奇妙な場所が頭の中に浮かんだ．．．", "Some strange places show up in your mind. And you see ..."));
for (int i = player_ptr->current_floor_ptr->m_max - 1; i >= 1; i--) {
#include "util/flag-group.h"
struct grid_type;
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class PlayerType;
class ObjectThrowEntity {
bool come_back = false;
bool do_drop = true;
grid_type *g_ptr{};
- monster_type *m_ptr{};
+ MonsterEntity *m_ptr{};
GAME_TEXT m_name[MAX_NLEN]{};
int back_chance{};
char o2_name[MAX_NLEN]{};
* @param dam 基本ダメージ
* @param max 算出した最大ダメージを返すポインタ
*/
-static void spell_damcalc(PlayerType *player_ptr, monster_type *m_ptr, AttributeType typ, int dam, int *max)
+static void spell_damcalc(PlayerType *player_ptr, MonsterEntity *m_ptr, AttributeType typ, int dam, int *max)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
int rlev = r_ptr->level;
* @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
* @return 算出された最大ダメージを返す。
*/
-static int blow_damcalc(monster_type *m_ptr, PlayerType *player_ptr, MonsterBlow *blow_ptr)
+static int blow_damcalc(MonsterEntity *m_ptr, PlayerType *player_ptr, MonsterBlow *blow_ptr)
{
int dam = blow_ptr->d_dice * blow_ptr->d_side;
int dummy_max = 0;
for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++) {
for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++) {
int dam_max0 = 0;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
if (!in_bounds(player_ptr->current_floor_ptr, my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) {
struct grid_type;
;
struct monster_race;
-struct monster_type;
+class MonsterEntity;
struct player_attack_type {
int16_t hand{}; //!< 武器の持ち手
grid_type *g_ptr; //!< ターゲットのいる地形情報
MONSTER_IDX m_idx{}; //!< モンスターID
- monster_type *m_ptr{}; //!< モンスター情報(参照ポインタ)
+ MonsterEntity *m_ptr{}; //!< モンスター情報(参照ポインタ)
GAME_TEXT m_name[MAX_NLEN]{}; //!< モンスター名
MonsterRaceId r_idx{}; //!< モンスター種族ID
monster_race *r_ptr{}; //!< モンスター種族情報(参照ポインタ)
void massacre(PlayerType *player_ptr)
{
grid_type *g_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
for (DIRECTION dir = 0; dir < 8; dir++) {
POSITION y = player_ptr->y + ddy_ddd[dir];
POSITION x = player_ptr->x + ddx_ddd[dir];
* @param m_ptr ELDRITCH_HORRORを引き起こしたモンスターの参照ポインタ。薬・罠・魔法の影響ならnullptr
* @param necro 暗黒領域魔法の詠唱失敗によるものならばTRUEを返す
*/
-void sanity_blast(PlayerType *player_ptr, monster_type *m_ptr, bool necro)
+void sanity_blast(PlayerType *player_ptr, MonsterEntity *m_ptr, bool necro)
{
if (player_ptr->phase_out || !w_ptr->character_dungeon) {
return;
#pragma once
-struct monster_type;
+class MonsterEntity;
class PlayerType;
-void sanity_blast(PlayerType *player_ptr, monster_type *m_ptr, bool necro);
+void sanity_blast(PlayerType *player_ptr, MonsterEntity *m_ptr, bool necro);
* @param dam_func ダメージ処理を行う関数の参照ポインタ
* @param message オーラダメージを受けた際のメッセージ
*/
-static void process_aura_damage(monster_type *m_ptr, PlayerType *player_ptr, bool immune, MonsterAuraType aura_flag, dam_func dam_func, concptr message)
+static void process_aura_damage(MonsterEntity *m_ptr, PlayerType *player_ptr, bool immune, MonsterAuraType aura_flag, dam_func dam_func, concptr message)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
if (r_ptr->aura_flags.has_not(aura_flag) || immune) {
* @param m_ptr オーラを持つモンスターの構造体参照ポインタ
* @param player_ptr プレイヤーへの参照ポインタ
*/
-void touch_zap_player(monster_type *m_ptr, PlayerType *player_ptr)
+void touch_zap_player(MonsterEntity *m_ptr, PlayerType *player_ptr)
{
process_aura_damage(m_ptr, player_ptr, has_immune_fire(player_ptr) != 0, MonsterAuraType::FIRE, fire_dam, _("突然とても熱くなった！", "You are suddenly very hot!"));
process_aura_damage(m_ptr, player_ptr, has_immune_cold(player_ptr) != 0, MonsterAuraType::COLD, cold_dam, _("突然とても寒くなった！", "You are suddenly very cold!"));
#define DAMAGE_NOESCAPE 5
#define DAMAGE_USELIFE 6
-struct monster_type;
+class MonsterEntity;
class PlayerType;
int take_hit(PlayerType *player_ptr, int damage_type, int damage, concptr kb_str);
int acid_dam(PlayerType *player_ptr, int dam, concptr kb_str, bool aura);
int elec_dam(PlayerType *player_ptr, int dam, concptr kb_str, bool aura);
int fire_dam(PlayerType *player_ptr, int dam, concptr kb_str, bool aura);
int cold_dam(PlayerType *player_ptr, int dam, concptr kb_str, bool aura);
-void touch_zap_player(monster_type *m_ptr, PlayerType *player_ptr);
+void touch_zap_player(MonsterEntity *m_ptr, PlayerType *player_ptr);
g_ptr->m_idx = om_idx;
oc_ptr->m_idx = nm_idx;
if (om_idx > 0) {
- monster_type *om_ptr = &floor_ptr->m_list[om_idx];
+ MonsterEntity *om_ptr = &floor_ptr->m_list[om_idx];
om_ptr->fy = ny;
om_ptr->fx = nx;
update_monster(player_ptr, om_idx, true);
}
if (nm_idx > 0) {
- monster_type *nm_ptr = &floor_ptr->m_list[nm_idx];
+ MonsterEntity *nm_ptr = &floor_ptr->m_list[nm_idx];
nm_ptr->fy = oy;
nm_ptr->fx = ox;
update_monster(player_ptr, nm_idx, true);
}
if (player_ptr->riding) {
- monster_type *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
+ MonsterEntity *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
monster_race *riding_r_ptr = &monraces_info[riding_m_ptr->r_idx];
if (riding_r_ptr->feature_flags.has(MonsterFeatureType::KILL_WALL)) {
return true;
}
if (player_ptr->riding) {
- monster_type *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
+ MonsterEntity *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
monster_race *riding_r_ptr = &monraces_info[riding_m_ptr->r_idx];
if (riding_r_ptr->feature_flags.has_not(MonsterFeatureType::PASS_WALL)) {
pow = false;
// 乗馬中は実際に浮遊するかどうかは乗馬中のモンスターに依存する
if (player_ptr->riding) {
- monster_type *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
+ MonsterEntity *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
monster_race *riding_r_ptr = &monraces_info[riding_m_ptr->r_idx];
result = riding_r_ptr->feature_flags.has(MonsterFeatureType::CAN_FLY) ? FLAG_CAUSE_RIDING : FLAG_CAUSE_NONE;
}
{
bool can_swim = false;
if (player_ptr->riding) {
- monster_type *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
+ MonsterEntity *riding_m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
monster_race *riding_r_ptr = &monraces_info[riding_m_ptr->r_idx];
if (riding_r_ptr->feature_flags.has_any_of({ MonsterFeatureType::CAN_SWIM, MonsterFeatureType::AQUATIC })) {
can_swim = true;
POSITION ny, nx;
MONSTER_IDX m_idx;
grid_type *g_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
y = player_ptr->y + ddy[dir];
x = player_ptr->x + ddx[dir];
int i;
nest_mon_info_type nest_mon_info[NUM_NEST_MON_TYPE];
- monster_type align;
+ MonsterEntity align;
grid_type *g_ptr;
MonsterRaceId what[16];
- monster_type align;
+ MonsterEntity align;
grid_type *g_ptr;
MonsterRaceId what[16];
- monster_type align;
+ MonsterEntity align;
grid_type *g_ptr;
#include "util/enum-converter.h"
#include "util/quarks.h"
-static void write_monster_flags(monster_type *m_ptr, BIT_FLAGS *flags)
+static void write_monster_flags(MonsterEntity *m_ptr, BIT_FLAGS *flags)
{
if (!m_ptr->is_original_ap()) {
set_bits(*flags, SaveDataMonsterFlagType::AP_R_IDX);
wr_u32b(*flags);
}
-static void write_monster_info(monster_type *m_ptr, const BIT_FLAGS flags)
+static void write_monster_info(MonsterEntity *m_ptr, const BIT_FLAGS flags)
{
byte tmp8u;
if (any_bits(flags, SaveDataMonsterFlagType::FAST)) {
* @brief モンスター情報を書き込む / Write a "monster" record
* @param m_ptr モンスター情報保存元ポインタ
*/
-void wr_monster(monster_type *m_ptr)
+void wr_monster(MonsterEntity *m_ptr)
{
BIT_FLAGS flags = 0x00000000;
write_monster_flags(m_ptr, &flags);
#include "system/angband.h"
enum class MonsterRaceId : int16_t;
-struct monster_type;
-void wr_monster(monster_type *m_ptr);
+class MonsterEntity;
+void wr_monster(MonsterEntity *m_ptr);
void wr_lore(MonsterRaceId r_idx);
bool fetch_monster(PlayerType *player_ptr)
{
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
MONSTER_IDX m_idx;
GAME_TEXT m_name[MAX_NLEN];
POSITION ty, tx;
return false;
}
- monster_type back_m = *m_ptr;
+ MonsterEntity back_m = *m_ptr;
new_r_idx = poly_r_idx(player_ptr, old_r_idx);
if (new_r_idx == old_r_idx) {
return false;
* @param m_ptr モンスター情報への参照ポインタ
* @param r_ptr モンスター種族への参照ポインタ
*/
-void probed_monster_info(char *buf, PlayerType *player_ptr, monster_type *m_ptr, monster_race *r_ptr)
+void probed_monster_info(char *buf, PlayerType *player_ptr, MonsterEntity *m_ptr, monster_race *r_ptr)
{
if (!m_ptr->is_original_ap()) {
if (m_ptr->mflag2.has(MonsterConstantFlagType::KAGE)) {
#include "system/angband.h"
struct monster_race;
-struct monster_type;
+class MonsterEntity;
class PlayerType;
bool project_all_los(PlayerType *player_ptr, AttributeType typ, int dam);
bool speed_monsters(PlayerType *player_ptr);
bool turn_evil(PlayerType *player_ptr, int dam);
bool turn_monsters(PlayerType *player_ptr, int dam);
bool deathray_monsters(PlayerType *player_ptr);
-void probed_monster_info(char *buf, PlayerType *player_ptr, monster_type *m_ptr, monster_race *r_ptr);
+void probed_monster_info(char *buf, PlayerType *player_ptr, MonsterEntity *m_ptr, monster_race *r_ptr);
bool probing(PlayerType *player_ptr);
return false;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
r_ptr = &monraces_info[m_ptr->r_idx];
return true;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
monster_race *r_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[target_m_idx];
r_ptr = &monraces_info[m_ptr->r_idx];
* @param m_ptr 対象モンスター
* @return 魅了に抵抗したらTRUE
*/
-bool common_saving_throw_charm(PlayerType *player_ptr, int pow, monster_type *m_ptr)
+bool common_saving_throw_charm(PlayerType *player_ptr, int pow, MonsterEntity *m_ptr)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
* @param m_ptr 対象モンスター
* @return 服従に抵抗したらTRUE
*/
-bool common_saving_throw_control(PlayerType *player_ptr, int pow, monster_type *m_ptr)
+bool common_saving_throw_control(PlayerType *player_ptr, int pow, MonsterEntity *m_ptr)
{
auto *r_ptr = &monraces_info[m_ptr->r_idx];
#include "system/angband.h"
-struct monster_type;
+class MonsterEntity;
class PlayerType;
-bool common_saving_throw_control(PlayerType *player_ptr, int pow, monster_type *m_ptr);
-bool common_saving_throw_charm(PlayerType *player_ptr, int pow, monster_type *m_ptr);
+bool common_saving_throw_control(PlayerType *player_ptr, int pow, MonsterEntity *m_ptr);
+bool common_saving_throw_charm(PlayerType *player_ptr, int pow, MonsterEntity *m_ptr);
PERCENTAGE beam_chance(PlayerType *player_ptr);
* @brief プレイヤーの因果混乱処理 / Apply Nexus
* @param m_ptr 因果混乱をプレイヤーに与えたモンスターの情報参照ポインタ
*/
-void apply_nexus(monster_type *m_ptr, PlayerType *player_ptr)
+void apply_nexus(MonsterEntity *m_ptr, PlayerType *player_ptr)
{
switch (randint1(7)) {
case 1:
class ItemEntity;
class PlayerType;
-struct monster_type;
+class MonsterEntity;
bool heal_monster(PlayerType *player_ptr, DIRECTION dir, int dam);
bool speed_monster(PlayerType *player_ptr, DIRECTION dir, int power);
bool slow_monster(PlayerType *player_ptr, DIRECTION dir, int power);
bool fishing(PlayerType *player_ptr);
bool cosmic_cast_off(PlayerType *player_ptr, ItemEntity **o_ptr_ptr);
-void apply_nexus(monster_type *m_ptr, PlayerType *player_ptr);
+void apply_nexus(MonsterEntity *m_ptr, PlayerType *player_ptr);
void status_shuffle(PlayerType *player_ptr);
if (!count) {
for (int i = player_ptr->current_floor_ptr->m_max - 1; i > 0; i--) {
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[i];
if (!m_ptr->is_valid()) {
continue;
constexpr auto REDRAW_MAX = 2298;
struct grid_type;
-struct monster_type;
+class MonsterEntity;
class ItemEntity;
class FloorType {
public:
OBJECT_IDX o_max = 0; /* Number of allocated objects */
OBJECT_IDX o_cnt = 0; /* Number of live objects */
- std::vector<monster_type> m_list; /*!< The array of dungeon monsters [max_m_idx] */
+ std::vector<MonsterEntity> m_list; /*!< The array of dungeon monsters [max_m_idx] */
MONSTER_IDX m_max = 0; /* Number of allocated monsters */
MONSTER_IDX m_cnt = 0; /* Number of live monsters */
#include "system/monster-race-definition.h"
#include "util/string-processor.h"
-bool monster_type::is_friendly() const
+bool MonsterEntity::is_friendly() const
{
return this->mflag2.has(MonsterConstantFlagType::FRIENDLY);
}
-bool monster_type::is_pet() const
+bool MonsterEntity::is_pet() const
{
return this->mflag2.has(MonsterConstantFlagType::PET);
}
-bool monster_type::is_hostile() const
+bool MonsterEntity::is_hostile() const
{
return !this->is_friendly() && !this->is_pet();
}
-bool monster_type::is_original_ap() const
+bool MonsterEntity::is_original_ap() const
{
return this->ap_r_idx == this->r_idx;
}
* その他増やしたい時はis_special_mimic に「|=」で追加すること
*
*/
-bool monster_type::is_mimicry() const
+bool MonsterEntity::is_mimicry() const
{
auto is_special_mimic = this->ap_r_idx == MonsterRaceId::BEHINDER;
if (is_special_mimic) {
return r_ref.behavior_flags.has(MonsterBehaviorType::NEVER_MOVE) || this->is_asleep();
}
-bool monster_type::is_valid() const
+bool MonsterEntity::is_valid() const
{
return MonsterRace(this->r_idx).is_valid();
}
-MonsterRaceId monster_type::get_real_r_idx() const
+MonsterRaceId MonsterEntity::get_real_r_idx() const
{
const auto &r_ref = monraces_info[this->r_idx];
if (this->mflag2.has_not(MonsterConstantFlagType::CHAMELEON)) {
* @brief モンスターの真の種族を返す / Extract monster race pointer of a monster's true form
* @return 本当のモンスター種族参照ポインタ
*/
-monster_race &monster_type::get_real_r_ref() const
+monster_race &MonsterEntity::get_real_r_ref() const
{
return monraces_info[this->get_real_r_idx()];
}
-short monster_type::get_remaining_sleep() const
+short MonsterEntity::get_remaining_sleep() const
{
return this->mtimed[MTIMED_CSLEEP];
}
-bool monster_type::is_asleep() const
+bool MonsterEntity::is_asleep() const
{
return this->get_remaining_sleep() > 0;
}
-short monster_type::get_remaining_acceleration() const
+short MonsterEntity::get_remaining_acceleration() const
{
return this->mtimed[MTIMED_FAST];
}
-bool monster_type::is_accelerated() const
+bool MonsterEntity::is_accelerated() const
{
return this->get_remaining_acceleration() > 0;
}
-short monster_type::get_remaining_deceleration() const
+short MonsterEntity::get_remaining_deceleration() const
{
return this->mtimed[MTIMED_SLOW];
}
-bool monster_type::is_decelerated() const
+bool MonsterEntity::is_decelerated() const
{
return this->get_remaining_deceleration() > 0;
}
-short monster_type::get_remaining_stun() const
+short MonsterEntity::get_remaining_stun() const
{
return this->mtimed[MTIMED_STUNNED];
}
-bool monster_type::is_stunned() const
+bool MonsterEntity::is_stunned() const
{
return this->get_remaining_stun() > 0;
}
-short monster_type::get_remaining_confusion() const
+short MonsterEntity::get_remaining_confusion() const
{
return this->mtimed[MTIMED_CONFUSED];
}
-bool monster_type::is_confused() const
+bool MonsterEntity::is_confused() const
{
return this->get_remaining_confusion() > 0;
}
-short monster_type::get_remaining_fear() const
+short MonsterEntity::get_remaining_fear() const
{
return this->mtimed[MTIMED_MONFEAR];
}
-bool monster_type::is_fearful() const
+bool MonsterEntity::is_fearful() const
{
return this->get_remaining_fear() > 0;
}
-short monster_type::get_remaining_invulnerability() const
+short MonsterEntity::get_remaining_invulnerability() const
{
return this->mtimed[MTIMED_INVULNER];
}
-bool monster_type::is_invulnerable() const
+bool MonsterEntity::is_invulnerable() const
{
return this->get_remaining_invulnerability() > 0;
}
/*
* @brief 悪夢モード、一時加速、一時減速に基づくモンスターの現在速度を返す
*/
-byte monster_type::get_temporary_speed() const
+byte MonsterEntity::get_temporary_speed() const
{
auto speed = this->mspeed;
if (ironman_nightmare) {
enum class MonsterRaceId : int16_t;
class FloorType;
struct monster_race;
-struct monster_type {
+class MonsterEntity {
+public:
+ MonsterEntity() = default;
MonsterRaceId r_idx{}; /*!< モンスターの実種族ID (これが0の時は死亡扱いになる) / Monster race index 0 = dead. */
MonsterRaceId ap_r_idx{}; /*!< モンスターの外見種族ID（あやしい影、たぬき、ジュラル星人誤認などにより変化する）Monster race appearance index */
FloorType *current_floor_ptr{}; /*!< 所在フロアID（現状はFloorType構造体によるオブジェクトは1つしかないためソースコード設計上の意義以外はない）*/
OBJECT_IDX floor_list[23];
ITEM_NUMBER floor_num;
grid_type *g_ptr;
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
OBJECT_IDX next_o_idx;
FEAT_IDX feat;
TerrainType *f_ptr;
/*
* Evaluate number of kill needed to gain level
*/
-static void evaluate_monster_exp(PlayerType *player_ptr, char *buf, monster_type *m_ptr)
+static void evaluate_monster_exp(PlayerType *player_ptr, char *buf, MonsterEntity *m_ptr)
{
monster_race *ap_r_ptr = &monraces_info[m_ptr->ap_r_idx];
if ((player_ptr->lev >= PY_MAX_LEVEL) || PlayerRace(player_ptr).equals(PlayerRaceType::ANDROID)) {
POSITION *y = (POSITION *)(v);
grid_type *ca_ptr = &player_ptr->current_floor_ptr->grid_array[y[a]][x[a]];
grid_type *cb_ptr = &player_ptr->current_floor_ptr->grid_array[y[b]][x[b]];
- monster_type *ma_ptr = &player_ptr->current_floor_ptr->m_list[ca_ptr->m_idx];
- monster_type *mb_ptr = &player_ptr->current_floor_ptr->m_list[cb_ptr->m_idx];
+ MonsterEntity *ma_ptr = &player_ptr->current_floor_ptr->m_list[ca_ptr->m_idx];
+ MonsterEntity *mb_ptr = &player_ptr->current_floor_ptr->m_list[cb_ptr->m_idx];
monster_race *ap_ra_ptr, *ap_rb_ptr;
/* The player grid */
int w1 = who[a];
int w2 = who[b];
- monster_type *m_ptr1 = &player_ptr->current_floor_ptr->m_list[w1];
- monster_type *m_ptr2 = &player_ptr->current_floor_ptr->m_list[w2];
+ MonsterEntity *m_ptr1 = &player_ptr->current_floor_ptr->m_list[w1];
+ MonsterEntity *m_ptr2 = &player_ptr->current_floor_ptr->m_list[w2];
monster_race *r_ptr1 = &monraces_info[m_ptr1->r_idx];
monster_race *r_ptr2 = &monraces_info[m_ptr2->r_idx];
int w1 = who[a];
int w2 = who[b];
- monster_type *m_ptr1 = &player_ptr->current_floor_ptr->m_list[w1];
- monster_type *m_ptr2 = &player_ptr->current_floor_ptr->m_list[w2];
+ MonsterEntity *m_ptr1 = &player_ptr->current_floor_ptr->m_list[w1];
+ MonsterEntity *m_ptr2 = &player_ptr->current_floor_ptr->m_list[w2];
monster_race *r_ptr1 = &monraces_info[m_ptr1->r_idx];
monster_race *r_ptr2 = &monraces_info[m_ptr2->r_idx];
/*
* Monster health description
*/
-concptr look_mon_desc(monster_type *m_ptr, BIT_FLAGS mode)
+concptr look_mon_desc(MonsterEntity *m_ptr, BIT_FLAGS mode)
{
bool living = monster_living(m_ptr->ap_r_idx);
int perc = m_ptr->maxhp > 0 ? 100L * m_ptr->hp / m_ptr->maxhp : 0;
#include "system/angband.h"
-struct monster_type;
-concptr look_mon_desc(monster_type *m_ptr, BIT_FLAGS mode);
+class MonsterEntity;
+concptr look_mon_desc(MonsterEntity *m_ptr, BIT_FLAGS mode);
* name: name of monster
* </pre>
*/
-static void print_monster_line(TERM_LEN x, TERM_LEN y, monster_type *m_ptr, int n_same)
+static void print_monster_line(TERM_LEN x, TERM_LEN y, MonsterEntity *m_ptr, int n_same)
{
char buf[256];
MonsterRaceId r_idx = m_ptr->ap_r_idx;
void print_monster_list(FloorType *floor_ptr, const std::vector<MONSTER_IDX> &monster_list, TERM_LEN x, TERM_LEN y, TERM_LEN max_lines)
{
TERM_LEN line = y;
- monster_type *last_mons = nullptr;
+ MonsterEntity *last_mons = nullptr;
int n_same = 0;
size_t i;
for (i = 0; i < monster_list.size(); i++) {
* @details
* Lookコマンドでカーソルを合わせた場合に合わせてミミックは考慮しない。
*/
-static const monster_type *monster_on_floor_items(FloorType *floor_ptr, const grid_type *g_ptr)
+static const MonsterEntity *monster_on_floor_items(FloorType *floor_ptr, const grid_type *g_ptr)
{
if (g_ptr->m_idx == 0) {
return nullptr;
col = COL_INFO;
}
- monster_type *m_ptr;
+ MonsterEntity *m_ptr;
m_ptr = &player_ptr->current_floor_ptr->m_list[health_who];
if (w_ptr->wizard && player_ptr->phase_out) {
OSDN Git Service
