* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return 発動実行の是非を返す。
*/
-static bool activate_artifact(PlayerType *player_ptr, ObjectType *o_ptr)
+static bool activate_artifact(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto tmp_act_ptr = find_activation_info(o_ptr);
if (!tmp_act_ptr.has_value()) {
{
auto *g_ptr = &floor_ptr->grid_array[y][x];
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if ((o_ptr->tval == ItemKindType::CHEST) && (((!trapped) && (o_ptr->pval)) || /* non empty */
((trapped) && (o_ptr->pval > 0)))) { /* trapped only */
continue;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[o_idx];
if (o_ptr->pval == 0) {
continue;
}
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (o_ptr->marked & OM_FOUND) {
return true;
*/
void verify_equip_slot(PlayerType *player_ptr, INVENTORY_IDX item)
{
- ObjectType *o_ptr, *new_o_ptr;
+ ItemEntity *o_ptr, *new_o_ptr;
GAME_TEXT o_name[MAX_NLEN];
if (item == INVEN_MAIN_HAND) {
* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return 発動効果のIDを返す
*/
-RandomArtActType activation_index(const ObjectType *o_ptr)
+RandomArtActType activation_index(const ItemEntity *o_ptr)
{
if (auto act_idx = Smith::object_activation(o_ptr); act_idx.has_value()) {
return act_idx.value();
* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return 発動効果構造体のポインタを返す
*/
-std::optional<const activation_type *> find_activation_info(const ObjectType *o_ptr)
+std::optional<const activation_type *> find_activation_info(const ItemEntity *o_ptr)
{
const auto index = activation_index(o_ptr);
for (const auto &p : activation_info) {
enum class RandomArtActType : short;
struct activation_type;
-class ObjectType;
-RandomArtActType activation_index(const ObjectType *o_ptr);
-std::optional<const activation_type *> find_activation_info(const ObjectType *o_ptr);
+class ItemEntity;
+RandomArtActType activation_index(const ItemEntity *o_ptr);
+std::optional<const activation_type *> find_activation_info(const ItemEntity *o_ptr);
* 純戦士系職業は追加能力/耐性がもらえる。
* それ以外では、反感、太古の怨念、呪いが付き追加能力/耐性はもらえない。
*/
-static bool invest_terror_mask(PlayerType *player_ptr, ObjectType *o_ptr)
+static bool invest_terror_mask(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::TERROR)) {
return false;
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 対象のオブジェクト構造体への参照ポインタ
*/
-static void milim_swimsuit(PlayerType *player_ptr, ObjectType *o_ptr)
+static void milim_swimsuit(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::MILIM) || (player_ptr->ppersonality != PERSONALITY_SEXY)) {
return;
* @details
* 対象は村正、ロビントンのハープ、龍争虎鬪、ブラッディムーン、羽衣、天女の羽衣、ミリム
*/
-static void invest_special_artifact_abilities(PlayerType *player_ptr, ObjectType *o_ptr)
+static void invest_special_artifact_abilities(PlayerType *player_ptr, ItemEntity *o_ptr)
{
const auto pc = PlayerClass(player_ptr);
switch (o_ptr->fixed_artifact_idx) {
* @param a_ptr 固定アーティファクト情報への参照ポインタ
* @param q_ptr オブジェクト情報への参照ポインタ
*/
-static void fixed_artifact_random_abilities(PlayerType *player_ptr, const ArtifactType &a_ref, ObjectType *o_ptr)
+static void fixed_artifact_random_abilities(PlayerType *player_ptr, const ArtifactType &a_ref, ItemEntity *o_ptr)
{
auto give_power = false;
auto give_resistance = false;
* @param a_ptr 固定アーティファクト情報への参照ポインタ
* @param q_ptr オブジェクト情報への参照ポインタ
*/
-static void invest_curse_to_fixed_artifact(const ArtifactType &a_ref, ObjectType *o_ptr)
+static void invest_curse_to_fixed_artifact(const ArtifactType &a_ref, ItemEntity *o_ptr)
{
if (!a_ref.cost) {
set_bits(o_ptr->ident, IDENT_BROKEN);
* @param o_ptr 生成に割り当てたいオブジェクトの構造体参照ポインタ
* @return 適用したアーティファクト情報への参照ポインタ
*/
-void apply_artifact(PlayerType *player_ptr, ObjectType *o_ptr)
+void apply_artifact(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto &a_ref = artifacts_info.at(o_ptr->fixed_artifact_idx);
o_ptr->pval = a_ref.pval;
return true;
}
- ObjectType forge;
+ ItemEntity forge;
auto q_ptr = &forge;
q_ptr->prep(bi_id);
q_ptr->fixed_artifact_idx = a_idx;
* This routine should only be called by "apply_magic()"\n
* Note -- see "make_artifact_special()" and "apply_magic()"\n
*/
-bool make_artifact(PlayerType *player_ptr, ObjectType *o_ptr)
+bool make_artifact(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto floor_ptr = player_ptr->current_floor_ptr;
if (floor_ptr->dun_level == 0) {
*\n
* Note -- see "make_artifact()" and "apply_magic()"\n
*/
-bool make_artifact_special(PlayerType *player_ptr, ObjectType *o_ptr)
+bool make_artifact_special(PlayerType *player_ptr, ItemEntity *o_ptr)
{
/*! @note 地上ではキャンセルする / No artifacts in the town */
auto floor_ptr = player_ptr->current_floor_ptr;
enum class FixedArtifactId : short;
class ArtifactType;
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool create_named_art(PlayerType *player_ptr, FixedArtifactId a_idx, POSITION y, POSITION x);
-bool make_artifact(PlayerType *player_ptr, ObjectType *o_ptr);
-void apply_artifact(PlayerType *player_ptr, ObjectType *o_ptr);
-bool make_artifact_special(PlayerType *player_ptr, ObjectType *o_ptr);
+bool make_artifact(PlayerType *player_ptr, ItemEntity *o_ptr);
+void apply_artifact(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool make_artifact_special(PlayerType *player_ptr, ItemEntity *o_ptr);
* @details バイアスが無い場合、一部のバイアスの確率によっては one_ability() に処理が移行する。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void give_activation_power(ObjectType *o_ptr)
+void give_activation_power(ItemEntity *o_ptr)
{
RandomArtActType type = RandomArtActType::NONE;
int chance = 0;
* @brief ランダムアーティファクトの発動実装ヘッダ
*/
-class ObjectType;
-void give_activation_power(ObjectType *o_ptr);
+class ItemEntity;
+void give_activation_power(ItemEntity *o_ptr);
#include <sstream>
#include <string_view>
-static void pval_subtraction(ObjectType *o_ptr)
+static void pval_subtraction(ItemEntity *o_ptr)
{
if (o_ptr->pval > 0) {
o_ptr->pval = 0 - (o_ptr->pval + randint1(4));
}
}
-static void add_negative_flags(ObjectType *o_ptr)
+static void add_negative_flags(ItemEntity *o_ptr)
{
if (one_in_(4)) {
o_ptr->curse_flags.set(CurseTraitType::PERMA_CURSE);
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void curse_artifact(PlayerType *player_ptr, ObjectType *o_ptr)
+void curse_artifact(PlayerType *player_ptr, ItemEntity *o_ptr)
{
pval_subtraction(o_ptr);
o_ptr->curse_flags.set({ CurseTraitType::HEAVY_CURSE, CurseTraitType::CURSED });
* @details 確率によって、シンダリン銘、漢字銘 (anameからランダム)、固定名のいずれか一つが与えられる.
* シンダリン銘：10%、漢字銘18%、固定銘72% (固定銘が尽きていたら漢字銘になることもある).
*/
-void get_random_name(ObjectType *o_ptr, char *return_name, bool armour, int power)
+void get_random_name(ItemEntity *o_ptr, char *return_name, bool armour, int power)
{
const auto prob = randint1(100);
constexpr auto chance_sindarin = 10;
}
/*対邪平均ダメージの計算処理*/
-static int calc_arm_avgdamage(PlayerType *player_ptr, ObjectType *o_ptr)
+static int calc_arm_avgdamage(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto flgs = object_flags(o_ptr);
int base, forced, vorpal;
return dam;
}
-bool has_extreme_damage_rate(PlayerType *player_ptr, ObjectType *o_ptr)
+bool has_extreme_damage_rate(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto flgs = object_flags(o_ptr);
if (flgs.has(TR_VAMPIRIC)) {
* @brief ランダムアーティファクトのバイアス付加処理ヘッダ
*/
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void curse_artifact(PlayerType *player_ptr, ObjectType *o_ptr);
-void get_random_name(ObjectType *o_ptr, char *return_name, bool armour, int power);
-bool has_extreme_damage_rate(PlayerType *player_ptr, ObjectType *o_ptr);
+void curse_artifact(PlayerType *player_ptr, ItemEntity *o_ptr);
+void get_random_name(ItemEntity *o_ptr, char *return_name, bool armour, int power);
+bool has_extreme_damage_rate(PlayerType *player_ptr, ItemEntity *o_ptr);
#include "wizard/wizard-messages.h"
#include "world/world.h"
-static bool weakening_artifact(ObjectType *o_ptr)
+static bool weakening_artifact(ItemEntity *o_ptr)
{
const auto k_idx = lookup_baseitem_id({ o_ptr->tval, o_ptr->sval });
auto *k_ptr = &baseitems_info[k_idx];
return false;
}
-static void set_artifact_bias(PlayerType *player_ptr, ObjectType *o_ptr, int *warrior_artifact_bias)
+static void set_artifact_bias(PlayerType *player_ptr, ItemEntity *o_ptr, int *warrior_artifact_bias)
{
switch (player_ptr->pclass) {
case PlayerClassType::WARRIOR:
}
}
-static void decide_warrior_bias(PlayerType *player_ptr, ObjectType *o_ptr, const bool a_scroll)
+static void decide_warrior_bias(PlayerType *player_ptr, ItemEntity *o_ptr, const bool a_scroll)
{
int warrior_artifact_bias = 0;
if (a_scroll && one_in_(4)) {
}
}
-static bool decide_random_art_cursed(const bool a_scroll, ObjectType *o_ptr)
+static bool decide_random_art_cursed(const bool a_scroll, ItemEntity *o_ptr)
{
constexpr auto chance_cursed = 13;
if (!a_scroll && one_in_(chance_cursed)) {
return powers;
}
-static void invest_powers(PlayerType *player_ptr, ObjectType *o_ptr, int *powers, bool *has_pval, const bool a_cursed)
+static void invest_powers(PlayerType *player_ptr, ItemEntity *o_ptr, int *powers, bool *has_pval, const bool a_cursed)
{
int max_type = o_ptr->is_weapon_ammo() ? 7 : 5;
while ((*powers)--) {
};
}
-static void strengthen_pval(ObjectType *o_ptr)
+static void strengthen_pval(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BLOWS)) {
o_ptr->pval = randint1(2);
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr ランダムアーティファクトを示すアイテムへの参照ポインタ
*/
-static void invest_positive_modified_value(ObjectType *o_ptr)
+static void invest_positive_modified_value(ItemEntity *o_ptr)
{
if (o_ptr->is_armour()) {
o_ptr->to_a += randint1(o_ptr->to_a > 19 ? 1 : 20 - o_ptr->to_a);
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr ランダムアーティファクトを示すアイテムへの参照ポインタ
*/
-static void invest_negative_modified_value(ObjectType *o_ptr)
+static void invest_negative_modified_value(ItemEntity *o_ptr)
{
if (!o_ptr->is_armour()) {
return;
}
}
-static void reset_flags_poison_needle(ObjectType *o_ptr)
+static void reset_flags_poison_needle(ItemEntity *o_ptr)
{
if ((o_ptr->tval != ItemKindType::SWORD) || (o_ptr->sval != SV_POISON_NEEDLE)) {
return;
o_ptr->art_flags.reset(TR_BRAND_COLD);
}
-static int decide_random_art_power_level(ObjectType *o_ptr, const bool a_cursed, const int total_flags)
+static int decide_random_art_power_level(ItemEntity *o_ptr, const bool a_cursed, const int total_flags)
{
if (o_ptr->is_weapon_ammo()) {
if (a_cursed) {
return 3;
}
-static void name_unnatural_random_artifact(PlayerType *player_ptr, ObjectType *o_ptr, const bool a_scroll, const int power_level, GAME_TEXT *new_name)
+static void name_unnatural_random_artifact(PlayerType *player_ptr, ItemEntity *o_ptr, const bool a_scroll, const int power_level, GAME_TEXT *new_name)
{
if (!a_scroll) {
get_random_name(o_ptr, new_name, o_ptr->is_armour(), power_level);
}
static void generate_unnatural_random_artifact(
- PlayerType *player_ptr, ObjectType *o_ptr, const bool a_scroll, const int power_level, const int max_powers, const int total_flags)
+ PlayerType *player_ptr, ItemEntity *o_ptr, const bool a_scroll, const int power_level, const int max_powers, const int total_flags)
{
GAME_TEXT new_name[1024];
strcpy(new_name, "");
* @param a_scroll アーティファクト生成の巻物上の処理。呪いのアーティファクトが生成対象外となる。
* @return 常にTRUE(1)を返す
*/
-bool become_random_artifact(PlayerType *player_ptr, ObjectType *o_ptr, bool a_scroll)
+bool become_random_artifact(PlayerType *player_ptr, ItemEntity *o_ptr, bool a_scroll)
{
o_ptr->artifact_bias = 0;
o_ptr->fixed_artifact_idx = FixedArtifactId::NONE;
* @brief ランダムアーティファクトの生成メインヘッダ / Artifact code
*/
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool become_random_artifact(PlayerType *player_ptr, ObjectType *o_ptr, bool a_scroll);
+bool become_random_artifact(PlayerType *player_ptr, ItemEntity *o_ptr, bool a_scroll);
#include "system/player-type-definition.h"
#include "util/bit-flags-calculator.h"
-static bool invest_misc_ranger(ObjectType *o_ptr)
+static bool invest_misc_ranger(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_CON)) {
return false;
return one_in_(2);
}
-static bool invest_misc_strength(ObjectType *o_ptr)
+static bool invest_misc_strength(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_STR)) {
return false;
return one_in_(2);
}
-static bool invest_misc_wisdom(ObjectType *o_ptr)
+static bool invest_misc_wisdom(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_WIS)) {
return false;
return one_in_(2);
}
-static bool invest_misc_intelligence(ObjectType *o_ptr)
+static bool invest_misc_intelligence(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_INT)) {
return false;
return one_in_(2);
}
-static bool invest_misc_dexterity(ObjectType *o_ptr)
+static bool invest_misc_dexterity(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_DEX)) {
return false;
return one_in_(2);
}
-static bool invest_misc_constitution(ObjectType *o_ptr)
+static bool invest_misc_constitution(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_CON)) {
return false;
return one_in_(2);
}
-static bool invest_misc_charisma(ObjectType *o_ptr)
+static bool invest_misc_charisma(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SUST_CHR)) {
return false;
return one_in_(2);
}
-static bool invest_misc_chaos(ObjectType *o_ptr)
+static bool invest_misc_chaos(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_TELEPORT)) {
return false;
return one_in_(2);
}
-static bool invest_misc_res_curse(ObjectType *o_ptr)
+static bool invest_misc_res_curse(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_RES_CURSE)) {
return false;
* @param o_ptr 対象のオブジェクト構造体への参照ポインタ
* @return 処理続行ならFALSE、打ち切るならTRUE
*/
-static bool switch_misc_bias(ObjectType *o_ptr)
+static bool switch_misc_bias(ItemEntity *o_ptr)
{
switch (o_ptr->artifact_bias) {
case BIAS_RANGER:
}
}
-static void invest_misc_hit_dice(ObjectType *o_ptr)
+static void invest_misc_hit_dice(ItemEntity *o_ptr)
{
o_ptr->art_flags.set(TR_SHOW_MODS);
HIT_PROB bonus_h = 4 + (HIT_PROB)randint1(11);
o_ptr->to_d += bonus_d;
}
-static void invest_misc_string_esp(ObjectType *o_ptr)
+static void invest_misc_string_esp(ItemEntity *o_ptr)
{
switch (randint1(3)) {
case 1:
}
}
-static void switch_investment_weak_esps(ObjectType *o_ptr, const int *idx, const int n)
+static void switch_investment_weak_esps(ItemEntity *o_ptr, const int *idx, const int n)
{
switch (idx[n]) {
case 1:
}
}
-static void invest_misc_weak_esps(ObjectType *o_ptr)
+static void invest_misc_weak_esps(ItemEntity *o_ptr)
{
int idx[3];
idx[0] = randint1(10);
* @attention オブジェクトのtval、svalに依存したハードコーディング処理がある。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void random_misc(PlayerType *player_ptr, ObjectType *o_ptr)
+void random_misc(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (switch_misc_bias(o_ptr)) {
return;
* @brief ランダムアーティファクト生成のその他特性バイアス付けヘッダ / Artifact code
*/
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void random_misc(PlayerType *player_ptr, ObjectType *o_ptr);
+void random_misc(PlayerType *player_ptr, ItemEntity *o_ptr);
#include "system/object-type-definition.h"
#include "util/bit-flags-calculator.h"
-static bool random_art_bias_strength(ObjectType *o_ptr)
+static bool random_art_bias_strength(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_STR)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_intelligence(ObjectType *o_ptr)
+static bool random_art_bias_intelligence(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_INT)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_wisdom(ObjectType *o_ptr)
+static bool random_art_bias_wisdom(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_WIS)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_dexterity(ObjectType *o_ptr)
+static bool random_art_bias_dexterity(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_DEX)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_constitution(ObjectType *o_ptr)
+static bool random_art_bias_constitution(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_CON)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_charisma(ObjectType *o_ptr)
+static bool random_art_bias_charisma(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_CHR)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_magic_mastery(ObjectType *o_ptr)
+static bool random_art_bias_magic_mastery(ItemEntity *o_ptr)
{
if ((o_ptr->tval != ItemKindType::GLOVES) || o_ptr->art_flags.has(TR_MAGIC_MASTERY)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_stealth(ObjectType *o_ptr)
+static bool random_art_bias_stealth(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_STEALTH)) {
return false;
return one_in_(2);
}
-static bool random_art_bias_search(ObjectType *o_ptr)
+static bool random_art_bias_search(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SEARCH)) {
return false;
return one_in_(2);
}
-static bool switch_random_art_bias(ObjectType *o_ptr)
+static bool switch_random_art_bias(ItemEntity *o_ptr)
{
switch (o_ptr->artifact_bias) {
case BIAS_WARRIOR:
}
}
-static bool random_art_bias_decrease_mana(ObjectType *o_ptr)
+static bool random_art_bias_decrease_mana(ItemEntity *o_ptr)
{
if (((o_ptr->artifact_bias != BIAS_MAGE) && (o_ptr->artifact_bias != BIAS_PRIESTLY)) || (o_ptr->tval != ItemKindType::SOFT_ARMOR) || (o_ptr->sval != SV_ROBE) || o_ptr->art_flags.has(TR_DEC_MANA) || !one_in_(3)) {
return false;
* @attention オブジェクトのtval、svalに依存したハードコーディング処理がある。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void random_plus(ObjectType *o_ptr)
+void random_plus(ItemEntity *o_ptr)
{
if (switch_random_art_bias(o_ptr) || random_art_bias_decrease_mana(o_ptr)) {
return;
* @brief ランダムアーティファクトのpval付加処理ヘッダ
*/
-class ObjectType;
-void random_plus(ObjectType *o_ptr);
+class ItemEntity;
+void random_plus(ItemEntity *o_ptr);
* @param tr_sh_flag 付与するフラグ (TR_SH_*)
* @return 続くフラグ付与の処理を打ち切る場合 true を返す
*/
-static bool random_art_aura(ObjectType *o_ptr, tr_type tr_sh_flag)
+static bool random_art_aura(ItemEntity *o_ptr, tr_type tr_sh_flag)
{
if ((o_ptr->tval < ItemKindType::CLOAK) || (o_ptr->tval > ItemKindType::HARD_ARMOR) || o_ptr->art_flags.has(tr_sh_flag)) {
return false;
* @details フラグの付与には 1/chance_bias の確率を通過する必要がある.
* 更に、1/chance_immunity の確率を通過しなければ他の免疫フラグは消去される.
*/
-static bool random_art_immunity(ObjectType *o_ptr, tr_type tr_im_flag)
+static bool random_art_immunity(ItemEntity *o_ptr, tr_type tr_im_flag)
{
constexpr auto chance_bias = 20;
if (!one_in_(chance_bias) || o_ptr->art_flags.has(tr_im_flag)) {
* @param skip true の場合このフラグは付与せず処理を終了し、続くフラグ付与の処理を継続する
* @return 続くフラグ付与の処理を打ち切る場合 true を返す
*/
-static bool random_art_resistance(ObjectType *o_ptr, tr_type tr_res_flag, bool skip = false)
+static bool random_art_resistance(ItemEntity *o_ptr, tr_type tr_res_flag, bool skip = false)
{
if (skip || o_ptr->art_flags.has(tr_res_flag)) {
return false;
return one_in_(2);
}
-static bool switch_random_art_resistance(ObjectType *o_ptr)
+static bool switch_random_art_resistance(ItemEntity *o_ptr)
{
switch (o_ptr->artifact_bias) {
case BIAS_ACID:
}
/* 一定確率で再試行する */
-static void set_weird_bias_acid(ObjectType *o_ptr)
+static void set_weird_bias_acid(ItemEntity *o_ptr)
{
if (!one_in_(CHANCE_STRENGTHENING)) {
random_resistance(o_ptr);
}
/* 一定確率で再試行する */
-static void set_weird_bias_elec(ObjectType *o_ptr)
+static void set_weird_bias_elec(ItemEntity *o_ptr)
{
if (!one_in_(CHANCE_STRENGTHENING)) {
random_resistance(o_ptr);
}
/* 一定確率で再試行する */
-static void set_weird_bias_cold(ObjectType *o_ptr)
+static void set_weird_bias_cold(ItemEntity *o_ptr)
{
if (!one_in_(CHANCE_STRENGTHENING)) {
random_resistance(o_ptr);
}
/* 一定確率で再試行する */
-static void set_weird_bias_fire(ObjectType *o_ptr)
+static void set_weird_bias_fire(ItemEntity *o_ptr)
{
if (!one_in_(CHANCE_STRENGTHENING)) {
random_resistance(o_ptr);
}
}
-static void set_bias_pois(ObjectType *o_ptr)
+static void set_bias_pois(ItemEntity *o_ptr)
{
o_ptr->art_flags.set(TR_RES_POIS);
if (!o_ptr->artifact_bias && !one_in_(4)) {
}
/* 一定確率で再試行する */
-static void set_weird_bias_aura_elec(ObjectType *o_ptr)
+static void set_weird_bias_aura_elec(ItemEntity *o_ptr)
{
if (o_ptr->tval >= ItemKindType::CLOAK && o_ptr->tval <= ItemKindType::HARD_ARMOR) {
o_ptr->art_flags.set(TR_SH_ELEC);
}
/* 一定確率で再試行する */
-static void set_weird_bias_aura_fire(ObjectType *o_ptr)
+static void set_weird_bias_aura_fire(ItemEntity *o_ptr)
{
if (o_ptr->tval >= ItemKindType::CLOAK && o_ptr->tval <= ItemKindType::HARD_ARMOR) {
o_ptr->art_flags.set(TR_SH_FIRE);
}
/* 一定確率で再試行する */
-static void set_weird_bias_reflection(ObjectType *o_ptr)
+static void set_weird_bias_reflection(ItemEntity *o_ptr)
{
if (o_ptr->tval == ItemKindType::SHIELD || o_ptr->tval == ItemKindType::CLOAK || o_ptr->tval == ItemKindType::HELM || o_ptr->tval == ItemKindType::HARD_ARMOR) {
o_ptr->art_flags.set(TR_REFLECT);
}
/* 一定確率で再試行する */
-static void set_weird_bias_aura_cold(ObjectType *o_ptr)
+static void set_weird_bias_aura_cold(ItemEntity *o_ptr)
{
if (o_ptr->tval >= ItemKindType::CLOAK && o_ptr->tval <= ItemKindType::HARD_ARMOR) {
o_ptr->art_flags.set(TR_SH_COLD);
* @attention オブジェクトのtval、svalに依存したハードコーディング処理がある。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void random_resistance(ObjectType *o_ptr)
+void random_resistance(ItemEntity *o_ptr)
{
if (switch_random_art_resistance(o_ptr)) {
return;
* @brief ランダムアーティファクトの耐性付加処理ヘッダ
*/
-class ObjectType;
-void random_resistance(ObjectType *o_ptr);
+class ItemEntity;
+void random_resistance(ItemEntity *o_ptr);
#include "system/object-type-definition.h"
#include "util/bit-flags-calculator.h"
-static bool random_art_slay_bow(ObjectType *o_ptr)
+static bool random_art_slay_bow(ItemEntity *o_ptr)
{
if (o_ptr->tval != ItemKindType::BOW) {
return false;
}
}
-static bool random_art_slay_chaos(ObjectType *o_ptr)
+static bool random_art_slay_chaos(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_CHAOTIC)) {
return false;
return one_in_(2);
}
-static bool random_art_brand_magical(ObjectType *o_ptr)
+static bool random_art_brand_magical(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_MAGIC)) {
return false;
return one_in_(3);
}
-static bool random_art_slay_vampiric(ObjectType *o_ptr)
+static bool random_art_slay_vampiric(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_VAMPIRIC)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_brand_acid(ObjectType *o_ptr)
+static bool random_art_slay_brand_acid(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_ACID)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_brand_elec(ObjectType *o_ptr)
+static bool random_art_slay_brand_elec(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_ELEC)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_brand_fire(ObjectType *o_ptr)
+static bool random_art_slay_brand_fire(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_FIRE)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_brand_cold(ObjectType *o_ptr)
+static bool random_art_slay_brand_cold(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_COLD)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_brand_pois(ObjectType *o_ptr)
+static bool random_art_slay_brand_pois(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_BRAND_POIS) || one_in_(2)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_animal(ObjectType *o_ptr)
+static bool random_art_slay_animal(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SLAY_ANIMAL)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_evil(ObjectType *o_ptr)
+static bool random_art_slay_evil(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SLAY_EVIL)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_undead(ObjectType *o_ptr)
+static bool random_art_slay_undead(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SLAY_UNDEAD)) {
return false;
return one_in_(2);
}
-static bool random_art_slay_demon(ObjectType *o_ptr)
+static bool random_art_slay_demon(ItemEntity *o_ptr)
{
if (o_ptr->art_flags.has(TR_SLAY_DEMON)) {
return false;
return one_in_(2);
}
-static bool switch_random_art_slay(ObjectType *o_ptr)
+static bool switch_random_art_slay(ItemEntity *o_ptr)
{
switch (o_ptr->artifact_bias) {
case BIAS_CHAOS:
* @attention オブジェクトのtval、svalに依存したハードコーディング処理がある。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void random_slay(ObjectType *o_ptr)
+void random_slay(ItemEntity *o_ptr)
{
if (random_art_slay_bow(o_ptr) || switch_random_art_slay(o_ptr)) {
return;
* @brief ランダムアーティファクトのスレイ付加処理ヘッダ
*/
-class ObjectType;
-void random_slay(ObjectType *o_ptr);
+class ItemEntity;
+void random_slay(ItemEntity *o_ptr);
* @param o_ptr アイテムへの参照ポインタ
* @return 特別なクラス、かつそのクラス特有のアイテムであればFALSE、それ以外はTRUE
*/
-static bool is_leave_special_item(PlayerType *player_ptr, ObjectType *o_ptr)
+static bool is_leave_special_item(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!leave_special) {
return true;
/*!
* @brief Automatically destroy items in this grid.
*/
-static bool is_opt_confirm_destroy(PlayerType *player_ptr, ObjectType *o_ptr)
+static bool is_opt_confirm_destroy(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!destroy_items) {
return false;
return true;
}
-void auto_destroy_item(PlayerType *player_ptr, ObjectType *o_ptr, int autopick_idx)
+void auto_destroy_item(PlayerType *player_ptr, ItemEntity *o_ptr, int autopick_idx)
{
bool destroy = false;
if (is_opt_confirm_destroy(player_ptr, o_ptr)) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void auto_destroy_item(PlayerType *player_ptr, ObjectType *o_ptr, int autopick_idx);
+void auto_destroy_item(PlayerType *player_ptr, ItemEntity *o_ptr, int autopick_idx);
/*!
* @brief Get auto-picker entry from o_ptr.
*/
-void autopick_entry_from_object(PlayerType *player_ptr, autopick_type *entry, ObjectType *o_ptr)
+void autopick_entry_from_object(PlayerType *player_ptr, autopick_type *entry, ItemEntity *o_ptr)
{
/* Assume that object name is to be added */
bool name = true;
{
concptr q = _("どのアイテムを登録しますか? ", "Enter which item? ");
concptr s = _("アイテムを持っていない。", "You have nothing to enter.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, nullptr, q, s, USE_INVEN | USE_FLOOR | USE_EQUIP);
if (!o_ptr) {
return false;
#include "system/angband.h"
struct autopick_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool autopick_new_entry(autopick_type *entry, concptr str, bool allow_default);
-void autopick_entry_from_object(PlayerType *player_ptr, autopick_type *entry, ObjectType *o_ptr);
+void autopick_entry_from_object(PlayerType *player_ptr, autopick_type *entry, ItemEntity *o_ptr);
concptr autopick_line_from_entry(autopick_type *entry);
concptr autopick_line_from_entry_kill(autopick_type *entry);
bool entry_from_choosed_object(PlayerType *player_ptr, autopick_type *entry);
* A function for Auto-picker/destroyer
* Examine whether the object matches to the list of keywords or not.
*/
-int find_autopick_list(PlayerType *player_ptr, ObjectType *o_ptr)
+int find_autopick_list(PlayerType *player_ptr, ItemEntity *o_ptr)
{
GAME_TEXT o_name[MAX_NLEN];
if (o_ptr->tval == ItemKindType::GOLD) {
/*!
* @brief Choose an item for search
*/
-bool get_object_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp)
+bool get_object_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp)
{
concptr q = _("どのアイテムを検索しますか? ", "Enter which item? ");
concptr s = _("アイテムを持っていない。", "You have nothing to enter.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, nullptr, q, s, USE_INVEN | USE_FLOOR | USE_EQUIP);
if (!o_ptr) {
return false;
/*!
* @brief Prepare for search by destroyed object
*/
-bool get_destroyed_object_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp)
+bool get_destroyed_object_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp)
{
if (!autopick_last_destroyed_object.k_idx) {
return false;
* TERM_YELLOW : Overwrite mode
* TERM_WHITE : Insert mode
*/
-byte get_string_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp)
+byte get_string_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp)
{
byte color = TERM_YELLOW;
char buf[MAX_NLEN + 20];
/*!
* @brief Search next line matches for o_ptr
*/
-void search_for_object(PlayerType *player_ptr, text_body_type *tb, ObjectType *o_ptr, bool forward)
+void search_for_object(PlayerType *player_ptr, text_body_type *tb, ItemEntity *o_ptr, bool forward)
{
autopick_type an_entry, *entry = &an_entry;
GAME_TEXT o_name[MAX_NLEN];
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
struct text_body_type;
-int find_autopick_list(PlayerType *player_ptr, ObjectType *o_ptr);
-bool get_object_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp);
-bool get_destroyed_object_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp);
-byte get_string_for_search(PlayerType *player_ptr, ObjectType **o_handle, concptr *search_strp);
-void search_for_object(PlayerType *player_ptr, text_body_type *tb, ObjectType *o_ptr, bool forward);
+int find_autopick_list(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool get_object_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp);
+bool get_destroyed_object_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp);
+byte get_string_for_search(PlayerType *player_ptr, ItemEntity **o_handle, concptr *search_strp);
+void search_for_object(PlayerType *player_ptr, text_body_type *tb, ItemEntity *o_ptr, bool forward);
void search_for_string(text_body_type *tb, concptr search_str, bool forward);
/*!
* @brief A function for Auto-picker/destroyer Examine whether the object matches to the entry
*/
-bool is_autopick_match(PlayerType *player_ptr, ObjectType *o_ptr, autopick_type *entry, concptr o_name)
+bool is_autopick_match(PlayerType *player_ptr, ItemEntity *o_ptr, autopick_type *entry, concptr o_name)
{
concptr ptr = entry->name.data();
if (IS_FLG(FLG_UNAWARE) && o_ptr->is_aware()) {
#include "system/angband.h"
struct autopick_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool is_autopick_match(PlayerType *player_ptr, ObjectType *o_ptr, autopick_type *entry, concptr o_name);
+bool is_autopick_match(PlayerType *player_ptr, ItemEntity *o_ptr, autopick_type *entry, concptr o_name);
/*!
* @brief Automatically register an auto-destroy preference line
*/
-bool autopick_autoregister(PlayerType *player_ptr, ObjectType *o_ptr)
+bool autopick_autoregister(PlayerType *player_ptr, ItemEntity *o_ptr)
{
autopick_type an_entry, *entry = &an_entry;
int autopick_registered = find_autopick_list(player_ptr, o_ptr);
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool autopick_autoregister(PlayerType *player_ptr, ObjectType *o_ptr);
+bool autopick_autoregister(PlayerType *player_ptr, ItemEntity *o_ptr);
* When always_pickup is 'yes', we disable auto-destroyer function of
* auto-picker/destroyer, and do only easy-auto-destroyer.
*/
-ObjectType autopick_last_destroyed_object;
+ItemEntity autopick_last_destroyed_object;
/*!
* @brief Free memory of lines_list.
/*!
* @brief Auto inscription
*/
-void auto_inscribe_item(PlayerType *player_ptr, ObjectType *o_ptr, int idx)
+void auto_inscribe_item(PlayerType *player_ptr, ItemEntity *o_ptr, int idx)
{
if (idx < 0 || autopick_list[idx].insc.empty()) {
return;
/*
* Data struct for text editor
*/
-class ObjectType;
+class ItemEntity;
;
struct text_body_type {
int wid, hgt;
int mx, my;
byte mark;
- ObjectType *search_o_ptr;
+ ItemEntity *search_o_ptr;
concptr search_str;
concptr last_destroyed;
* List for auto-picker/destroyer entries
*/
extern std::vector<autopick_type> autopick_list;
-extern ObjectType autopick_last_destroyed_object;
+extern ItemEntity autopick_last_destroyed_object;
class PlayerType;
void free_text_lines(std::vector<concptr> &lines_list);
int get_com_id(char key);
-void auto_inscribe_item(PlayerType *player_ptr, ObjectType *o_ptr, int idx);
+void auto_inscribe_item(PlayerType *player_ptr, ItemEntity *o_ptr, int idx);
int count_line(text_body_type *tb);
/*!
*/
static void autopick_delayed_alter_aux(PlayerType *player_ptr, INVENTORY_IDX item)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = ref_item(player_ptr, item);
if (o_ptr->k_idx == 0 || !(o_ptr->marked & OM_AUTODESTROY)) {
*/
void autopick_alter_item(PlayerType *player_ptr, INVENTORY_IDX item, bool destroy)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = ref_item(player_ptr, item);
int idx = find_autopick_list(player_ptr, o_ptr);
auto_inscribe_item(player_ptr, o_ptr, idx);
// TODO: キャラ作成からゲーム開始までに current_floor_ptr を参照しなければならない処理は今後整理して外す。
player_ptr->current_floor_ptr = &floor_info;
//! @todo std::make_shared の配列対応版は C++20 から
- player_ptr->inventory_list = std::shared_ptr<ObjectType[]>{ new ObjectType[INVEN_TOTAL] };
+ player_ptr->inventory_list = std::shared_ptr<ItemEntity[]>{ new ItemEntity[INVEN_TOTAL] };
for (int i = 0; i < 4; i++) {
strcpy(player_ptr->history[i], "");
}
*/
void wield_all(PlayerType *player_ptr)
{
- ObjectType ObjectType_body;
+ ItemEntity ObjectType_body;
for (INVENTORY_IDX item = INVEN_PACK - 1; item >= 0; item--) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[item];
if (!o_ptr->k_idx) {
continue;
continue;
}
- ObjectType *i_ptr;
+ ItemEntity *i_ptr;
i_ptr = &ObjectType_body;
i_ptr->copy_from(o_ptr);
i_ptr->number = 1;
* @details アイテムを既知のものとした上でwield_all()関数により装備させる。
* @param o_ptr 処理したいオブジェクト構造体の参照ポインタ
*/
-void add_outfit(PlayerType *player_ptr, ObjectType *o_ptr)
+void add_outfit(PlayerType *player_ptr, ItemEntity *o_ptr)
{
object_aware(player_ptr, o_ptr);
object_known(o_ptr);
wield_all(player_ptr);
}
-static void decide_initial_items(PlayerType *player_ptr, ObjectType *q_ptr)
+static void decide_initial_items(PlayerType *player_ptr, ItemEntity *q_ptr)
{
switch (player_ptr->prace) {
case PlayerRaceType::VAMPIRE:
*/
void player_outfit(PlayerType *player_ptr)
{
- ObjectType *q_ptr;
- ObjectType forge;
+ ItemEntity *q_ptr;
+ ItemEntity forge;
q_ptr = &forge;
decide_initial_items(player_ptr, q_ptr);
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
void wield_all(PlayerType *player_ptr);
-void add_outfit(PlayerType *player_ptr, ObjectType *o_ptr);
+void add_outfit(PlayerType *player_ptr, ItemEntity *o_ptr);
void player_outfit(PlayerType *player_ptr);
OBJECT_IDX item;
int i, j;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
concptr q, s;
bool gain = false;
void do_cmd_fire(PlayerType *player_ptr, SPELL_IDX snipe_type)
{
OBJECT_IDX item;
- ObjectType *j_ptr, *ammo_ptr;
+ ItemEntity *j_ptr, *ammo_ptr;
if (player_ptr->wild_mode) {
return;
}
SPELL_IDX spells[64];
char temp[62 * 4];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
concptr q, s;
/* Spells of realm2 will have an increment of +32 */
SPELL_IDX spell = -1;
concptr p = spell_category_name(mp_ptr->spell_book);
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
concptr q, s;
if (!player_ptr->realm1) {
MANA_POINT need_mana;
concptr prayer;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
const magic_type *s_ptr;
concptr q, s;
bcost = compare_weapons(player_ptr, bcost);
break;
case BACT_ENCHANT_WEAPON:
- enchant_item(player_ptr, bcost, 1, 1, 0, FuncItemTester(&ObjectType::allow_enchant_melee_weapon));
+ enchant_item(player_ptr, bcost, 1, 1, 0, FuncItemTester(&ItemEntity::allow_enchant_melee_weapon));
break;
case BACT_ENCHANT_ARMOR:
- enchant_item(player_ptr, bcost, 0, 0, 1, FuncItemTester(&ObjectType::is_armour));
+ enchant_item(player_ptr, bcost, 0, 0, 1, FuncItemTester(&ItemEntity::is_armour));
break;
case BACT_RECHARGE:
building_recharge(player_ptr);
paid = restore_all_status(player_ptr);
break;
case BACT_ENCHANT_ARROWS:
- enchant_item(player_ptr, bcost, 1, 1, 0, FuncItemTester(&ObjectType::is_ammo));
+ enchant_item(player_ptr, bcost, 1, 1, 0, FuncItemTester(&ItemEntity::is_ammo));
break;
case BACT_ENCHANT_BOW:
enchant_item(player_ptr, bcost, 1, 1, 0, TvalItemTester(ItemKindType::BOW));
QUANTITY amt;
QUANTITY old_number;
bool force;
- ObjectType *o_ptr;
- ObjectType *q_ptr;
+ ItemEntity *o_ptr;
+ ItemEntity *q_ptr;
GAME_TEXT o_name[MAX_NLEN];
char out_val[MAX_NLEN + 40];
};
-static destroy_type *initialize_destroy_type(destroy_type *destroy_ptr, ObjectType *o_ptr)
+static destroy_type *initialize_destroy_type(destroy_type *destroy_ptr, ItemEntity *o_ptr)
{
destroy_ptr->amt = 1;
destroy_ptr->force = false;
{
PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
- ObjectType forge;
+ ItemEntity forge;
destroy_type tmp_destroy;
destroy_type *destroy_ptr = initialize_destroy_type(&tmp_destroy, &forge);
if (command_arg > 0) {
* @param o_ptr 食べるオブジェクト
* @return 鑑定されるならTRUE、されないならFALSE
*/
-bool exe_eat_food_type_object(PlayerType *player_ptr, ObjectType *o_ptr)
+bool exe_eat_food_type_object(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (o_ptr->tval != ItemKindType::FOOD) {
return false;
* @param item オブジェクトのインベントリ番号
* @return 食べようとしたらTRUE、しなかったらFALSE
*/
-bool exe_eat_charge_of_magic_device(PlayerType *player_ptr, ObjectType *o_ptr, INVENTORY_IDX item)
+bool exe_eat_charge_of_magic_device(PlayerType *player_ptr, ItemEntity *o_ptr, INVENTORY_IDX item)
{
if (o_ptr->tval != ItemKindType::STAFF && o_ptr->tval != ItemKindType::WAND) {
return false;
/* XXX Hack -- unstack if necessary */
if (o_ptr->tval == ItemKindType::STAFF && (item >= 0) && (o_ptr->number > 1)) {
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->copy_from(o_ptr);
if (PlayerRace(player_ptr).equals(PlayerRaceType::SKELETON)) {
if (!((o_ptr->sval == SV_FOOD_WAYBREAD) || (o_ptr->sval < SV_FOOD_BISCUIT))) {
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
msg_print(_("食べ物がアゴを素通りして落ちた！", "The food falls through your jaws!"));
/*!
* @brief 装備時にアイテムを呪う処理
*/
-static void do_curse_on_equip(OBJECT_IDX slot, ObjectType *o_ptr, PlayerType *player_ptr)
+static void do_curse_on_equip(OBJECT_IDX slot, ItemEntity *o_ptr, PlayerType *player_ptr)
{
if (set_anubis_and_chariot(player_ptr) && ((slot == INVEN_MAIN_HAND) || (slot == INVEN_SUB_HAND))) {
- ObjectType *anubis = &(player_ptr->inventory_list[INVEN_MAIN_HAND]);
- ObjectType *chariot = &(player_ptr->inventory_list[INVEN_SUB_HAND]);
+ ItemEntity *anubis = &(player_ptr->inventory_list[INVEN_MAIN_HAND]);
+ ItemEntity *chariot = &(player_ptr->inventory_list[INVEN_SUB_HAND]);
anubis->curse_flags.set(CurseTraitType::PERSISTENT_CURSE);
anubis->curse_flags.set(CurseTraitType::HEAVY_CURSE);
void do_cmd_wield(PlayerType *player_ptr)
{
OBJECT_IDX item, slot;
- ObjectType forge;
- ObjectType *q_ptr;
- ObjectType *o_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
+ ItemEntity *o_ptr;
concptr act;
GAME_TEXT o_name[MAX_NLEN];
OBJECT_IDX need_switch_wielding = 0;
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
q = _("どちらの武器と取り替えますか?", "Replace which weapon? ");
s = _("おっと。", "Oops.");
- if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ObjectType::is_melee_weapon))) {
+ if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ItemEntity::is_melee_weapon))) {
return;
}
((o_ptr->tval == ItemKindType::CAPTURE) || (!o_ptr_mh->is_melee_weapon() && !o_ptr_sh->is_melee_weapon()))) {
q = _("どちらの手に装備しますか?", "Equip which hand? ");
s = _("おっと。", "Oops.");
- if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP), FuncItemTester(&ObjectType::is_wieldable_in_etheir_hand))) {
+ if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP), FuncItemTester(&ItemEntity::is_wieldable_in_etheir_hand))) {
return;
}
}
} else if (o_ptr_mh->k_idx && o_ptr_sh->k_idx) {
q = _("どちらの手に装備しますか?", "Equip which hand? ");
s = _("おっと。", "Oops.");
- if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP), FuncItemTester(&ObjectType::is_wieldable_in_etheir_hand))) {
+ if (!choose_object(player_ptr, &slot, q, s, (USE_EQUIP), FuncItemTester(&ItemEntity::is_wieldable_in_etheir_hand))) {
return;
}
sound(SOUND_WIELD);
if (need_switch_wielding && !player_ptr->inventory_list[need_switch_wielding].is_cursed()) {
- ObjectType *slot_o_ptr = &player_ptr->inventory_list[slot];
- ObjectType *switch_o_ptr = &player_ptr->inventory_list[need_switch_wielding];
- ObjectType object_tmp;
- ObjectType *otmp_ptr = &object_tmp;
+ ItemEntity *slot_o_ptr = &player_ptr->inventory_list[slot];
+ ItemEntity *switch_o_ptr = &player_ptr->inventory_list[need_switch_wielding];
+ ItemEntity object_tmp;
+ ItemEntity *otmp_ptr = &object_tmp;
GAME_TEXT switch_name[MAX_NLEN];
describe_flavor(player_ptr, switch_name, switch_o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
otmp_ptr->copy_from(switch_o_ptr);
void do_cmd_takeoff(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
PlayerClass pc(player_ptr);
pc.break_samurai_stance({ SamuraiStanceType::MUSOU });
{
OBJECT_IDX item;
int amt = 1;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
concptr q = _("どのアイテムを落としますか? ", "Drop which item? ");
void do_cmd_observe(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
concptr q = _("どのアイテムを調べますか? ", "Examine which item? ");
concptr s = _("調べられるアイテムがない。", "You have nothing to examine.");
void do_cmd_uninscribe(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
concptr q = _("どのアイテムの銘を消しますか? ", "Un-inscribe which item? ");
concptr s = _("銘を消せるアイテムがない。", "You have nothing to un-inscribe.");
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT));
void do_cmd_inscribe(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
char out_val[MAX_INSCRIPTION + 1] = "";
concptr q = _("どのアイテムに銘を刻みますか? ", "Inscribe which item? ");
void do_cmd_use(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (player_ptr->wild_mode || cmd_limit_arena(player_ptr)) {
return;
}
concptr q = _("どのアイテムを始動させますか? ", "Activate which item? ");
concptr s = _("始動できるアイテムを装備していない。", "You have nothing to activate.");
- if (!choose_object(player_ptr, &item, q, s, (USE_EQUIP | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ObjectType::is_activatable))) {
+ if (!choose_object(player_ptr, &item, q, s, (USE_EQUIP | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ItemEntity::is_activatable))) {
return;
}
concptr q = _("どの巻物を読みますか? ", "Read which scroll? ");
concptr s = _("読める巻物がない。", "You have no scrolls to read.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
OBJECT_IDX item;
- o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ObjectType::is_readable));
+ o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ItemEntity::is_readable));
if (!o_ptr) {
return;
}
static void do_cmd_refill_lamp(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
- ObjectType *j_ptr;
+ ItemEntity *o_ptr;
+ ItemEntity *j_ptr;
concptr q = _("どの油つぼから注ぎますか? ", "Refill with which flask? ");
concptr s = _("油つぼがない。", "You have no flasks of oil.");
- o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ObjectType::can_refill_lantern));
+ o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ItemEntity::can_refill_lantern));
if (!o_ptr) {
return;
}
static void do_cmd_refill_torch(PlayerType *player_ptr)
{
OBJECT_IDX item;
- ObjectType *o_ptr;
- ObjectType *j_ptr;
+ ItemEntity *o_ptr;
+ ItemEntity *j_ptr;
concptr q = _("どの松明で明かりを強めますか? ", "Refuel with which torch? ");
concptr s = _("他に松明がない。", "You have no extra torches.");
- o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ObjectType::can_refill_torch));
+ o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ItemEntity::can_refill_torch));
if (!o_ptr) {
return;
}
*/
void do_cmd_refill(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_LITE];
PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
PlayerClass pc(this->player_ptr);
pc.break_samurai_stance({ SamuraiStanceType::MUSOU });
- ObjectType tmp_object;
+ ItemEntity tmp_object;
ObjectThrowEntity ote(this->player_ptr, &tmp_object, delay_factor, mult, boomerang, shuriken);
if (!ote.check_can_throw()) {
return false;
if (!k_ref.flavor) {
o_name = strip_name(k_ref.idx);
} else {
- ObjectType dummy;
+ ItemEntity dummy;
dummy.prep(k_ref.idx);
describe_flavor(player_ptr, char_o_name, &dummy, OD_FORCE_FLAVOR);
}
}
int dam = 1;
- ObjectType *o_armed_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
+ ItemEntity *o_armed_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
auto *r_ptr = &monraces_info[monap_ptr->m_ptr->r_idx];
const EnumClassFlagGroup<MonsterResistanceType> resist_flags = { MonsterResistanceType::RESIST_ALL, MonsterResistanceType::RESIST_DARK };
* @param arrow_ptr 矢弾のオブジェクト構造体参照ポインタ
* @return スナイパーの射撃属性、弓矢の属性を考慮する。デフォルトはGF_PLAYER_SHOOT。
*/
-AttributeFlags shot_attribute(PlayerType *player_ptr, ObjectType *bow_ptr, ObjectType *arrow_ptr, SPELL_IDX snipe_type)
+AttributeFlags shot_attribute(PlayerType *player_ptr, ItemEntity *bow_ptr, ItemEntity *arrow_ptr, SPELL_IDX snipe_type)
{
AttributeFlags attribute_flags{};
attribute_flags.set(AttributeType::PLAYER_SHOOT);
* @return スレイ倍率をかけたダメージ量
*/
static MULTIPLY calc_shot_damage_with_slay(
- PlayerType *player_ptr, ObjectType *bow_ptr, ObjectType *arrow_ptr, int tdam, monster_type *monster_ptr, SPELL_IDX snipe_type)
+ PlayerType *player_ptr, ItemEntity *bow_ptr, ItemEntity *arrow_ptr, int tdam, monster_type *monster_ptr, SPELL_IDX snipe_type)
{
MULTIPLY mult = 10;
* Note that Bows of "Extra Shots" give an extra shot.
* </pre>
*/
-void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ObjectType *j_ptr, SPELL_IDX snipe_type)
+void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ItemEntity *j_ptr, SPELL_IDX snipe_type)
{
DIRECTION dir;
int i;
int cur_dis, visible;
PERCENTAGE j;
- ObjectType forge;
- ObjectType *q_ptr;
- ObjectType *o_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
+ ItemEntity *o_ptr;
AttributeFlags attribute_flags{};
attribute_flags.set(AttributeType::PLAYER_SHOOT);
#include "system/angband.h"
struct monster_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool test_hit_fire(PlayerType *player_ptr, int chance, monster_type *m_ptr, int vis, char *o_name);
int critical_shot(PlayerType *player_ptr, WEIGHT weight, int plus_ammo, int plus_bow, int dam);
int calc_crit_ratio_shot(PlayerType *player_ptr, int plus_ammo, int plus_bow);
int calc_expect_crit_shot(PlayerType *player_ptr, WEIGHT weight, int plus_ammo, int plus_bow, int dam);
int calc_expect_crit(PlayerType *player_ptr, WEIGHT weight, int plus, int dam, int16_t meichuu, bool dokubari, bool impact);
-void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ObjectType *j_ptr, SPELL_IDX snipe_type);
+void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ItemEntity *j_ptr, SPELL_IDX snipe_type);
* 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, ObjectType *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, monster_type *m_ptr, combat_options mode, bool thrown)
{
auto flgs = object_flags(o_ptr);
torch_flags(o_ptr, flgs); /* torches has secret flags */
return tdam * mult / 10;
}
-AttributeFlags melee_attribute(PlayerType *player_ptr, ObjectType *o_ptr, combat_options mode)
+AttributeFlags melee_attribute(PlayerType *player_ptr, ItemEntity *o_ptr, combat_options mode)
{
AttributeFlags attribute_flags{};
attribute_flags.set(AttributeType::PLAYER_MELEE);
#include "object-enchant/tr-flags.h"
struct monster_type;
-class ObjectType;
+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, ObjectType *o_ptr, int tdam, monster_type *m_ptr, combat_options mode, bool thrown);
-AttributeFlags melee_attribute(PlayerType *player_ptr, ObjectType *o_ptr, combat_options mode);
+int calc_attack_damage_with_slay(PlayerType *player_ptr, ItemEntity *o_ptr, int tdam, monster_type *m_ptr, combat_options mode, bool thrown);
+AttributeFlags melee_attribute(PlayerType *player_ptr, ItemEntity *o_ptr, combat_options mode);
*/
void compact_objects(PlayerType *player_ptr, int size)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (size) {
msg_print(_("アイテム情報を圧縮しています...", "Compacting objects..."));
player_ptr->redraw |= PR_MAP;
{
auto dun_level = this->player_ptr->current_floor_ptr->dun_level;
for (auto i = 0; i < (dun_level / 15) + 1; i++) {
- ObjectType item;
+ ItemEntity item;
while (true) {
item.wipe();
auto &r_ref = monraces_info[this->m_ptr->r_idx];
* 2. 固定アーティファクト以外の矢弾
* 3. 穴掘りエゴの装備品
*/
-bool QuestCompletionChecker::check_quality(ObjectType &item)
+bool QuestCompletionChecker::check_quality(ItemEntity &item)
{
auto is_good_reward = !item.is_cursed();
is_good_reward &= !item.is_ammo() || (item.is_ammo() && item.is_fixed_artifact());
#include <tuple>
struct monster_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
struct quest_type;
class QuestCompletionChecker {
int count_all_hostile_monsters();
Pos2D make_stairs(const bool create_stairs);
void make_reward(const Pos2D pos);
- bool check_quality(ObjectType &item);
+ bool check_quality(ItemEntity &item);
};
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 入手したオブジェクトの構造体参照ポインタ
*/
-void check_find_art_quest_completion(PlayerType *player_ptr, ObjectType *o_ptr)
+void check_find_art_quest_completion(PlayerType *player_ptr, ItemEntity *o_ptr)
{
const auto &quest_list = QuestList::get_instance();
/* Check if completed a quest */
extern int quest_text_line;
extern QuestId leaving_quest;
-class ObjectType;
+class ItemEntity;
class PlayerType;
void determine_random_questor(PlayerType *player_ptr, quest_type *q_ptr);
void record_quest_final_status(quest_type *q_ptr, PLAYER_LEVEL lev, QuestStatusType stat);
void complete_quest(PlayerType *player_ptr, QuestId quest_num);
-void check_find_art_quest_completion(PlayerType *player_ptr, ObjectType *o_ptr);
+void check_find_art_quest_completion(PlayerType *player_ptr, ItemEntity *o_ptr);
void quest_discovery(QuestId q_idx);
QuestId quest_number(PlayerType *player_ptr, DEPTH level);
QuestId random_quest_number(PlayerType *player_ptr, DEPTH level);
return;
}
- ObjectType *q_ptr;
- ObjectType forge;
+ ItemEntity *q_ptr;
+ ItemEntity forge;
q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::STATUE, SV_PHOTO }));
q_ptr->pval = em_ptr->photo;
* @param mode 表記に関するオプション指定
* @return 現在クエスト達成目的のアイテムならばTRUEを返す
*/
-void describe_flavor(PlayerType *player_ptr, char *buf, ObjectType *o_ptr, BIT_FLAGS mode)
+void describe_flavor(PlayerType *player_ptr, char *buf, ItemEntity *o_ptr, BIT_FLAGS mode)
{
flavor_type tmp_flavor;
flavor_type *flavor_ptr = initialize_flavor_type(&tmp_flavor, buf, o_ptr, mode);
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void describe_flavor(PlayerType *player_ptr, char *buf, ObjectType *o_ptr, BIT_FLAGS mode);
+void describe_flavor(PlayerType *player_ptr, char *buf, ItemEntity *o_ptr, BIT_FLAGS mode);
#include "util/enum-converter.h"
#include "util/quarks.h"
-flavor_type *initialize_flavor_type(flavor_type *flavor_ptr, char *buf, ObjectType *o_ptr, BIT_FLAGS mode)
+flavor_type *initialize_flavor_type(flavor_type *flavor_ptr, char *buf, ItemEntity *o_ptr, BIT_FLAGS mode)
{
flavor_ptr->buf = buf;
flavor_ptr->o_ptr = o_ptr;
* @param all TRUEならばベースアイテム上で明らかなフラグは省略する
* @return ptrと同じアドレス
*/
-char *get_ability_abbreviation(char *short_flavor, ObjectType *o_ptr, bool kanji, bool all)
+char *get_ability_abbreviation(char *short_flavor, ItemEntity *o_ptr, bool kanji, bool all)
{
char *prev_ptr = short_flavor;
auto flgs = object_flags(o_ptr);
* @param buff 特性短縮表記を格納する文字列ポインタ
* @param o_ptr 特性短縮表記を得たいオブジェクト構造体の参照ポインタ
*/
-void get_inscription(char *buff, ObjectType *o_ptr)
+void get_inscription(char *buff, ItemEntity *o_ptr)
{
concptr insc = quark_str(o_ptr->inscription);
char *ptr = buff;
* @details
* cmd1.c で流用するために object_desc_japanese から移動した。
*/
-char *object_desc_count_japanese(char *t, ObjectType *o_ptr)
+char *object_desc_count_japanese(char *t, ItemEntity *o_ptr)
{
t = object_desc_num(t, o_ptr->number);
switch (o_ptr->tval) {
#include "object-enchant/tr-flags.h"
class BaseitemInfo;
-class ObjectType;
+class ItemEntity;
struct flavor_type {
char *buf;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
BIT_FLAGS mode;
concptr kindname;
concptr basenm;
char tmp_val2[MAX_NLEN + 10];
char fake_insc_buf[30];
TrFlags tr_flags;
- ObjectType *bow_ptr;
+ ItemEntity *bow_ptr;
BaseitemInfo *k_ptr;
BaseitemInfo *flavor_k_ptr;
int avgdam;
};
class PlayerType;
-flavor_type *initialize_flavor_type(flavor_type *flavor_ptr, char *buf, ObjectType *o_ptr, BIT_FLAGS mode);
+flavor_type *initialize_flavor_type(flavor_type *flavor_ptr, char *buf, ItemEntity *o_ptr, BIT_FLAGS mode);
char *object_desc_chr(char *t, char c);
char *object_desc_str(char *t, concptr s);
char *object_desc_num(char *t, uint n);
char *object_desc_int(char *t, int v);
-char *get_ability_abbreviation(char *ptr, ObjectType *o_ptr, bool kanji, bool all);
-void get_inscription(char *buff, ObjectType *o_ptr);
+char *get_ability_abbreviation(char *ptr, ItemEntity *o_ptr, bool kanji, bool all);
+void get_inscription(char *buff, ItemEntity *o_ptr);
bool has_lite_flag(const TrFlags &flags);
bool has_dark_flag(const TrFlags &flags);
#ifdef JP
-char *object_desc_count_japanese(char *t, ObjectType *o_ptr);
+char *object_desc_count_japanese(char *t, ItemEntity *o_ptr);
#endif
* @param x 配置先X座標
* @return エラーコード
*/
-static void drop_here(FloorType *floor_ptr, ObjectType *j_ptr, POSITION y, POSITION x)
+static void drop_here(FloorType *floor_ptr, ItemEntity *j_ptr, POSITION y, POSITION x)
{
OBJECT_IDX o_idx = o_pop(floor_ptr);
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
o_ptr->copy_from(j_ptr);
o_ptr->iy = y;
}
const auto k_idx = lookup_baseitem_id({ ItemKindType::SCROLL, SV_SCROLL_ACQUIREMENT });
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(k_idx);
drop_here(player_ptr->current_floor_ptr, q_ptr, *qtwg_ptr->y, *qtwg_ptr->x);
g_ptr->mimic = g_ptr->feat;
g_ptr->feat = conv_dungeon_feat(floor_ptr, letter[idx].trap);
} else if (object_index) {
- ObjectType tmp_object;
+ ItemEntity tmp_object;
auto *o_ptr = &tmp_object;
o_ptr->prep(object_index);
if (o_ptr->tval == ItemKindType::GOLD) {
void clear_cave(PlayerType *player_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
- std::fill_n(floor_ptr->o_list.begin(), floor_ptr->o_max, ObjectType{});
+ std::fill_n(floor_ptr->o_list.begin(), floor_ptr->o_max, ItemEntity{});
floor_ptr->o_max = 1;
floor_ptr->o_cnt = 0;
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr デバッグ出力するオブジェクトの構造体参照ポインタ
*/
-static void object_mention(PlayerType *player_ptr, ObjectType *o_ptr)
+static void object_mention(PlayerType *player_ptr, ItemEntity *o_ptr)
{
object_aware(player_ptr, o_ptr);
object_known(o_ptr);
return floor_ptr->object_level;
}
-static void set_ammo_quantity(ObjectType *j_ptr)
+static void set_ammo_quantity(ItemEntity *j_ptr)
{
auto is_ammo = j_ptr->tval == ItemKindType::SPIKE;
is_ammo |= j_ptr->tval == ItemKindType::SHOT;
* @param rq_mon_level ランダムクエスト討伐対象のレベル。ランダムクエスト以外の生成であれば無効値
* @return アイテムの生成成功可否
*/
-bool make_object(PlayerType *player_ptr, ObjectType *j_ptr, BIT_FLAGS mode, std::optional<int> rq_mon_level)
+bool make_object(PlayerType *player_ptr, ItemEntity *j_ptr, BIT_FLAGS mode, std::optional<int> rq_mon_level)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
auto prob = any_bits(mode, AM_GOOD) ? 10 : 1000;
* @details
* The location must be a legal, clean, floor grid.
*/
-bool make_gold(PlayerType *player_ptr, ObjectType *j_ptr)
+bool make_gold(PlayerType *player_ptr, ItemEntity *j_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
int i = ((randint1(floor_ptr->object_level + 2) + 2) / 2) - 1;
g_ptr = &floor_ptr->grid_array[y][x];
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
o_ptr->wipe();
floor_ptr->o_cnt--;
*/
void delete_object_idx(PlayerType *player_ptr, OBJECT_IDX o_idx)
{
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
auto *floor_ptr = player_ptr->current_floor_ptr;
excise_object_idx(floor_ptr, o_idx);
j_ptr = &floor_ptr->o_list[o_idx];
* the object can combine, stack, or be placed. Artifacts will try very\n
* hard to be placed, including "teleporting" to a useful grid if needed.\n
*/
-OBJECT_IDX drop_near(PlayerType *player_ptr, ObjectType *j_ptr, PERCENTAGE chance, POSITION y, POSITION x)
+OBJECT_IDX drop_near(PlayerType *player_ptr, ItemEntity *j_ptr, PERCENTAGE chance, POSITION y, POSITION x)
{
int i, k, d, s;
POSITION dy, dx;
k = 0;
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (object_similar(o_ptr, j_ptr)) {
comb = true;
g_ptr = &floor_ptr->grid_array[by][bx];
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (object_similar(o_ptr, j_ptr)) {
object_absorb(o_ptr, j_ptr);
/*
* Choose an item and get auto-picker entry from it.
*/
-ObjectType *choose_object(PlayerType *player_ptr, OBJECT_IDX *idx, concptr q, concptr s, BIT_FLAGS option, const ItemTester &item_tester)
+ItemEntity *choose_object(PlayerType *player_ptr, OBJECT_IDX *idx, concptr q, concptr s, BIT_FLAGS option, const ItemTester &item_tester)
{
OBJECT_IDX item;
class ObjectIndexList;
class FloorType;
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ItemTester;
-bool make_object(PlayerType *player_ptr, ObjectType *j_ptr, BIT_FLAGS mode, std::optional<int> rq_mon_level = std::nullopt);
-bool make_gold(PlayerType *player_ptr, ObjectType *j_ptr);
+bool make_object(PlayerType *player_ptr, ItemEntity *j_ptr, BIT_FLAGS mode, std::optional<int> rq_mon_level = std::nullopt);
+bool make_gold(PlayerType *player_ptr, ItemEntity *j_ptr);
void delete_all_items_from_floor(PlayerType *player_ptr, POSITION y, POSITION x);
void floor_item_increase(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER num);
void floor_item_optimize(PlayerType *player_ptr, INVENTORY_IDX item);
void delete_object_idx(PlayerType *player_ptr, OBJECT_IDX o_idx);
void excise_object_idx(FloorType *floor_ptr, OBJECT_IDX o_idx);
ObjectIndexList &get_o_idx_list_contains(FloorType *floor_ptr, OBJECT_IDX o_idx);
-OBJECT_IDX drop_near(PlayerType *player_ptr, ObjectType *o_ptr, PERCENTAGE chance, POSITION y, POSITION x);
+OBJECT_IDX drop_near(PlayerType *player_ptr, ItemEntity *o_ptr, PERCENTAGE chance, POSITION y, POSITION x);
void floor_item_charges(FloorType *player_ptr, INVENTORY_IDX item);
void floor_item_describe(PlayerType *player_ptr, INVENTORY_IDX item);
-ObjectType *choose_object(PlayerType *player_ptr, OBJECT_IDX *idx, concptr q, concptr s, BIT_FLAGS option, const ItemTester &item_tester = AllMatchItemTester());
+ItemEntity *choose_object(PlayerType *player_ptr, OBJECT_IDX *idx, concptr q, concptr s, BIT_FLAGS option, const ItemTester &item_tester = AllMatchItemTester());
ITEM_NUMBER num = 0;
for (const auto this_o_idx : floor_ptr->grid_array[y][x].o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if ((mode & SCAN_FLOOR_ITEM_TESTER) && !item_tester.okay(o_ptr)) {
continue;
{
COMMAND_CODE i, m;
int j, k, l;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
char tmp_val[80];
COMMAND_CODE out_index[23];
return;
}
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->wipe();
if (!make_gold(player_ptr, q_ptr)) {
return;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
o_ptr->copy_from(q_ptr);
{
auto *floor_ptr = player_ptr->current_floor_ptr;
auto *g_ptr = &floor_ptr->grid_array[y][x];
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
if (!in_bounds(floor_ptr, y, x) || !cave_drop_bold(floor_ptr, y, x) || !g_ptr->o_idx_list.empty()) {
return;
}
return;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
o_ptr->copy_from(q_ptr);
}
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (o_ptr->is_artifact()) {
return false;
}
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_LITE];
auto flgs = object_flags(o_ptr);
}
}
-static void choise_cursed_item(CurseTraitType flag, ObjectType *o_ptr, int *choices, int *number, int item_num)
+static void choise_cursed_item(CurseTraitType flag, ItemEntity *o_ptr, int *choices, int *number, int item_num)
{
if (!is_specific_curse(flag)) {
return;
* @return 該当の呪いが一つでもあった場合にランダムに選ばれた装備品のオブジェクト構造体参照ポインタを返す。\n
* 呪いがない場合nullptrを返す。
*/
-ObjectType *choose_cursed_obj_name(PlayerType *player_ptr, CurseTraitType flag)
+ItemEntity *choose_cursed_obj_name(PlayerType *player_ptr, CurseTraitType flag)
{
int choices[INVEN_TOTAL - INVEN_MAIN_HAND];
int number = 0;
}
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int i_keep = 0, count = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
return;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_cursed_obj_name(player_ptr, CurseTraitType::ADD_L_CURSE);
auto new_curse = get_curse(0, o_ptr);
if (o_ptr->curse_flags.has(new_curse)) {
return;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_cursed_obj_name(player_ptr, CurseTraitType::ADD_H_CURSE);
auto new_curse = get_curse(1, o_ptr);
if (o_ptr->curse_flags.has(new_curse)) {
return;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_cursed_obj_name(player_ptr, CurseTraitType::PERSISTENT_CURSE);
if (o_ptr->curse_flags.has(CurseTraitType::HEAVY_CURSE)) {
return;
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-ObjectType *choose_cursed_obj_name(PlayerType *player_ptr, BIT_FLAGS flag);
+ItemEntity *choose_cursed_obj_name(PlayerType *player_ptr, BIT_FLAGS flag);
void execute_cursed_items_effect(PlayerType *player_ptr);
{
INVENTORY_IDX i;
int j, amt;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
if (check_multishadow(player_ptr) || player_ptr->current_floor_ptr->inside_arena) {
/*
* This seems like a pretty standard "typedef"
*/
-class ObjectType;
+class ItemEntity;
class PlayerType;
void inventory_damage(PlayerType *player_ptr, const ObjectBreaker &breaker, int perc);
*/
void drop_from_inventory(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER amt)
{
- ObjectType forge;
- ObjectType *q_ptr;
- ObjectType *o_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
o_ptr = &player_ptr->inventory_list[item];
if (amt <= 0) {
combined = false;
for (int i = INVEN_PACK; i > 0; i--) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
}
for (int j = 0; j < i; j++) {
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &player_ptr->inventory_list[j];
if (!j_ptr->k_idx) {
continue;
{
int i, j, k;
int32_t o_value;
- ObjectType forge;
- ObjectType *q_ptr;
- ObjectType *o_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
+ ItemEntity *o_ptr;
bool flag = false;
for (i = 0; i < INVEN_PACK; i++) {
* Note that this code must remove any location/stack information\n
* from the object once it is placed into the inventory.\n
*/
-int16_t store_item_to_inventory(PlayerType *player_ptr, ObjectType *o_ptr)
+int16_t store_item_to_inventory(PlayerType *player_ptr, ItemEntity *o_ptr)
{
INVENTORY_IDX i, j, k;
INVENTORY_IDX n = -1;
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
for (j = 0; j < INVEN_PACK; j++) {
j_ptr = &player_ptr->inventory_list[j];
if (!j_ptr->k_idx) {
* @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
* @return 溢れずに済むならTRUEを返す
*/
-bool check_store_item_to_inventory(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool check_store_item_to_inventory(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
if (player_ptr->inven_cnt < INVEN_PACK) {
return true;
INVENTORY_IDX inven_takeoff(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER amt)
{
INVENTORY_IDX slot;
- ObjectType forge;
- ObjectType *q_ptr;
- ObjectType *o_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
+ ItemEntity *o_ptr;
concptr act;
GAME_TEXT o_name[MAX_NLEN];
o_ptr = &player_ptr->inventory_list[item];
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
void vary_item(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER num);
void inven_item_increase(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER num);
void drop_from_inventory(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER amt);
void combine_pack(PlayerType *player_ptr);
void reorder_pack(PlayerType *player_ptr);
-int16_t store_item_to_inventory(PlayerType *player_ptr, ObjectType *o_ptr);
-bool check_store_item_to_inventory(PlayerType *player_ptr, const ObjectType *o_ptr);
+int16_t store_item_to_inventory(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool check_store_item_to_inventory(PlayerType *player_ptr, const ItemEntity *o_ptr);
INVENTORY_IDX inven_takeoff(PlayerType *player_ptr, INVENTORY_IDX item, ITEM_NUMBER amt);
return true;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (item >= 0) {
o_ptr = &player_ptr->inventory_list[item];
} else {
{
GAME_TEXT o_name[MAX_NLEN];
char out_val[MAX_NLEN + 20];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (item >= 0) {
o_ptr = &player_ptr->inventory_list[item];
} else {
return false;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
item_selection_ptr->k = 0 - (*item_selection_ptr->cp);
o_ptr = &player_ptr->current_floor_ptr->o_list[item_selection_ptr->k];
if (!item_tester.okay(o_ptr) && ((item_selection_ptr->mode & USE_FULL) == 0)) {
if (item_selection_ptr->floor) {
for (const auto this_o_idx : player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
if ((item_tester.okay(o_ptr) || (item_selection_ptr->mode & USE_FULL)) && (o_ptr->marked & OM_FOUND)) {
item_selection_ptr->allow_floor = true;
case '-': {
if (item_selection_ptr->allow_floor) {
for (const auto this_o_idx : player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
if (!item_tester.okay(o_ptr) && !(item_selection_ptr->mode & USE_FULL)) {
continue;
}
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
update_creature(player_ptr);
if (!player_ptr->inventory_list[INVEN_PACK].k_idx) {
return;
void py_pickup_floor(PlayerType *player_ptr, bool pickup)
{
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int floor_num = 0;
OBJECT_IDX floor_o_idx = 0;
int can_pickup = 0;
GAME_TEXT o_name[MAX_NLEN];
#endif
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[o_idx];
#ifdef JP
for (auto it = g_ptr->o_idx_list.begin(); it != g_ptr->o_idx_list.end();) {
const OBJECT_IDX this_o_idx = *it++;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(player_ptr, o_name, o_ptr, 0);
* If player has inscribed the object with "!!", let him know when it's recharged. -LM-
* @param o_ptr 対象オブジェクトの構造体参照ポインタ
*/
-static void recharged_notice(PlayerType *player_ptr, ObjectType *o_ptr)
+static void recharged_notice(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->inscription) {
return;
* @param art_ptr 記述内容を収めた構造体参照ポインタ
* Fill in an object description structure for a given object
*/
-static void spoiler_print_randart(ObjectType *o_ptr, obj_desc_list *art_ptr)
+static void spoiler_print_randart(ItemEntity *o_ptr, obj_desc_list *art_ptr)
{
pval_info_type *pval_ptr = &art_ptr->pval_info;
char buf[80];
* @param o_ptr ランダムアーティファクトのオブジェクト構造体参照ポインタ
* @param tval 出力したいランダムアーティファクトの種類
*/
-static void spoil_random_artifact_aux(PlayerType *player_ptr, ObjectType *o_ptr, ItemKindType tval)
+static void spoil_random_artifact_aux(PlayerType *player_ptr, ItemEntity *o_ptr, ItemKindType tval)
{
obj_desc_list artifact;
if (!o_ptr->is_known() || !o_ptr->art_name || o_ptr->tval != tval) {
void spoil_random_artifact(PlayerType *player_ptr, concptr fname)
{
store_type *store_ptr;
- ObjectType *q_ptr;
+ ItemEntity *q_ptr;
char buf[1024];
path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
spoiler_file = angband_fopen(buf, "w");
}
}
-void InputKeyRequestor::confirm_command(ObjectType &o_ref, const int caret_command)
+void InputKeyRequestor::confirm_command(ItemEntity &o_ref, const int caret_command)
{
auto s = quark_str(o_ref.inscription);
s = angband_strchr(s, '^');
extern int16_t command_wrk;
extern int16_t command_new;
-class ObjectType;
+class ItemEntity;
class PlayerType;
class SpecialMenuContent;
class InputKeyRequestor {
void change_shopping_command();
int get_caret_command();
void sweep_confirmation_equipments();
- void confirm_command(ObjectType &o_ref, const int caret_command);
+ void confirm_command(ItemEntity &o_ref, const int caret_command);
void make_commands_frame();
std::string switch_special_menu_condition(const SpecialMenuContent &special_menu);
* @param tval アイテム主分類番号
* @return 特殊なアイテムならTRUE
*/
-static bool determine_spcial_item_type(ObjectType *o_ptr, ItemKindType tval)
+static bool determine_spcial_item_type(ItemEntity *o_ptr, ItemKindType tval)
{
bool is_special_item_type = (o_ptr->is_wearable() && o_ptr->is_ego()) || ((tval == ItemKindType::AMULET) && (o_ptr->sval == SV_AMULET_RESISTANCE)) || ((tval == ItemKindType::RING) && (o_ptr->sval == SV_RING_LORDLY)) || ((tval == ItemKindType::SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) || ((tval == ItemKindType::HELM) && (o_ptr->sval == SV_DRAGON_HELM)) || ((tval == ItemKindType::GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) || ((tval == ItemKindType::BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)) || o_ptr->is_artifact();
* @param tval アイテム主分類番号
* @return 必要があるならTRUE
*/
-static bool check_item_knowledge(ObjectType *o_ptr, ItemKindType tval)
+static bool check_item_knowledge(ItemEntity *o_ptr, ItemKindType tval)
{
if (o_ptr->k_idx == 0) {
return false;
* @param fff 一時ファイルへの参照ポインタ
* @todo ここの関数から表示用の関数に移したい
*/
-static void display_identified_resistances_flag(ObjectType *o_ptr, FILE *fff)
+static void display_identified_resistances_flag(ItemEntity *o_ptr, FILE *fff)
{
auto flags = object_flags_known(o_ptr);
* @param o_ptr アイテムへの参照ポインタ
* @param where アイテムの場所 (手持ち、家等) を示す文字列への参照ポインタ
*/
-static void do_cmd_knowledge_inventory_aux(PlayerType *player_ptr, FILE *fff, ObjectType *o_ptr, char *where)
+static void do_cmd_knowledge_inventory_aux(PlayerType *player_ptr, FILE *fff, ItemEntity *o_ptr, char *where)
{
int i = 0;
GAME_TEXT o_name[MAX_NLEN];
for (POSITION x = 0; x < player_ptr->current_floor_ptr->width; x++) {
auto *g_ptr = &player_ptr->current_floor_ptr->grid_array[y][x];
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
if (!o_ptr->is_fixed_artifact()) {
continue;
continue;
}
- ObjectType item;
+ ItemEntity item;
item.prep(bi_id);
item.fixed_artifact_idx = a_idx;
item.ident |= IDENT_STORE;
*/
static void desc_obj_fake(PlayerType *player_ptr, KIND_OBJECT_IDX k_idx)
{
- ObjectType *o_ptr;
- ObjectType ObjectType_body;
+ ItemEntity *o_ptr;
+ ItemEntity ObjectType_body;
o_ptr = &ObjectType_body;
o_ptr->wipe();
o_ptr->prep(k_idx);
case QuestKindType::FIND_ARTIFACT:
if (q_ref.reward_artifact_idx != FixedArtifactId::NONE) {
const auto &a_ref = artifacts_info.at(q_ref.reward_artifact_idx);
- ObjectType item;
+ ItemEntity item;
auto k_idx = lookup_baseitem_id(a_ref.bi_key);
item.prep(k_idx);
item.fixed_artifact_idx = q_ref.reward_artifact_idx;
player_ptr->equip_cnt = 0;
//! @todo std::make_shared の配列対応版は C++20 から
- player_ptr->inventory_list = std::shared_ptr<ObjectType[]>{ new ObjectType[INVEN_TOTAL] };
+ player_ptr->inventory_list = std::shared_ptr<ItemEntity[]>{ new ItemEntity[INVEN_TOTAL] };
int slot = 0;
auto item_loader = ItemLoaderFactory::create_loader();
break;
}
- ObjectType item;
+ ItemEntity item;
item_loader->rd_item(&item);
if (!item.k_idx) {
return 53;
public:
virtual ~ItemLoaderBase() = default;
- virtual void rd_item(ObjectType *o_ptr) = 0;
+ virtual void rd_item(ItemEntity *o_ptr) = 0;
void load_item(void);
void load_artifact(void);
* @brief アイテムオブジェクトを読み込む(v3.0.0 Savefile ver50まで)
* @param o_ptr アイテムオブジェクト保存先ポインタ
*/
-void ItemLoader50::rd_item(ObjectType *o_ptr)
+void ItemLoader50::rd_item(ItemEntity *o_ptr)
{
if (h_older_than(1, 5, 0, 0)) {
rd_item_old(o_ptr);
#include "load/item/item-loader-base.h"
-class ObjectType;
+class ItemEntity;
class ItemLoader50 : public ItemLoaderBase {
public:
ItemLoader50() = default;
- void rd_item(ObjectType *o_ptr) override;
+ void rd_item(ItemEntity *o_ptr) override;
};
* @brief アイテムオブジェクト1件を読み込む / Read an object
* @param o_ptr アイテムオブジェクト読み取り先ポインタ
*/
-void rd_item_old(ObjectType *o_ptr)
+void rd_item_old(ItemEntity *o_ptr)
{
o_ptr->k_idx = rd_s16b();
extern const int QUEST_OLD_CASTLE;
extern const int QUEST_ROYAL_CRYPT;
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void rd_item_old(ObjectType *o_ptr);
+void rd_item_old(ItemEntity *o_ptr);
void rd_monster_old(PlayerType *player_ptr, monster_type *m_ptr);
void set_old_lore(monster_race *r_ptr, BIT_FLAGS f4, const MonsterRaceId r_idx);
errr rd_dungeon_old(PlayerType *player_ptr);
* Also note that it may not correctly "adapt" to "knowledge" bacoming
* known, the player may have to pick stuff up and drop it again.
*/
-static void home_carry_load(PlayerType *player_ptr, store_type *store_ptr, ObjectType *o_ptr)
+static void home_carry_load(PlayerType *player_ptr, store_type *store_ptr, ItemEntity *o_ptr)
{
for (auto i = 0; i < store_ptr->stock_num; i++) {
auto *j_ptr = &store_ptr->stock[i];
auto item_loader = ItemLoaderFactory::create_loader();
for (int j = 0; j < inven_num; j++) {
- ObjectType item;
+ ItemEntity item;
item_loader->rd_item(&item);
auto stock_max = store_get_stock_max(i2enum<StoreSaleType>(store_number));
if (store_ptr->stock_num >= stock_max) {
{
bool change = false;
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
for (INVENTORY_IDX i = 0; i <= INVEN_SUB_HAND; i++) {
o_ptr = &player_ptr->inventory_list[i];
char buf[MAX_NLEN + 20];
INVENTORY_IDX item_new;
- ObjectType forge;
+ ItemEntity forge;
describe_flavor(player_ptr, o_name, o_ptr, 0);
sprintf(buf, _("%sを渡しますか？", "Hand %s over? "), o_name);
* @param from_ptr 修復材料オブジェクトの構造体の参照ポインタ。
* @return 修復対象になるならTRUEを返す。
*/
-static void give_one_ability_of_object(ObjectType *to_ptr, ObjectType *from_ptr)
+static void give_one_ability_of_object(ItemEntity *to_ptr, ItemEntity *from_ptr)
{
auto to_flgs = object_flags(to_ptr);
auto from_flgs = object_flags(from_ptr);
concptr s = _("修復できる折れた武器がありません。", "You have no broken weapon to repair.");
OBJECT_IDX item;
- ObjectType *o_ptr;
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_EQUIP), FuncItemTester(&ObjectType::is_broken_weapon));
+ ItemEntity *o_ptr;
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_EQUIP), FuncItemTester(&ItemEntity::is_broken_weapon));
if (!o_ptr) {
return 0;
}
s = _("材料となる武器がありません。", "You have no material for the repair.");
OBJECT_IDX mater;
- ObjectType *mo_ptr;
- mo_ptr = choose_object(player_ptr, &mater, q, s, (USE_INVEN | USE_EQUIP), FuncItemTester(&ObjectType::is_orthodox_melee_weapons));
+ ItemEntity *mo_ptr;
+ mo_ptr = choose_object(player_ptr, &mater, q, s, (USE_INVEN | USE_EQUIP), FuncItemTester(&ItemEntity::is_orthodox_melee_weapons));
if (!mo_ptr) {
return 0;
}
* Only accurate for the current weapon, because it includes\n
* the current number of blows for the player.\n
*/
-static void compare_weapon_aux(PlayerType *player_ptr, ObjectType *o_ptr, int col, int r)
+static void compare_weapon_aux(PlayerType *player_ptr, ItemEntity *o_ptr, int col, int r)
{
int blow = player_ptr->num_blow[0];
bool force = false;
* Only accurate for the current weapon, because it includes
* various info about the player's +to_dam and number of blows.
*/
-static void list_weapon(PlayerType *player_ptr, ObjectType *o_ptr, TERM_LEN row, TERM_LEN col)
+static void list_weapon(PlayerType *player_ptr, ItemEntity *o_ptr, TERM_LEN row, TERM_LEN col)
{
GAME_TEXT o_name[MAX_NLEN];
GAME_TEXT tmp_str[80];
*/
PRICE compare_weapons(PlayerType *player_ptr, PRICE bcost)
{
- ObjectType *o_ptr[2];
- ObjectType orig_weapon;
- ObjectType *i_ptr;
+ ItemEntity *o_ptr[2];
+ ItemEntity orig_weapon;
+ ItemEntity *i_ptr;
TERM_LEN row = 2;
TERM_LEN wid = 38, mgn = 2;
bool old_character_xtra = w_ptr->character_xtra;
concptr s = _("比べるものがありません。", "You have nothing to compare.");
OBJECT_IDX item;
- o_ptr[0] = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ObjectType::is_orthodox_melee_weapons));
+ o_ptr[0] = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ItemEntity::is_orthodox_melee_weapons));
if (!o_ptr[0]) {
screen_load();
return 0;
q = _("第二の武器は？", "What is your second weapon? ");
s = _("比べるものがありません。", "You have nothing to compare.");
OBJECT_IDX item2;
- ObjectType *i2_ptr = choose_object(player_ptr, &item2, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ObjectType::is_orthodox_melee_weapons));
+ ItemEntity *i2_ptr = choose_object(player_ptr, &item2, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ItemEntity::is_orthodox_melee_weapons));
if (!i2_ptr) {
continue;
}
concptr s = _("改良できるものがありません。", "You have nothing to improve.");
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_EQUIP | IGNORE_BOTHHAND_SLOT), item_tester);
if (!o_ptr) {
return false;
}
store_ptr->stock_size = store_get_stock_max(sst);
- store_ptr->stock = std::make_unique<ObjectType[]>(store_ptr->stock_size);
+ store_ptr->stock = std::make_unique<ItemEntity[]>(store_ptr->stock_size);
if ((sst == StoreSaleType::BLACK) || (sst == StoreSaleType::HOME) || (sst == StoreSaleType::MUSEUM)) {
continue;
}
concptr s = _("魔力を充填すべきアイテムがない。", "You have nothing to recharge.");
OBJECT_IDX item;
- ObjectType *o_ptr;
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_rechargeable));
+ ItemEntity *o_ptr;
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_rechargeable));
if (!o_ptr) {
return;
}
PRICE price = 0;
PRICE total_cost = 0;
for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if ((o_ptr->tval < ItemKindType::STAFF) || (o_ptr->tval > ItemKindType::ROD)) {
}
for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
BaseitemInfo *k_ptr;
k_ptr = &baseitems_info[o_ptr->k_idx];
return true;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::SHOT, (OBJECT_SUBTYPE_VALUE)m_bonus(1, player_ptr->lev) + 1 }));
q_ptr->number = (byte)rand_range(15, 30);
concptr q = _("どのアイテムから作りますか？ ", "Convert which item? ");
concptr s = _("材料を持っていない。", "You have no item to convert.");
OBJECT_IDX item;
- auto *q_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ObjectType::is_convertible));
+ auto *q_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ItemEntity::is_convertible));
if (!q_ptr) {
return false;
}
- ObjectType forge;
+ ItemEntity forge;
q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::ARROW, static_cast<short>(m_bonus(1, player_ptr->lev) + 1) }));
q_ptr->number = (byte)rand_range(5, 10);
concptr q = _("どのアイテムから作りますか？ ", "Convert which item? ");
concptr s = _("材料を持っていない。", "You have no item to convert.");
OBJECT_IDX item;
- auto *q_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_convertible));
+ auto *q_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_convertible));
if (!q_ptr) {
return false;
}
- ObjectType forge;
+ ItemEntity forge;
q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::BOLT, static_cast<short>(m_bonus(1, player_ptr->lev) + 1) }));
q_ptr->number = (byte)rand_range(4, 8);
void acquire_chaos_weapon(PlayerType *player_ptr)
{
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
auto dummy = ItemKindType::SWORD;
OBJECT_SUBTYPE_VALUE dummy2;
bool create_ration(PlayerType *player_ptr)
{
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::FOOD, SV_FOOD_RATION }));
(void)drop_near(player_ptr, q_ptr, -1, player_ptr->y, player_ptr->x);
concptr q = _("どのアイテムから魔力を吸収しますか？", "Drain which item? ");
concptr s = _("魔力を吸収できるアイテムがありません。", "You have nothing to drain.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
OBJECT_IDX item;
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_rechargeable));
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_rechargeable));
if (!o_ptr) {
return false;
}
o_ptr->pval--;
if ((o_ptr->tval == ItemKindType::STAFF) && (item >= 0) && (o_ptr->number > 1)) {
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->copy_from(o_ptr);
concptr q = _("どのアイテムの魔力を取り込みますか? ", "Gain power of which item? ");
concptr s = _("魔力を取り込めるアイテムがない。", "There's nothing with power to absorb.");
OBJECT_IDX item;
- auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ObjectType::is_rechargeable));
+ auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_INVEN | USE_FLOOR, FuncItemTester(&ItemEntity::is_rechargeable));
if (!o_ptr) {
return false;
}
{
concptr q = _("どのアイテムを調べますか？", "Meditate on which item? ");
concptr s = _("調べるアイテムがありません。", "You have nothing appropriate.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
OBJECT_IDX item;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT));
if (!o_ptr) {
return false;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
if (player_ptr->is_dead) {
return false;
concptr s = _("祝福できる武器がありません。", "You have no weapon to bless.");
OBJECT_IDX item;
- auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ObjectType::is_weapon));
+ auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ItemEntity::is_weapon));
if (!o_ptr) {
return false;
}
auto s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
OBJECT_IDX item;
- auto o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ObjectType::is_weapon_armour_ammo));
+ auto o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), FuncItemTester(&ItemEntity::is_weapon_armour_ammo));
if (!o_ptr) {
return;
}
bool flag;
char choice;
concptr q, s;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
char out_val[160];
GAME_TEXT o_name[MAX_NLEN];
int menu_line = (use_menu ? 1 : 0);
{
OBJECT_IDX item;
concptr q, s;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
s = _("エッセンスを付加したアイテムがありません。", "You have nothing with added essence to remove.");
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_smith));
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_smith));
if (!o_ptr) {
return;
}
enum class RaceBlowMethodType;
class PlayerType;
struct monster_type;
-class ObjectType;
+class ItemEntity;
class MonsterAttackPlayer {
public:
MonsterAttackPlayer(PlayerType *player_ptr, short m_idx);
GAME_TEXT m_name[MAX_NLEN]{};
int d_dice = 0;
int d_side = 0;
- ObjectType *o_ptr = nullptr;
+ ItemEntity *o_ptr = nullptr;
bool obvious = false;
int damage = 0;
bool blinked = false;
return;
}
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &player_ptr->current_floor_ptr->o_list[o_idx];
j_ptr->copy_from(monap_ptr->o_ptr);
j_ptr->number = 1;
const auto &arena = arena_info[player_ptr->arena_number];
const auto tval = arena.key.tval();
if (tval > ItemKindType::NONE) {
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id(arena.key));
ItemMagicApplier(player_ptr, q_ptr, floor_ptr->object_level, AM_NO_FIXED_ART).execute();
}
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::CORPSE, (corpse ? SV_CORPSE : SV_SKELETON) }));
ItemMagicApplier(player_ptr, q_ptr, floor_ptr->object_level, AM_NO_FIXED_ART).execute();
KIND_OBJECT_IDX k_idx = drop_dungeon_final_artifact(player_ptr, md_ptr);
if (k_idx != 0) {
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(k_idx);
ItemMagicApplier(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART | AM_GOOD).execute();
int dump_item = 0;
int dump_gold = 0;
for (int i = 0; i < drop_numbers; i++) {
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->wipe();
if (md_ptr->do_gold && (!md_ptr->do_item || (randint0(100) < 50))) {
* @param o_name アイテム名
* @param this_o_idx モンスターが乗ったオブジェクトID
*/
-static void monster_pickup_object(PlayerType *player_ptr, turn_flags *turn_flags_ptr, const MONSTER_IDX m_idx, ObjectType *o_ptr, const bool is_unpickable_object,
+static void monster_pickup_object(PlayerType *player_ptr, turn_flags *turn_flags_ptr, const MONSTER_IDX m_idx, ItemEntity *o_ptr, const bool is_unpickable_object,
const POSITION ny, const POSITION nx, const GAME_TEXT *m_name, const GAME_TEXT *o_name, const OBJECT_IDX this_o_idx)
{
auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
void monster_drop_carried_objects(PlayerType *player_ptr, monster_type *m_ptr)
{
for (auto it = m_ptr->hold_o_idx_list.begin(); it != m_ptr->hold_o_idx_list.end();) {
- ObjectType forge;
- ObjectType *o_ptr;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *o_ptr;
+ ItemEntity *q_ptr;
const OBJECT_IDX this_o_idx = *it++;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
q_ptr = &forge;
}
concptr color;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
if (r_ptr->level > player_ptr->lev + 30) {
color = _("黒く", "black");
return;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::SWORD, SV_BLADE_OF_CHAOS }));
ItemMagicApplier(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART | md_ptr->mo_mode).execute();
return;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->wipe();
if ((floor_ptr->dun_level > 49) && one_in_(5)) {
return;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::HAFTED, SV_GROND }));
q_ptr->fixed_artifact_idx = FixedArtifactId::GROND;
return;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::SWORD, randint1(2) }));
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
return;
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(lookup_baseitem_id({ ItemKindType::CHEST, SV_CHEST_KANDUME }));
ItemMagicApplier(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART).execute();
* @return 生成したアイテムが装備品ならtrue、それ以外ならfalse
* @todo 汎用的に使えそうだがどこかにいいファイルはないか？
*/
-static bool make_equipment(PlayerType *player_ptr, ObjectType *q_ptr, const BIT_FLAGS drop_mode, const bool is_object_hook_null)
+static bool make_equipment(PlayerType *player_ptr, ItemEntity *q_ptr, const BIT_FLAGS drop_mode, const bool is_object_hook_null)
{
q_ptr->wipe();
(void)make_object(player_ptr, q_ptr, drop_mode);
*/
static void on_dead_random_artifact(PlayerType *player_ptr, monster_death_type *md_ptr, bool (*object_hook_pf)(KIND_OBJECT_IDX k_idx))
{
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
auto is_object_hook_null = object_hook_pf == nullptr;
auto drop_mode = md_ptr->mo_mode | AM_NO_FIXED_ART;
static void drop_specific_item_on_dead(PlayerType *player_ptr, monster_death_type *md_ptr, bool (*object_hook_pf)(KIND_OBJECT_IDX k_idx))
{
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->wipe();
get_obj_index_hook = object_hook_pf;
g_ptr->m_idx = i2;
for (const auto this_o_idx : m_ptr->hold_o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
o_ptr->held_m_idx = i2;
}
{
int hp = player_ptr->chp;
int shoot_dd = 1, shoot_ds = 1, shoot_base = 0;
- ObjectType *o_ptr = nullptr;
+ ItemEntity *o_ptr = nullptr;
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND)) {
o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
}
if (player_ptr->muta.has(PlayerMutationType::EAT_LIGHT) && one_in_(3000)) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
msg_print(_("影につつまれた。", "A shadow passes over you."));
msg_print(nullptr);
bool drop_weapons(PlayerType *player_ptr)
{
INVENTORY_IDX slot = 0;
- ObjectType *o_ptr = nullptr;
+ ItemEntity *o_ptr = nullptr;
if (player_ptr->wild_mode) {
return false;
* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return 発動実行の是非を返す。
*/
-bool activate_dragon_breath(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_dragon_breath(PlayerType *player_ptr, ItemEntity *o_ptr)
{
DIRECTION dir;
if (!get_aim_dir(player_ptr, &dir)) {
return true;
}
-bool activate_breath_fire(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_breath_fire(PlayerType *player_ptr, ItemEntity *o_ptr)
{
DIRECTION dir;
if (!get_aim_dir(player_ptr, &dir)) {
return true;
}
-bool activate_breath_cold(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_breath_cold(PlayerType *player_ptr, ItemEntity *o_ptr)
{
DIRECTION dir;
if (!get_aim_dir(player_ptr, &dir)) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool activate_dragon_breath(PlayerType *player_ptr, ObjectType *o_ptr);
-bool activate_breath_fire(PlayerType *player_ptr, ObjectType *o_ptr);
-bool activate_breath_cold(PlayerType *player_ptr, ObjectType *o_ptr);
+bool activate_dragon_breath(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool activate_breath_fire(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool activate_breath_cold(PlayerType *player_ptr, ItemEntity *o_ptr);
return true;
}
-bool activate_aggravation(PlayerType *player_ptr, ObjectType *o_ptr, concptr name)
+bool activate_aggravation(PlayerType *player_ptr, ItemEntity *o_ptr, concptr name)
{
if (o_ptr->is_specific_artifact(FixedArtifactId::HYOUSIGI)) {
msg_print(_("拍子木を打った。", "You beat your wooden clappers."));
return recall_player(player_ptr, randint0(21) + 15);
}
-bool activate_tree_creation(PlayerType *player_ptr, ObjectType *o_ptr, concptr name)
+bool activate_tree_creation(PlayerType *player_ptr, ItemEntity *o_ptr, concptr name)
{
msg_format(_("%s%sから明るい緑の光があふれ出た...", "The %s%s wells with clear light..."), name, quark_str(o_ptr->art_name));
return tree_creation(player_ptr, player_ptr->y, player_ptr->x);
}
-bool activate_animate_dead(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_animate_dead(PlayerType *player_ptr, ItemEntity *o_ptr)
{
msg_print(_("黄金色の光が溢れ出た...", "It emitted a golden light..."));
if (o_ptr->is_specific_artifact(FixedArtifactId::EXCALIBORG)) {
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool activate_sunlight(PlayerType *player_ptr);
bool activate_confusion(PlayerType *player_ptr);
bool activate_banish_evil(PlayerType *player_ptr);
bool activate_scare(PlayerType *player_ptr);
-bool activate_aggravation(PlayerType *player_ptr, ObjectType *o_ptr, concptr name);
+bool activate_aggravation(PlayerType *player_ptr, ItemEntity *o_ptr, concptr name);
bool activate_stone_mud(PlayerType *player_ptr);
bool activate_judgement(PlayerType *player_ptr, concptr name);
bool activate_telekinesis(PlayerType *player_ptr, concptr name);
bool activate_protection_elbereth(PlayerType *player_ptr);
bool activate_light(PlayerType *player_ptr, concptr name);
bool activate_recall(PlayerType *player_ptr);
-bool activate_tree_creation(PlayerType *player_ptr, ObjectType *o_ptr, concptr name);
-bool activate_animate_dead(PlayerType *player_ptr, ObjectType *o_ptr);
+bool activate_tree_creation(PlayerType *player_ptr, ItemEntity *o_ptr, concptr name);
+bool activate_animate_dead(PlayerType *player_ptr, ItemEntity *o_ptr);
bool activate_detect_treasure(PlayerType *player_ptr);
bool activate_create_ammo(PlayerType *player_ptr);
bool activate_dispel_magic(PlayerType *player_ptr);
#include "timed-effect/player-acceleration.h"
#include "view/display-messages.h"
-bool switch_activation(PlayerType *player_ptr, ObjectType **o_ptr_ptr, const activation_type *const act_ptr, concptr name)
+bool switch_activation(PlayerType *player_ptr, ItemEntity **o_ptr_ptr, const activation_type *const act_ptr, concptr name)
{
auto *o_ptr = (*o_ptr_ptr);
#include "system/angband.h"
struct activation_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool switch_activation(PlayerType *player_ptr, ObjectType **o_ptr_ptr, const activation_type *const act_ptr, concptr name);
+bool switch_activation(PlayerType *player_ptr, ItemEntity **o_ptr_ptr, const activation_type *const act_ptr, concptr name);
#include "system/angband.h"
// Activation Execution.
-class ObjectType;
+class ItemEntity;
struct ae_type {
DIRECTION dir;
bool success;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
DEPTH lev;
int chance;
int fail;
* @details 純粋仮想関数につき、必要なメンバ変数は派生クラスで設定すること
*/
-class ObjectType;
+class ItemEntity;
class PlayerType;
class EnchanterBase {
public:
#include "object/tval-types.h"
#include "system/object-type-definition.h"
-std::unique_ptr<EnchanterBase> EnchanterFactory::create_enchanter(PlayerType *player_ptr, ObjectType *o_ptr, int lev, int power)
+std::unique_ptr<EnchanterBase> EnchanterFactory::create_enchanter(PlayerType *player_ptr, ItemEntity *o_ptr, int lev, int power)
{
switch (o_ptr->tval) {
case ItemKindType::SHOT:
#include <memory>
class EnchanterBase;
-class ObjectType;
+class ItemEntity;
class PlayerType;
class EnchanterFactory {
public:
- static std::unique_ptr<EnchanterBase> create_enchanter(PlayerType *player_ptr, ObjectType *o_ptr, int lev, int power);
+ static std::unique_ptr<EnchanterBase> create_enchanter(PlayerType *player_ptr, ItemEntity *o_ptr, int lev, int power);
private:
EnchanterFactory() = delete;
* @param lev 生成基準階
* @param mode 生成オプション
*/
-ItemMagicApplier::ItemMagicApplier(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH lev, BIT_FLAGS mode)
+ItemMagicApplier::ItemMagicApplier(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH lev, BIT_FLAGS mode)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
, lev(lev)
#include "system/angband.h"
#include <tuple>
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ItemMagicApplier {
public:
- ItemMagicApplier(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH lev, BIT_FLAGS mode);
+ ItemMagicApplier(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH lev, BIT_FLAGS mode);
void execute();
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
DEPTH lev;
BIT_FLAGS mode;
* @details 重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_sustain(ObjectType *o_ptr)
+void one_sustain(ItemEntity *o_ptr)
{
switch (randint0(A_MAX)) {
case 0:
* @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
* @return TR_ESP_NONLIVINGがついたならばTRUE
*/
-bool add_esp_strong(ObjectType *o_ptr)
+bool add_esp_strong(ItemEntity *o_ptr)
{
bool nonliv = false;
* @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
* @param extra TRUEならばESPの最大付与数が増える(TRUE -> 3+1d6 / FALSE -> 1d3)
*/
-void add_esp_weak(ObjectType *o_ptr, bool extra)
+void add_esp_weak(ItemEntity *o_ptr, bool extra)
{
int i;
tr_type weak_esp_list[] = {
* ESPまたは邪ESPは1d3の種族ESPを得る。
* 無ESPは3+1d6の種族ESPを得る。
*/
-void add_high_telepathy(ObjectType *o_ptr)
+void add_high_telepathy(ItemEntity *o_ptr)
{
if (add_esp_strong(o_ptr)) {
add_esp_weak(o_ptr, true);
* 鋭敏の帽子など。
* ESP、邪ESP、無ESPまたは1d3の種族ESP。
*/
-void add_low_telepathy(ObjectType *o_ptr)
+void add_low_telepathy(ItemEntity *o_ptr)
{
if (one_in_(2)) {
add_esp_strong(o_ptr);
* @details 候補は火炎、冷気、電撃、酸のいずれかであり、重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_ele_resistance(ObjectType *o_ptr)
+void one_ele_resistance(ItemEntity *o_ptr)
{
switch (randint0(4)) {
case 0:
* @details 候補は1/7の確率で毒、6/7の確率で火炎、冷気、電撃、酸のいずれか(one_ele_resistance()のコール)であり、重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_dragon_ele_resistance(ObjectType *o_ptr)
+void one_dragon_ele_resistance(ItemEntity *o_ptr)
{
if (one_in_(7)) {
o_ptr->art_flags.set(TR_RES_POIS);
* @details 重複の抑止はない。候補は毒、閃光、暗黒、破片、盲目、混乱、地獄、因果混乱、カオス、劣化、恐怖、時間逆転、水、呪力のいずれか。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_high_resistance(ObjectType *o_ptr)
+void one_high_resistance(ItemEntity *o_ptr)
{
switch (randint0(15)) {
case 0:
* @brief ドラゴン装備にランダムな耐性を与える
* @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
*/
-void dragon_resist(ObjectType *o_ptr)
+void dragon_resist(ItemEntity *o_ptr)
{
do {
if (one_in_(4)) {
* をコールする。重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_resistance(ObjectType *o_ptr)
+void one_resistance(ItemEntity *o_ptr)
{
if (one_in_(3)) {
one_ele_resistance(o_ptr);
* 重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_ability(ObjectType *o_ptr)
+void one_ability(ItemEntity *o_ptr)
{
switch (randint0(10)) {
case 0:
* ドラゴン、人間、善良、ユニークESPのいずれかであり、重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_low_esp(ObjectType *o_ptr)
+void one_low_esp(ItemEntity *o_ptr)
{
switch (randint1(10)) {
case 1:
* whileループによる構造で能力的に強力なものほど確率を落としている。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_activation(ObjectType *o_ptr)
+void one_activation(ItemEntity *o_ptr)
{
RandomArtActType type = RandomArtActType::NONE;
PERCENTAGE chance = 0;
* ランダム付加そのものに重複の抑止はない。
* @param o_ptr 対象のオブジェクト構造体ポインタ
*/
-void one_lordly_high_resistance(ObjectType *o_ptr)
+void one_lordly_high_resistance(ItemEntity *o_ptr)
{
switch (randint0(13)) {
case 0:
* @brief オブジェクトの重量を軽くする
* @param o_ptr オブジェクト情報への参照ポインタ
*/
-void make_weight_ligten(ObjectType *o_ptr)
+void make_weight_ligten(ItemEntity *o_ptr)
{
o_ptr->weight = (2 * baseitems_info[o_ptr->k_idx].weight / 3);
}
* @brief オブジェクトの重量を重くする
* @param o_ptr オブジェクト情報への参照ポインタ
*/
-void make_weight_heavy(ObjectType *o_ptr)
+void make_weight_heavy(ItemEntity *o_ptr)
{
o_ptr->weight = (4 * baseitems_info[o_ptr->k_idx].weight / 3);
}
* @details
* 1/4を加算。最低+5を保証。
*/
-void add_xtra_ac(ObjectType *o_ptr)
+void add_xtra_ac(ItemEntity *o_ptr)
{
o_ptr->ac += std::max<short>(5, o_ptr->ac / 4);
}
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
int m_bonus(int max, DEPTH level);
-void one_sustain(ObjectType *o_ptr);
-bool add_esp_strong(ObjectType *o_ptr);
-void add_esp_weak(ObjectType *o_ptr, bool extra);
-void add_high_telepathy(ObjectType *o_ptr);
-void add_low_telepathy(ObjectType *o_ptr);
-void one_dragon_ele_resistance(ObjectType *o_ptr);
-void one_high_resistance(ObjectType *o_ptr);
-void one_ele_resistance(ObjectType *o_ptr);
-void dragon_resist(ObjectType *o_ptr);
-void one_resistance(ObjectType *o_ptr);
-void one_low_esp(ObjectType *o_ptr);
-void one_ability(ObjectType *o_ptr);
-void one_activation(ObjectType *o_ptr);
-void one_lordly_high_resistance(ObjectType *o_ptr);
-void make_weight_ligten(ObjectType *o_ptr);
-void make_weight_heavy(ObjectType *o_ptr);
-void add_xtra_ac(ObjectType *o_ptr);
+void one_sustain(ItemEntity *o_ptr);
+bool add_esp_strong(ItemEntity *o_ptr);
+void add_esp_weak(ItemEntity *o_ptr, bool extra);
+void add_high_telepathy(ItemEntity *o_ptr);
+void add_low_telepathy(ItemEntity *o_ptr);
+void one_dragon_ele_resistance(ItemEntity *o_ptr);
+void one_high_resistance(ItemEntity *o_ptr);
+void one_ele_resistance(ItemEntity *o_ptr);
+void dragon_resist(ItemEntity *o_ptr);
+void one_resistance(ItemEntity *o_ptr);
+void one_low_esp(ItemEntity *o_ptr);
+void one_ability(ItemEntity *o_ptr);
+void one_activation(ItemEntity *o_ptr);
+void one_lordly_high_resistance(ItemEntity *o_ptr);
+void make_weight_ligten(ItemEntity *o_ptr);
+void make_weight_heavy(ItemEntity *o_ptr);
+void add_xtra_ac(ItemEntity *o_ptr);
* @param o_ptr 呪いをかけられる装備オブジェクトの構造体参照ポインタ
* @return 与える呪いのID
*/
-CurseTraitType get_curse(int power, ObjectType *o_ptr)
+CurseTraitType get_curse(int power, ItemEntity *o_ptr)
{
CurseTraitType new_curse;
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
enum class CurseTraitType;
-CurseTraitType get_curse(int power, ObjectType *o_ptr);
+CurseTraitType get_curse(int power, ItemEntity *o_ptr);
void curse_equipment(PlayerType *player_ptr, PERCENTAGE chance, PERCENTAGE heavy_chance);
* @param o_ptr オブジェクト情報への参照ポインタ
* @param gen_flags 生成フラグ(参照渡し)
*/
-static void ego_invest_curse(ObjectType *o_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
+static void ego_invest_curse(ItemEntity *o_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
{
if (gen_flags.has(ItemGenerationTraitType::CURSED)) {
o_ptr->curse_flags.set(CurseTraitType::CURSED);
* @param o_ptr オブジェクト情報への参照ポインタ
* @param gen_flags 生成フラグ(参照渡し)
*/
-static void ego_invest_extra_abilities(ObjectType *o_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
+static void ego_invest_extra_abilities(ItemEntity *o_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
{
if (gen_flags.has(ItemGenerationTraitType::ONE_SUSTAIN)) {
one_sustain(o_ptr);
* @param e_ptr エゴアイテム情報への参照ポインタ
* @param gen_flags 生成フラグ(参照渡し)
*/
-static void ego_interpret_extra_abilities(ObjectType *o_ptr, ego_item_type *e_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
+static void ego_interpret_extra_abilities(ItemEntity *o_ptr, ego_item_type *e_ptr, EnumClassFlagGroup<ItemGenerationTraitType> &gen_flags)
{
for (auto &xtra : e_ptr->xtra_flags) {
if (xtra.mul == 0 || xtra.dev == 0) {
* @param flag フラグ
* @return 持つならtrue、持たないならfalse
*/
-static bool ego_has_flag(ObjectType *o_ptr, ego_item_type *e_ptr, tr_type flag)
+static bool ego_has_flag(ItemEntity *o_ptr, ego_item_type *e_ptr, tr_type flag)
{
if (o_ptr->art_flags.has(flag)) {
return true;
* @param e_ptr エゴアイテム情報への参照ポインタ
* @param lev 生成階
*/
-void ego_invest_extra_attack(ObjectType *o_ptr, ego_item_type *e_ptr, DEPTH lev)
+void ego_invest_extra_attack(ItemEntity *o_ptr, ego_item_type *e_ptr, DEPTH lev)
{
if (!o_ptr->is_weapon()) {
o_ptr->pval = e_ptr->max_pval >= 0 ? 1 : randint1_signed(e_ptr->max_pval);
* @param o_ptr オブジェクト情報への参照ポインタ
* @param lev 生成階
*/
-void apply_ego(ObjectType *o_ptr, DEPTH lev)
+void apply_ego(ItemEntity *o_ptr, DEPTH lev)
{
auto e_ptr = &egos_info[o_ptr->ego_idx];
auto gen_flags = e_ptr->gen_flags;
extern std::map<EgoType, ego_item_type> egos_info;
-class ObjectType;
+class ItemEntity;
class PlayerType;
EgoType get_random_ego(byte slot, bool good);
-void apply_ego(ObjectType *o_ptr, DEPTH lev);
+void apply_ego(ItemEntity *o_ptr, DEPTH lev);
* @param level 生成基準階
* @param power 生成ランク
*/
-AmuletEnchanter::AmuletEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+AmuletEnchanter::AmuletEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
, level(level)
#include "object-enchant/enchanter-base.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class AmuletEnchanter : public EnchanterBase {
public:
- AmuletEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ AmuletEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
virtual ~AmuletEnchanter() = default;
void apply_magic() override;
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
DEPTH level;
int power;
};
#include "system/object-type-definition.h"
#include "system/player-type-definition.h"
-LiteEnchanter::LiteEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, int power)
+LiteEnchanter::LiteEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, int power)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
, power(power)
#include "object-enchant/enchanter-base.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class LiteEnchanter : public EnchanterBase {
public:
- LiteEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, int power);
+ LiteEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, int power);
void apply_magic() override;
protected:
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int power;
void add_dark_flag();
* @param power 生成ランク
* @details power > 2はデバッグ専用.
*/
-OtherItemsEnchanter::OtherItemsEnchanter(PlayerType *player_ptr, ObjectType *o_ptr)
+OtherItemsEnchanter::OtherItemsEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
{
#include "object-enchant/enchanter-base.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class OtherItemsEnchanter : public EnchanterBase {
public:
- OtherItemsEnchanter(PlayerType *player_ptr, ObjectType *o_ptr);
+ OtherItemsEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr);
void apply_magic() override;
void sval_enchant() override{};
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
void enchant_wand_staff();
void generate_figurine();
* @param level 生成基準階
* @param power 生成ランク
*/
-RingEnchanter::RingEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+RingEnchanter::RingEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
, level(level)
#include "object-enchant/enchanter-base.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class RingEnchanter : public EnchanterBase {
public:
- RingEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ RingEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
virtual ~RingEnchanter() = default;
void apply_magic() override;
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
DEPTH level;
int power;
};
* @param level 生成基準階
* @param power 生成ランク
*/
-AbstractProtectorEnchanter::AbstractProtectorEnchanter(ObjectType *o_ptr, DEPTH level, int power)
+AbstractProtectorEnchanter::AbstractProtectorEnchanter(ItemEntity *o_ptr, DEPTH level, int power)
: o_ptr(o_ptr)
, power(power)
{
#include "object-enchant/enchanter-base.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class AbstractProtectorEnchanter : public EnchanterBase {
public:
virtual ~AbstractProtectorEnchanter() = default;
protected:
- AbstractProtectorEnchanter(ObjectType *o_ptr, DEPTH level, int power);
- ObjectType *o_ptr;
+ AbstractProtectorEnchanter(ItemEntity *o_ptr, DEPTH level, int power);
+ ItemEntity *o_ptr;
int power;
};
* @param level 生成基準階
* @param power 生成ランク
*/
-ArmorEnchanter::ArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+ArmorEnchanter::ArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ArmorEnchanter : public AbstractProtectorEnchanter {
public:
virtual ~ArmorEnchanter() = default;
protected:
- ArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ ArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
PlayerType *player_ptr;
* @param level 生成基準階
* @param power 生成ランク
*/
-BootsEnchanter::BootsEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+BootsEnchanter::BootsEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class BootsEnchanter : public AbstractProtectorEnchanter {
public:
- BootsEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ BootsEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-CloakEnchanter::CloakEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+CloakEnchanter::CloakEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class CloakEnchanter : public AbstractProtectorEnchanter {
public:
- CloakEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ CloakEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-CrownEnchanter::CrownEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+CrownEnchanter::CrownEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class CrownEnchanter : public AbstractProtectorEnchanter {
public:
- CrownEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ CrownEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-DragonArmorEnchanter::DragonArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+DragonArmorEnchanter::DragonArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class DragonArmorEnchanter : public AbstractProtectorEnchanter {
public:
- DragonArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ DragonArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-GlovesEnchanter::GlovesEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+GlovesEnchanter::GlovesEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class GlovesEnchanter : public AbstractProtectorEnchanter {
public:
- GlovesEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ GlovesEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-HardArmorEnchanter::HardArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+HardArmorEnchanter::HardArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: ArmorEnchanter{ player_ptr, o_ptr, level, power }
{
}
#include "object-enchant/protector/apply-magic-armor.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class HardArmorEnchanter : public ArmorEnchanter {
public:
- HardArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ HardArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-HelmEnchanter::HelmEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+HelmEnchanter::HelmEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class HelmEnchanter : public AbstractProtectorEnchanter {
public:
- HelmEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ HelmEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-ShieldEnchanter::ShieldEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+ShieldEnchanter::ShieldEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractProtectorEnchanter{ o_ptr, level, power }
, player_ptr(player_ptr)
{
#include "object-enchant/protector/abstract-protector-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ShieldEnchanter : public AbstractProtectorEnchanter {
public:
- ShieldEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ ShieldEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-SoftArmorEnchanter::SoftArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+SoftArmorEnchanter::SoftArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: ArmorEnchanter{ player_ptr, o_ptr, level, power }
{
}
#include "object-enchant/protector/apply-magic-armor.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class SoftArmorEnchanter : public ArmorEnchanter {
public:
- SoftArmorEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ SoftArmorEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @brief チェンソーのノイズ音を表示する
* @param o_ptr チェンソーへの参照ポインタ
*/
-static void print_chainsword_noise(ObjectType *o_ptr)
+static void print_chainsword_noise(ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::CHAINSWORD) || one_in_(2)) {
return;
#include "sv-definition/sv-weapon-types.h"
#include "system/object-type-definition.h"
-AbstractWeaponEnchanter::AbstractWeaponEnchanter(ObjectType *o_ptr, DEPTH level, int power)
+AbstractWeaponEnchanter::AbstractWeaponEnchanter(ItemEntity *o_ptr, DEPTH level, int power)
: o_ptr(o_ptr)
, level(level)
, power(power)
#include "object-enchant/enchanter-base.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class AbstractWeaponEnchanter : public EnchanterBase {
public:
virtual ~AbstractWeaponEnchanter() = default;
protected:
- AbstractWeaponEnchanter(ObjectType *o_ptr, DEPTH level, int power);
- ObjectType *o_ptr;
+ AbstractWeaponEnchanter(ItemEntity *o_ptr, DEPTH level, int power);
+ ItemEntity *o_ptr;
DEPTH level;
int power;
bool should_skip = false;
* @param level 生成基準階
* @param power 生成ランク
*/
-ArrowEnchanter::ArrowEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+ArrowEnchanter::ArrowEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractWeaponEnchanter(o_ptr, level, power)
, player_ptr(player_ptr)
{
#include "object-enchant/weapon/abstract-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ArrowEnchanter : public AbstractWeaponEnchanter {
public:
- ArrowEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ ArrowEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-BowEnchanter::BowEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+BowEnchanter::BowEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractWeaponEnchanter(o_ptr, level, power)
, player_ptr(player_ptr)
{
#include "object-enchant/weapon/abstract-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class BowEnchanter : public AbstractWeaponEnchanter {
public:
- BowEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ BowEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-DiggingEnchanter::DiggingEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+DiggingEnchanter::DiggingEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractWeaponEnchanter(o_ptr, level, power)
, player_ptr(player_ptr)
{
#include "object-enchant/weapon/abstract-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class DiggingEnchanter : public AbstractWeaponEnchanter {
public:
- DiggingEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ DiggingEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
protected:
* @param level 生成基準階
* @param power 生成ランク
*/
-HaftedEnchanter::HaftedEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+HaftedEnchanter::HaftedEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: MeleeWeaponEnchanter(player_ptr, o_ptr, level, power)
{
}
#include "object-enchant/weapon/melee-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class HaftedEnchanter : public MeleeWeaponEnchanter {
public:
- HaftedEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ HaftedEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
* @param level 生成基準階
* @param power 生成ランク
*/
-PolearmEnchanter::PolearmEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+PolearmEnchanter::PolearmEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: MeleeWeaponEnchanter(player_ptr, o_ptr, level, power)
{
}
#include "object-enchant/weapon/melee-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class PolearmEnchanter : public MeleeWeaponEnchanter {
public:
- PolearmEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ PolearmEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
* @param level 生成基準階
* @param power 生成ランク
*/
-SwordEnchanter::SwordEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+SwordEnchanter::SwordEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: MeleeWeaponEnchanter(player_ptr, o_ptr, level, power)
{
}
#include "object-enchant/weapon/melee-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class SwordEnchanter : public MeleeWeaponEnchanter {
public:
- SwordEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ SwordEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
void apply_magic() override;
#include "artifact/random-art-generator.h"
#include "system/object-type-definition.h"
-MeleeWeaponEnchanter::MeleeWeaponEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power)
+MeleeWeaponEnchanter::MeleeWeaponEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power)
: AbstractWeaponEnchanter(o_ptr, level, power)
, player_ptr(player_ptr)
{
#include "object-enchant/weapon/abstract-weapon-enchanter.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class MeleeWeaponEnchanter : public AbstractWeaponEnchanter {
public:
void apply_magic() override;
protected:
- MeleeWeaponEnchanter(PlayerType *player_ptr, ObjectType *o_ptr, DEPTH level, int power);
+ MeleeWeaponEnchanter(PlayerType *player_ptr, ItemEntity *o_ptr, DEPTH level, int power);
PlayerType *player_ptr;
* @param o_ptr 判定するオブジェクトの構造体参照ポインタ
* @return オブジェクトが防具として装備できるならTRUEを返す。
*/
-bool item_tester_hook_wear(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool item_tester_hook_wear(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
if ((o_ptr->tval == ItemKindType::SOFT_ARMOR) && (o_ptr->sval == SV_ABUNAI_MIZUGI)) {
if (player_ptr->psex == SEX_MALE) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool item_tester_hook_wear(PlayerType *player_ptr, const ObjectType *o_ptr);
+bool item_tester_hook_wear(PlayerType *player_ptr, const ItemEntity *o_ptr);
* @param o_ptr 判定したいオブジェクトの構造体参照ポインタ
* @return 食べることが可能ならばTRUEを返す
*/
-bool item_tester_hook_eatable(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool item_tester_hook_eatable(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
if (o_ptr->tval == ItemKindType::FOOD) {
return true;
* @param o_ptr 判定したいオブジェクトの構造体参照ポインタ
* @return 飲むことが可能ならばTRUEを返す
*/
-bool item_tester_hook_quaff(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool item_tester_hook_quaff(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
if (o_ptr->tval == ItemKindType::POTION) {
return true;
* @param o_ptr 破壊可能かを確認したいオブジェクトの構造体参照ポインタ
* @return オブジェクトが破壊可能ならばTRUEを返す
*/
-bool can_player_destroy_object(PlayerType *player_ptr, ObjectType *o_ptr)
+bool can_player_destroy_object(PlayerType *player_ptr, ItemEntity *o_ptr)
{
/* Artifacts cannot be destroyed */
if (!o_ptr->is_artifact()) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool item_tester_hook_eatable(PlayerType *player_ptr, const ObjectType *o_ptr);
-bool item_tester_hook_quaff(PlayerType *player_ptr, const ObjectType *o_ptr);
-bool can_player_destroy_object(PlayerType *player_ptr, ObjectType *o_ptr);
+bool item_tester_hook_eatable(PlayerType *player_ptr, const ItemEntity *o_ptr);
+bool item_tester_hook_quaff(PlayerType *player_ptr, const ItemEntity *o_ptr);
+bool can_player_destroy_object(PlayerType *player_ptr, ItemEntity *o_ptr);
* @param o_ptr 判定したいオブジェクトの構造体参照ポインタ
* @return 利用可能ならばTRUEを返す
*/
-bool item_tester_hook_use(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool item_tester_hook_use(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
if (o_ptr->tval == player_ptr->tval_ammo) {
return true;
* @param o_ptr 判定したいオブ会ジェクトの構造体参照ポインタ
* @return 学習できる魔道書ならばTRUEを返す
*/
-bool item_tester_learn_spell(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool item_tester_learn_spell(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
int32_t choices = realm_choices2[enum2i(player_ptr->pclass)];
PlayerClass pc(player_ptr);
* @param o_ptr 判定したいオブジェクトの構造体参照ポインタ
* @return オブジェクトが高位の魔法書ならばTRUEを返す
*/
-bool item_tester_high_level_book(const ObjectType *o_ptr)
+bool item_tester_high_level_book(const ItemEntity *o_ptr)
{
if ((o_ptr->tval == ItemKindType::LIFE_BOOK) || (o_ptr->tval == ItemKindType::SORCERY_BOOK) || (o_ptr->tval == ItemKindType::NATURE_BOOK) || (o_ptr->tval == ItemKindType::CHAOS_BOOK) || (o_ptr->tval == ItemKindType::DEATH_BOOK) || (o_ptr->tval == ItemKindType::TRUMP_BOOK) || (o_ptr->tval == ItemKindType::CRAFT_BOOK) || (o_ptr->tval == ItemKindType::DEMON_BOOK) || (o_ptr->tval == ItemKindType::CRUSADE_BOOK) || (o_ptr->tval == ItemKindType::MUSIC_BOOK) || (o_ptr->tval == ItemKindType::HEX_BOOK)) {
if (o_ptr->sval > 1) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool item_tester_hook_use(PlayerType *player_ptr, const ObjectType *o_ptr);
-bool item_tester_learn_spell(PlayerType *player_ptr, const ObjectType *o_ptr);
-bool item_tester_high_level_book(const ObjectType *o_ptr);
+bool item_tester_hook_use(PlayerType *player_ptr, const ItemEntity *o_ptr);
+bool item_tester_learn_spell(PlayerType *player_ptr, const ItemEntity *o_ptr);
+bool item_tester_high_level_book(const ItemEntity *o_ptr);
* @param o_ptr 判定するアイテムの情報参照ポインタ
* @return 並ならばTRUEを返す
*/
-bool object_is_nameless_weapon_armour(const ObjectType *o_ptr)
+bool object_is_nameless_weapon_armour(const ItemEntity *o_ptr)
{
/* Require weapon or armour */
if (!o_ptr->is_weapon_armour_ammo()) {
* @param o_ptr 判定するアイテムの情報参照ポインタ
* @return 実際に未鑑定ならばTRUEを返す
*/
-bool object_is_not_identified(const ObjectType *o_ptr)
+bool object_is_not_identified(const ItemEntity *o_ptr)
{
return !o_ptr->is_known();
}
* @param o_ptr 判定するアイテムの情報参照ポインタ
* @return 実際に未鑑定の武器防具ならばTRUEを返す
*/
-bool object_is_not_identified_weapon_armor(const ObjectType *o_ptr)
+bool object_is_not_identified_weapon_armor(const ItemEntity *o_ptr)
{
if (!object_is_not_identified(o_ptr)) {
return false;
* @param o_ptr 判定するアイテムの情報参照ポインタ
* @return 実際に未*鑑定*ならばTRUEを返す
*/
-bool object_is_not_fully_identified(const ObjectType *o_ptr)
+bool object_is_not_fully_identified(const ItemEntity *o_ptr)
{
return !o_ptr->is_known() || !o_ptr->is_fully_known();
}
* @param o_ptr 判定するアイテムの情報参照ポインタ
* @return 実際に未*鑑定*の武器防具ならばTRUEを返す
*/
-bool object_is_not_fully_identified_weapon_armour(const ObjectType *o_ptr)
+bool object_is_not_fully_identified_weapon_armour(const ItemEntity *o_ptr)
{
if (!object_is_not_fully_identified(o_ptr)) {
return false;
#pragma once
-class ObjectType;
-bool object_is_nameless_weapon_armour(const ObjectType *o_ptr);
-bool object_is_not_identified(const ObjectType *o_ptr);
-bool object_is_not_identified_weapon_armor(const ObjectType *o_ptr);
-bool object_is_not_fully_identified(const ObjectType *o_ptr);
-bool object_is_not_fully_identified_weapon_armour(const ObjectType *o_ptr);
+class ItemEntity;
+bool object_is_nameless_weapon_armour(const ItemEntity *o_ptr);
+bool object_is_not_identified(const ItemEntity *o_ptr);
+bool object_is_not_identified_weapon_armor(const ItemEntity *o_ptr);
+bool object_is_not_fully_identified(const ItemEntity *o_ptr);
+bool object_is_not_fully_identified_weapon_armour(const ItemEntity *o_ptr);
* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return オブジェクトが報酬対象になるならTRUEを返す
*/
-bool object_is_bounty(PlayerType *player_ptr, ObjectType *o_ptr)
+bool object_is_bounty(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (o_ptr->tval != ItemKindType::CORPSE) {
return false;
* @param o_ptr 特性短縮表記を得たいオブジェクト構造体の参照ポインタ
* @return 現在クエスト達成目的のアイテムならばTRUEを返す。
*/
-bool object_is_quest_target(QuestId quest_idx, ObjectType *o_ptr)
+bool object_is_quest_target(QuestId quest_idx, ItemEntity *o_ptr)
{
if (!inside_quest(quest_idx)) {
return false;
#include "dungeon/quest.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool object_is_bounty(PlayerType *player_ptr, ObjectType *o_ptr);
-bool object_is_quest_target(QuestId quest_idx, ObjectType *o_ptr);
+bool object_is_bounty(PlayerType *player_ptr, ItemEntity *o_ptr);
+bool object_is_quest_target(QuestId quest_idx, ItemEntity *o_ptr);
* @param o_ptr 対象のオブジェクト構造体ポインタ
* @return オブジェクトが適正武器ならばTRUEを返す
*/
-bool object_is_favorite(PlayerType *player_ptr, const ObjectType *o_ptr)
+bool object_is_favorite(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
/* Only melee weapons match */
if (!(o_ptr->tval == ItemKindType::POLEARM || o_ptr->tval == ItemKindType::SWORD || o_ptr->tval == ItemKindType::DIGGING || o_ptr->tval == ItemKindType::HAFTED)) {
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool object_is_favorite(PlayerType *player_ptr, const ObjectType *o_ptr);
+bool object_is_favorite(PlayerType *player_ptr, const ItemEntity *o_ptr);
{
}
-bool QuaffEffects::influence(const ObjectType &o_ref)
+bool QuaffEffects::influence(const ItemEntity &o_ref)
{
if (o_ref.tval != ItemKindType::POTION) {
return false;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
class QuaffEffects {
public:
QuaffEffects(PlayerType *player_ptr);
- bool influence(const ObjectType &o_ref);
+ bool influence(const ItemEntity &o_ref);
private:
PlayerType *player_ptr;
return ItemUseChecker(this->player_ptr).check_stun(_("朦朧としていて瓶の蓋を開けられなかった！", "You are too stunned to quaff it!"));
}
-ObjectType ObjectQuaffEntity::copy_object(const INVENTORY_IDX item)
+ItemEntity ObjectQuaffEntity::copy_object(const INVENTORY_IDX item)
{
auto *tmp_o_ptr = ref_item(this->player_ptr, item);
auto o_val = *tmp_o_ptr;
return o_val;
}
-void ObjectQuaffEntity::moisten(const ObjectType &o_ref)
+void ObjectQuaffEntity::moisten(const ItemEntity &o_ref)
{
switch (PlayerRace(this->player_ptr).food()) {
case PlayerRaceFoodType::WATER:
}
}
-void ObjectQuaffEntity::change_virtue_as_quaff(const ObjectType &o_ref)
+void ObjectQuaffEntity::change_virtue_as_quaff(const ItemEntity &o_ref)
{
if (o_ref.is_aware()) {
return;
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ObjectQuaffEntity {
public:
bool can_influence();
bool can_quaff();
- ObjectType copy_object(const INVENTORY_IDX item);
- void moisten(const ObjectType &o_ref);
- void change_virtue_as_quaff(const ObjectType &o_ref);
+ ItemEntity copy_object(const INVENTORY_IDX item);
+ void moisten(const ItemEntity &o_ref);
+ void change_virtue_as_quaff(const ItemEntity &o_ref);
};
#include "term/screen-processor.h"
#include "util/angband-files.h"
-ParchmentReadExecutor::ParchmentReadExecutor(PlayerType *player_ptr, ObjectType *o_ptr)
+ParchmentReadExecutor::ParchmentReadExecutor(PlayerType *player_ptr, ItemEntity *o_ptr)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
{
#include "object-use/read/read-executor-base.h"
class PlayerType;
-class ObjectType;
+class ItemEntity;
class ParchmentReadExecutor : public ReadExecutorBase {
public:
- ParchmentReadExecutor(PlayerType *player_ptr, ObjectType *o_ptr);
+ ParchmentReadExecutor(PlayerType *player_ptr, ItemEntity *o_ptr);
bool read() override;
bool is_identified() const override;
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
};
return ItemUseChecker(this->player_ptr).check_stun(_("朦朧としていて読めなかった！", "You too stunned to read it!"));
}
-void ObjectReadEntity::change_virtue_as_read(ObjectType &o_ref)
+void ObjectReadEntity::change_virtue_as_read(ItemEntity &o_ref)
{
if (o_ref.is_aware()) {
return;
chg_virtue(this->player_ptr, V_KNOWLEDGE, -1);
}
-void ObjectReadEntity::gain_exp_from_item_use(ObjectType *o_ptr, bool is_identified)
+void ObjectReadEntity::gain_exp_from_item_use(ItemEntity *o_ptr, bool is_identified)
{
if (!is_identified || o_ptr->is_aware()) {
return;
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ObjectReadEntity {
public:
INVENTORY_IDX item;
bool can_read() const;
- void change_virtue_as_read(ObjectType &o_ref);
- void gain_exp_from_item_use(ObjectType *o_ptr, bool is_identified);
+ void change_virtue_as_read(ItemEntity &o_ref);
+ void gain_exp_from_item_use(ItemEntity *o_ptr, bool is_identified);
};
#include "object/tval-types.h"
#include "system/object-type-definition.h"
-std::unique_ptr<ReadExecutorBase> ReadExecutorFactory::create(PlayerType *player_ptr, ObjectType *o_ptr, bool known)
+std::unique_ptr<ReadExecutorBase> ReadExecutorFactory::create(PlayerType *player_ptr, ItemEntity *o_ptr, bool known)
{
if (o_ptr->tval == ItemKindType::SCROLL) {
return std::make_unique<ScrollReadExecutor>(player_ptr, o_ptr, known);
#include "object-use/read/read-executor-base.h"
#include <memory>
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ReadExecutorFactory {
public:
- static std::unique_ptr<ReadExecutorBase> create(PlayerType *player_ptr, ObjectType *o_ptr, bool known);
+ static std::unique_ptr<ReadExecutorBase> create(PlayerType *player_ptr, ItemEntity *o_ptr, bool known);
private:
ReadExecutorFactory() = delete;
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
-ScrollReadExecutor::ScrollReadExecutor(PlayerType *player_ptr, ObjectType *o_ptr, bool known)
+ScrollReadExecutor::ScrollReadExecutor(PlayerType *player_ptr, ItemEntity *o_ptr, bool known)
: player_ptr(player_ptr)
, o_ptr(o_ptr)
, known(known)
#include "object-use/read/read-executor-base.h"
class PlayerType;
-class ObjectType;
+class ItemEntity;
class ScrollReadExecutor : public ReadExecutorBase {
public:
- ScrollReadExecutor(PlayerType *player_ptr, ObjectType *o_ptr, bool known);
+ ScrollReadExecutor(PlayerType *player_ptr, ItemEntity *o_ptr, bool known);
bool is_identified() const override;
bool read() override;
private:
PlayerType *player_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
bool known;
bool ident = false;
};
#include "view/object-describer.h"
#include "wizard/wizard-messages.h"
-ObjectThrowEntity::ObjectThrowEntity(PlayerType *player_ptr, ObjectType *q_ptr, const int delay_factor_val, const int mult, const bool boomerang, const OBJECT_IDX shuriken)
+ObjectThrowEntity::ObjectThrowEntity(PlayerType *player_ptr, ItemEntity *q_ptr, const int delay_factor_val, const int mult, const bool boomerang, const OBJECT_IDX shuriken)
: q_ptr(q_ptr)
, player_ptr(player_ptr)
, shuriken(shuriken)
concptr q, s;
q = _("どの武器を投げますか? ", "Throw which item? ");
s = _("投げる武器がない。", "You have nothing to throw.");
- this->o_ptr = choose_object(this->player_ptr, &this->item, q, s, USE_EQUIP, FuncItemTester(&ObjectType::is_throwable));
+ this->o_ptr = choose_object(this->player_ptr, &this->item, q, s, USE_EQUIP, FuncItemTester(&ItemEntity::is_throwable));
if (!this->o_ptr) {
flush();
return false;
struct grid_type;
struct monster_type;
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ObjectThrowEntity {
public:
ObjectThrowEntity() = default;
ObjectThrowEntity(
- PlayerType *player_ptr, ObjectType *q_ptr, const int delay_factor_val, const int mult, const bool boomerang, const OBJECT_IDX shuriken);
+ PlayerType *player_ptr, ItemEntity *q_ptr, const int delay_factor_val, const int mult, const bool boomerang, const OBJECT_IDX shuriken);
virtual ~ObjectThrowEntity() = default;
- ObjectType *q_ptr;
+ ItemEntity *q_ptr;
OBJECT_IDX item{};
POSITION y{};
POSITION x{};
int tdis{};
int cur_dis{};
int visible{};
- ObjectType *o_ptr{};
+ ItemEntity *o_ptr{};
bool hit_wall = false;
bool return_when_thrown = false;
GAME_TEXT o_name[MAX_NLEN]{};
o_ptr->pval--;
if ((this->item >= 0) && (o_ptr->number > 1)) {
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->copy_from(o_ptr);
q_ptr->number = 1;
* @param test_func そのオブジェクトが条件に合うならtrueを返すメンバ関数を指定する
*/
FuncItemTester::FuncItemTester(TestMemberFunctionPtr test_func)
- : test_func([f = test_func](PlayerType *, const ObjectType *o_ptr) { return (o_ptr->*f)(); })
+ : test_func([f = test_func](PlayerType *, const ItemEntity *o_ptr) { return (o_ptr->*f)(); })
{
}
/**
* @brief Construct a new Func Item Tester:: Func Item Tester object
*
- * @param test_func 引数に ObjectType へのポインタを取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
+ * @param test_func 引数に ItemEntity へのポインタを取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
*/
-FuncItemTester::FuncItemTester(std::function<bool(const ObjectType *)> test_func)
- : test_func([f = std::move(test_func)](PlayerType *, const ObjectType *o_ptr) { return f(o_ptr); })
+FuncItemTester::FuncItemTester(std::function<bool(const ItemEntity *)> test_func)
+ : test_func([f = std::move(test_func)](PlayerType *, const ItemEntity *o_ptr) { return f(o_ptr); })
{
}
/*!
* @brief Construct a new Func Item Tester:: Func Item Tester object
*
- * @param test_func 引数に PlayerType へのポインタと ObjectType へのポインタを取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
+ * @param test_func 引数に PlayerType へのポインタと ItemEntity へのポインタを取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
* @param player_ptr test_func の PlayerType へのポインタの引数に対して渡すポインタを指定する
*/
-FuncItemTester::FuncItemTester(std::function<bool(PlayerType *, const ObjectType *)> test_func, PlayerType *player_ptr)
+FuncItemTester::FuncItemTester(std::function<bool(PlayerType *, const ItemEntity *)> test_func, PlayerType *player_ptr)
: test_func(std::move(test_func))
, player_ptr(player_ptr)
{
/*!
* @brief Construct a new Func Item Tester:: Func Item Tester object
*
- * @param test_func 引数に PlayerType へのポインタと ObjectType へのポインタと StoreSaleType を取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
+ * @param test_func 引数に PlayerType へのポインタと ItemEntity へのポインタと StoreSaleType を取り、そのオブジェクトが条件に合うならtrueを返す関数を指定する
* @param player_ptr test_func の PlayerType へのポインタの引数に対して渡すポインタを指定する
*/
-FuncItemTester::FuncItemTester(std::function<bool(PlayerType *, const ObjectType *, StoreSaleType)> test_func, PlayerType *player_ptr, StoreSaleType store_num)
- : test_func([test_func = std::move(test_func), store_num](PlayerType *player_ptr, const ObjectType *o_ptr) { return test_func(player_ptr, o_ptr, store_num); })
+FuncItemTester::FuncItemTester(std::function<bool(PlayerType *, const ItemEntity *, StoreSaleType)> test_func, PlayerType *player_ptr, StoreSaleType store_num)
+ : test_func([test_func = std::move(test_func), store_num](PlayerType *player_ptr, const ItemEntity *o_ptr) { return test_func(player_ptr, o_ptr, store_num); })
, player_ptr(player_ptr)
{
}
* @return アイテムが条件を満たしているならtrueを返す
* @details 最初にk_idxが無効でないか等の共通の判定を行った後に子クラスで実装される okay_impl 関数の結果を返す
*/
-bool ItemTester::okay(const ObjectType *o_ptr) const
+bool ItemTester::okay(const ItemEntity *o_ptr) const
{
if (o_ptr->k_idx == 0) {
return false;
return this->okay_impl(o_ptr);
}
-bool TvalItemTester::okay_impl(const ObjectType *o_ptr) const
+bool TvalItemTester::okay_impl(const ItemEntity *o_ptr) const
{
return this->tval == o_ptr->tval;
}
-bool FuncItemTester::okay_impl(const ObjectType *o_ptr) const
+bool FuncItemTester::okay_impl(const ItemEntity *o_ptr) const
{
return this->test_func(this->player_ptr, o_ptr);
}
#include <memory>
enum class StoreSaleType;
-class ObjectType;
+class ItemEntity;
class PlayerType;
/*!
class ItemTester {
public:
virtual ~ItemTester() = default;
- bool okay(const ObjectType *o_ptr) const;
+ bool okay(const ItemEntity *o_ptr) const;
virtual std::unique_ptr<ItemTester> clone() const = 0;
protected:
ItemTester() = default;
private:
- virtual bool okay_impl(const ObjectType *o_ptr) const = 0;
+ virtual bool okay_impl(const ItemEntity *o_ptr) const = 0;
};
/**
AllMatchItemTester() = default;
private:
- virtual bool okay_impl(const ObjectType *) const
+ virtual bool okay_impl(const ItemEntity *) const
{
return true;
}
explicit TvalItemTester(ItemKindType tval);
private:
- virtual bool okay_impl(const ObjectType *o_ptr) const;
+ virtual bool okay_impl(const ItemEntity *o_ptr) const;
ItemKindType tval;
};
*/
class FuncItemTester : public CloneableItemTester<FuncItemTester> {
public:
- using TestMemberFunctionPtr = bool (ObjectType::*)() const;
+ using TestMemberFunctionPtr = bool (ItemEntity::*)() const;
explicit FuncItemTester(TestMemberFunctionPtr test_func);
- explicit FuncItemTester(std::function<bool(const ObjectType *)> test_func);
- explicit FuncItemTester(std::function<bool(PlayerType *, const ObjectType *)> test_func, PlayerType *player_ptr);
- explicit FuncItemTester(std::function<bool(PlayerType *, const ObjectType *, StoreSaleType)> test_func, PlayerType *player_ptr, StoreSaleType store_num);
+ explicit FuncItemTester(std::function<bool(const ItemEntity *)> test_func);
+ explicit FuncItemTester(std::function<bool(PlayerType *, const ItemEntity *)> test_func, PlayerType *player_ptr);
+ explicit FuncItemTester(std::function<bool(PlayerType *, const ItemEntity *, StoreSaleType)> test_func, PlayerType *player_ptr, StoreSaleType store_num);
private:
- virtual bool okay_impl(const ObjectType *o_ptr) const;
+ virtual bool okay_impl(const ItemEntity *o_ptr) const;
- std::function<bool(PlayerType *, const ObjectType *)> test_func;
+ std::function<bool(PlayerType *, const ItemEntity *)> test_func;
PlayerType *player_ptr;
};
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 現在光源として使っているオブジェクトの構造体参照ポインタ
*/
-void notice_lite_change(PlayerType *player_ptr, ObjectType *o_ptr)
+void notice_lite_change(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if ((o_ptr->fuel < 100) || (!(o_ptr->fuel % 100))) {
player_ptr->window_flags |= (PW_EQUIP);
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
void reduce_lite_life(PlayerType *player_ptr);
-void notice_lite_change(PlayerType *player_ptr, ObjectType *o_ptr);
+void notice_lite_change(PlayerType *player_ptr, ItemEntity *o_ptr);
* Does a given class of objects (usually) hate acid?
* Note that acid can either melt or corrode something.
*/
-bool BreakerAcid::hates(ObjectType *o_ptr) const
+bool BreakerAcid::hates(ItemEntity *o_ptr) const
{
/* Analyze the type */
switch (o_ptr->tval) {
* @param o_ptr アイテムの情報参照ポインタ
* @return 破損するならばTRUEを返す
*/
-bool BreakerElec::hates(ObjectType *o_ptr) const
+bool BreakerElec::hates(ItemEntity *o_ptr) const
{
switch (o_ptr->tval) {
case ItemKindType::RING:
* Hafted/Polearm weapons have wooden shafts.
* Arrows/Bows are mostly wooden.
*/
-bool BreakerFire::hates(ObjectType *o_ptr) const
+bool BreakerFire::hates(ItemEntity *o_ptr) const
{
/* Analyze the type */
switch (o_ptr->tval) {
* @param o_ptr アイテムの情報参照ポインタ
* @return 破損するならばTRUEを返す
*/
-bool BreakerCold::hates(ObjectType *o_ptr) const
+bool BreakerCold::hates(ItemEntity *o_ptr) const
{
switch (o_ptr->tval) {
case ItemKindType::POTION:
* @return 破損するならばTRUEを返す
* @todo 統合を検討
*/
-bool ObjectBreaker::can_destroy(ObjectType *o_ptr) const
+bool ObjectBreaker::can_destroy(ItemEntity *o_ptr) const
{
if (!this->hates(o_ptr)) {
return false;
* @details
* Note that artifacts never break, see the "drop_near()" function.
*/
-PERCENTAGE breakage_chance(PlayerType *player_ptr, ObjectType *o_ptr, bool has_archer_bonus, SPELL_IDX snipe_type)
+PERCENTAGE breakage_chance(PlayerType *player_ptr, ItemEntity *o_ptr, bool has_archer_bonus, SPELL_IDX snipe_type)
{
/* Examine the snipe type */
if (snipe_type) {
#include "object-enchant/tr-types.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool potion_smash_effect(PlayerType *player_ptr, MONSTER_IDX who, POSITION y, POSITION x, KIND_OBJECT_IDX k_idx);
-PERCENTAGE breakage_chance(PlayerType *player_ptr, ObjectType *o_ptr, bool has_archer_bonus, SPELL_IDX snipe_type);
+PERCENTAGE breakage_chance(PlayerType *player_ptr, ItemEntity *o_ptr, bool has_archer_bonus, SPELL_IDX snipe_type);
class ObjectBreaker {
protected:
public:
virtual ~ObjectBreaker() = default;
- bool can_destroy(ObjectType *o_ptr) const;
- virtual bool hates(ObjectType *o_ptr) const = 0;
+ bool can_destroy(ItemEntity *o_ptr) const;
+ virtual bool hates(ItemEntity *o_ptr) const = 0;
private:
tr_type ignore_flg;
public:
BreakerAcid();
virtual ~BreakerAcid() = default;
- bool hates(ObjectType *o_ptr) const;
+ bool hates(ItemEntity *o_ptr) const;
};
class BreakerElec : public ObjectBreaker {
public:
BreakerElec();
virtual ~BreakerElec() = default;
- bool hates(ObjectType *o_ptr) const;
+ bool hates(ItemEntity *o_ptr) const;
};
class BreakerFire : public ObjectBreaker {
public:
BreakerFire();
virtual ~BreakerFire() = default;
- bool hates(ObjectType *o_ptr) const;
+ bool hates(ItemEntity *o_ptr) const;
};
class BreakerCold : public ObjectBreaker {
public:
BreakerCold();
virtual ~BreakerCold() = default;
- bool hates(ObjectType *o_ptr) const;
+ bool hates(ItemEntity *o_ptr) const;
};
* @param o_ptr フラグ取得元のオブジェクト構造体ポインタ
* @param flgs フラグ情報を受け取る配列
*/
-static void object_flags_lite(const ObjectType *o_ptr, TrFlags &flgs)
+static void object_flags_lite(const ItemEntity *o_ptr, TrFlags &flgs)
{
if (!o_ptr->is_ego()) {
return;
* @param o_ptr フラグ取得元のオブジェクト構造体ポインタ
* @param flgs フラグ情報を受け取る配列
*/
-TrFlags object_flags(const ObjectType *o_ptr)
+TrFlags object_flags(const ItemEntity *o_ptr)
{
auto *k_ptr = &baseitems_info[o_ptr->k_idx];
* @param o_ptr フラグ取得元のオブジェクト構造体ポインタ
* @param flgs フラグ情報を受け取る配列
*/
-TrFlags object_flags_known(const ObjectType *o_ptr)
+TrFlags object_flags_known(const ItemEntity *o_ptr)
{
bool spoil = false;
auto *k_ptr = &baseitems_info[o_ptr->k_idx];
#include "object-enchant/tr-flags.h"
-class ObjectType;
-TrFlags object_flags(const ObjectType *o_ptr);
-TrFlags object_flags_known(const ObjectType *o_ptr);
+class ItemEntity;
+TrFlags object_flags(const ItemEntity *o_ptr);
+TrFlags object_flags_known(const ItemEntity *o_ptr);
/**
* @brief アイテムリスト(床上スタック/モンスター所持)を管理するクラス
*
- * @details ObjectType 自体を保持するのではなく、フロア全体の ObjectType 配列上のアイテムの要素番号を保持する
+ * @details ItemEntity 自体を保持するのではなく、フロア全体の ItemEntity 配列上のアイテムの要素番号を保持する
*/
class ObjectIndexList {
public:
* @param o_ptr 名称を取得する元のオブジェクト構造体参照ポインタ
* @return concptr 発動名称を返す文字列ポインタ
*/
-static concptr item_activation_dragon_breath(ObjectType *o_ptr)
+static concptr item_activation_dragon_breath(ItemEntity *o_ptr)
{
static char desc[256];
int n = 0;
* @param o_ptr 名称を取得する元のオブジェクト構造体参照ポインタ
* @return concptr 発動名称を返す文字列ポインタ
*/
-static concptr item_activation_aux(ObjectType *o_ptr)
+static concptr item_activation_aux(ItemEntity *o_ptr)
{
static char activation_detail[512];
char timeout[64];
* @param o_ptr 名称を取得する元のオブジェクト構造体参照ポインタ
* @return concptr 発動名称を返す文字列ポインタ
*/
-concptr activation_explanation(ObjectType *o_ptr)
+concptr activation_explanation(ItemEntity *o_ptr)
{
auto flgs = object_flags(o_ptr);
if (flgs.has_not(TR_ACTIVATE)) {
* @param o_ptr 名称を取得する元のオブジェクト構造体参照ポインタ
* @return 対応する装備部位ID
*/
-int16_t wield_slot(PlayerType *player_ptr, const ObjectType *o_ptr)
+int16_t wield_slot(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::DIGGING:
return (get_realm1_book(player_ptr) == book_tval) || (get_realm2_book(player_ptr) == book_tval);
}
-ObjectType *ref_item(PlayerType *player_ptr, INVENTORY_IDX item)
+ItemEntity *ref_item(PlayerType *player_ptr, INVENTORY_IDX item)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
return item >= 0 ? &player_ptr->inventory_list[item] : &(floor_ptr->o_list[0 - item]);
#define OBJ_GOLD_LIST 480 /* First "gold" entry */
-class ObjectType;
+class ItemEntity;
class PlayerType;
-concptr activation_explanation(ObjectType *o_ptr);
+concptr activation_explanation(ItemEntity *o_ptr);
char index_to_label(int i);
-int16_t wield_slot(PlayerType *player_ptr, const ObjectType *o_ptr);
+int16_t wield_slot(PlayerType *player_ptr, const ItemEntity *o_ptr);
bool check_book_realm(PlayerType *player_ptr, const ItemKindType book_tval, const OBJECT_SUBTYPE_VALUE book_sval);
-ObjectType *ref_item(PlayerType *player_ptr, INVENTORY_IDX item);
+ItemEntity *ref_item(PlayerType *player_ptr, INVENTORY_IDX item);
/*
- * @brief How object is marked (flags in ObjectType.mark)
+ * @brief How an entity of an item is marked (flags in ItemEntity::marked)
* @date 2020/05/28
* @author Hourier
* @details
* are being dropped, it makes for a neater message to leave the original\n
* stack's pval alone. -LM-\n
*/
-void distribute_charges(ObjectType *o_ptr, ObjectType *q_ptr, int amt)
+void distribute_charges(ItemEntity *o_ptr, ItemEntity *q_ptr, int amt)
{
if ((o_ptr->tval != ItemKindType::WAND) && (o_ptr->tval != ItemKindType::ROD)) {
return;
* charges of the stack needs to be reduced, unless all the items are\n
* being destroyed. -LM-\n
*/
-void reduce_charges(ObjectType *o_ptr, int amt)
+void reduce_charges(ItemEntity *o_ptr, int amt)
{
if (((o_ptr->tval == ItemKindType::WAND) || (o_ptr->tval == ItemKindType::ROD)) && (amt < o_ptr->number)) {
o_ptr->pval -= o_ptr->pval * amt / o_ptr->number;
* @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
* @return 重ね合わせ可能なアイテム数
*/
-int object_similar_part(const ObjectType *o_ptr, const ObjectType *j_ptr)
+int object_similar_part(const ItemEntity *o_ptr, const ItemEntity *j_ptr)
{
const int max_stack_size = 99;
int max_num = max_stack_size;
* @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
* @return 重ね合わせ可能ならばTRUEを返す。
*/
-bool object_similar(const ObjectType *o_ptr, const ObjectType *j_ptr)
+bool object_similar(const ItemEntity *o_ptr, const ItemEntity *j_ptr)
{
int total = o_ptr->number + j_ptr->number;
int max_num = object_similar_part(o_ptr, j_ptr);
* @param o_ptr 重ね合わせ先のオブジェクトの構造体参照ポインタ
* @param j_ptr 重ね合わせ元のオブジェクトの構造体参照ポインタ
*/
-void object_absorb(ObjectType *o_ptr, ObjectType *j_ptr)
+void object_absorb(ItemEntity *o_ptr, ItemEntity *j_ptr)
{
int max_num = object_similar_part(o_ptr, j_ptr);
int total = o_ptr->number + j_ptr->number;
#pragma once
-class ObjectType;
-void distribute_charges(ObjectType *o_ptr, ObjectType *q_ptr, int amt);
-void reduce_charges(ObjectType *o_ptr, int amt);
-int object_similar_part(const ObjectType *o_ptr, const ObjectType *j_ptr);
-bool object_similar(const ObjectType *o_ptr, const ObjectType *j_ptr);
-void object_absorb(ObjectType *o_ptr, ObjectType *j_ptr);
+class ItemEntity;
+void distribute_charges(ItemEntity *o_ptr, ItemEntity *q_ptr, int amt);
+void reduce_charges(ItemEntity *o_ptr, int amt);
+int object_similar_part(const ItemEntity *o_ptr, const ItemEntity *j_ptr);
+bool object_similar(const ItemEntity *o_ptr, const ItemEntity *j_ptr);
+void object_absorb(ItemEntity *o_ptr, ItemEntity *j_ptr);
* @param plusses フラグに与える価格の基本重み
* @return オブジェクトのフラグ価格
*/
-PRICE flag_cost(const ObjectType *o_ptr, int plusses)
+PRICE flag_cost(const ItemEntity *o_ptr, int plusses)
{
PRICE total = 0;
auto *k_ptr = &baseitems_info[o_ptr->k_idx];
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-int32_t flag_cost(const ObjectType *o_ptr, int plusses);
+int32_t flag_cost(const ItemEntity *o_ptr, int plusses);
*\n
* Every wearable item with a "pval" bonus is worth extra (see below).\n
*/
-PRICE object_value_real(const ObjectType *o_ptr)
+PRICE object_value_real(const ItemEntity *o_ptr)
{
auto *k_ptr = &baseitems_info[o_ptr->k_idx];
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-PRICE object_value_real(const ObjectType *o_ptr);
+PRICE object_value_real(const ItemEntity *o_ptr);
* Calculate spell damages
* @return 警告を行う
*/
-ObjectType *choose_warning_item(PlayerType *player_ptr)
+ItemEntity *choose_warning_item(PlayerType *player_ptr)
{
int choices[INVEN_TOTAL - INVEN_MAIN_HAND];
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-ObjectType *choose_warning_item(PlayerType *player_ptr);
+ItemEntity *choose_warning_item(PlayerType *player_ptr);
bool process_warning(PlayerType *player_ptr, POSITION xx, POSITION yy);
* @param mode 表示オプション
* @return 特筆すべき情報が一つでもあった場合TRUE、一つもなく表示がキャンセルされた場合FALSEを返す。
*/
-bool screen_object(PlayerType *player_ptr, ObjectType *o_ptr, BIT_FLAGS mode)
+bool screen_object(PlayerType *player_ptr, ItemEntity *o_ptr, BIT_FLAGS mode)
{
char temp[70 * 20];
concptr info[128];
#define SCROBJ_FAKE_OBJECT 0x00000001
#define SCROBJ_FORCE_DETAIL 0x00000002
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool screen_object(PlayerType *player_ptr, ObjectType *o_ptr, BIT_FLAGS mode);
+bool screen_object(PlayerType *player_ptr, ItemEntity *o_ptr, BIT_FLAGS mode);
*\n
* This routine also removes any inscriptions generated by "feelings".\n
*/
-void object_known(ObjectType *o_ptr)
+void object_known(ItemEntity *o_ptr)
{
o_ptr->feeling = FEEL_NONE;
o_ptr->ident &= ~(IDENT_SENSE);
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr ＊鑑定＊済にするオブジェクトの構造体参照ポインタ
*/
-void object_aware(PlayerType *player_ptr, const ObjectType *o_ptr)
+void object_aware(PlayerType *player_ptr, const ItemEntity *o_ptr)
{
const bool is_already_awared = o_ptr->is_aware();
}
// playrecordに識別したアイテムを記録
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
GAME_TEXT o_name[MAX_NLEN];
q_ptr = &forge;
* Something has been "sampled"
* @param o_ptr 試行済にするオブジェクトの構造体参照ポインタ
*/
-void object_tried(const ObjectType *o_ptr)
+void object_tried(const ItemEntity *o_ptr)
{
baseitems_info[o_ptr->k_idx].tried = true;
}
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void object_known(ObjectType *o_ptr);
-void object_aware(PlayerType *player_ptr, const ObjectType *o_ptr);
-void object_tried(const ObjectType *o_ptr);
+void object_known(ItemEntity *o_ptr);
+void object_aware(PlayerType *player_ptr, const ItemEntity *o_ptr);
+void object_tried(const ItemEntity *o_ptr);
{
PLAYER_LEVEL plev = player_ptr->lev;
bool heavy = false;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (player_ptr->effects()->confusion()->is_confused()) {
return;
}
void sense_inventory2(PlayerType *player_ptr)
{
PLAYER_LEVEL plev = player_ptr->lev;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (player_ptr->effects()->confusion()->is_confused()) {
return;
* @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
* @return 擬似鑑定結果のIDを返す。
*/
-item_feel_type pseudo_value_check_heavy(ObjectType *o_ptr)
+item_feel_type pseudo_value_check_heavy(ItemEntity *o_ptr)
{
if (o_ptr->is_artifact()) {
if (o_ptr->is_cursed() || o_ptr->is_broken()) {
* @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
* @return 擬似鑑定結果のIDを返す。
*/
-item_feel_type pseudo_value_check_light(ObjectType *o_ptr)
+item_feel_type pseudo_value_check_light(ItemEntity *o_ptr)
{
if (o_ptr->is_cursed()) {
return FEEL_CURSED;
#include "object-enchant/item-feeling.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
void sense_inventory1(PlayerType *player_ptr);
void sense_inventory2(PlayerType *player_ptr);
-item_feel_type pseudo_value_check_heavy(ObjectType *o_ptr);
-item_feel_type pseudo_value_check_light(ObjectType *o_ptr);
+item_feel_type pseudo_value_check_heavy(ItemEntity *o_ptr);
+item_feel_type pseudo_value_check_light(ItemEntity *o_ptr);
*/
static bool acid_minus_ac(PlayerType *player_ptr)
{
- ObjectType *o_ptr = nullptr;
+ ItemEntity *o_ptr = nullptr;
switch (randint1(7)) {
case 1:
o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
}
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (o_ptr->tval != ItemKindType::CHEST) {
continue;
return _("[不明]", "[Unknown]");
}
-void PlayerSkill::gain_melee_weapon_exp(const ObjectType *o_ptr)
+void PlayerSkill::gain_melee_weapon_exp(const ItemEntity *o_ptr)
{
const GainAmountList gain_amount_list{ { 80, 10, 1, (one_in_(2) ? 1 : 0) } };
constexpr GainAmountList others_gain_amount_list{ { 8, 1, 0, 0 } };
}
}
-void PlayerSkill::gain_range_weapon_exp(const ObjectType *o_ptr)
+void PlayerSkill::gain_range_weapon_exp(const ItemEntity *o_ptr)
{
constexpr GainAmountList gain_amount_list{ { 80, 25, 10, 2 } };
constexpr GainAmountList others_gain_amount_list{ { 8, 2, 0, 0 } };
extern std::vector<skill_table> class_skills_info;
struct monster_race;
-class ObjectType;
+class ItemEntity;
class PlayerType;
class PlayerSkill {
static concptr skill_name(PlayerSkillKindType skill);
static concptr skill_rank_str(PlayerSkillRank rank);
- void gain_melee_weapon_exp(const ObjectType *o_ptr);
- void gain_range_weapon_exp(const ObjectType *o_ptr);
+ void gain_melee_weapon_exp(const ItemEntity *o_ptr);
+ void gain_range_weapon_exp(const ItemEntity *o_ptr);
void gain_martial_arts_skill_exp();
void gain_two_weapon_skill_exp();
void gain_riding_skill_exp_on_melee_attack(const monster_race *r_ptr);
*/
BIT_FLAGS check_equipment_flags(PlayerType *player_ptr, tr_type tr_flag)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
void check_no_flowed(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
bool has_sw = false, has_kabe = false;
player_ptr->no_flowed = false;
BIT_FLAGS has_warning(PlayerType *player_ptr)
{
BIT_FLAGS result = 0L;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
void update_curses(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
player_ptr->cursed.clear();
player_ptr->cursed_special.clear();
void update_extra_blows(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
player_ptr->extra_blows[0] = player_ptr->extra_blows[1] = 0;
const melee_type melee_type = player_melee_type(player_ptr);
*/
BIT_FLAGS has_vuln_curse(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
*/
BIT_FLAGS has_heavy_vuln_curse(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
* @param o_ptr 判定する射撃武器のアイテム情報参照ポインタ
* @return 重すぎるならばTRUE
*/
-static bool is_heavy_shoot(PlayerType *player_ptr, ObjectType *o_ptr)
+static bool is_heavy_shoot(PlayerType *player_ptr, ItemEntity *o_ptr)
{
return calc_bow_weight_limit(player_ptr) < (o_ptr->weight / 10);
}
{
WEIGHT weight = 0;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
for (int i = 0; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
static void update_bonuses(PlayerType *player_ptr)
{
auto empty_hands_status = empty_hands(player_ptr, true);
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
/* Save the old vision stuff */
BIT_FLAGS old_telepathy = player_ptr->telepathy;
if (any_bits(mp_ptr->spell_xtra, extra_magic_glove_reduce_mana)) {
player_ptr->cumber_glove = false;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
auto flgs = object_flags(o_ptr);
if (o_ptr->k_idx && flgs.has_not(TR_FREE_ACT) && flgs.has_not(TR_DEC_MANA) && flgs.has_not(TR_EASY_SPELL) && !((flgs.has(TR_MAGIC_MASTERY)) && (o_ptr->pval > 0)) && !((flgs.has(TR_DEX)) && (o_ptr->pval > 0))) {
* @param o_ptr 計算する射撃武器のアイテム情報参照ポインタ
* @return 射撃倍率の値(100で1.00倍)
*/
-int16_t calc_num_fire(PlayerType *player_ptr, ObjectType *o_ptr)
+int16_t calc_num_fire(PlayerType *player_ptr, ItemEntity *o_ptr)
{
int extra_shots = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *q_ptr;
+ ItemEntity *q_ptr;
q_ptr = &player_ptr->inventory_list[i];
if (!q_ptr->k_idx) {
continue;
pow += ((c_ptr->x_dev * player_ptr->lev / 10) + (ap_ptr->a_dev * player_ptr->lev / 50));
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
pow += (c_ptr->x_srh * player_ptr->lev / 10);
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
pow += (c_ptr->x_fos * player_ptr->lev / 10);
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
*/
static ACTION_SKILL_POWER calc_skill_dig(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
ACTION_SKILL_POWER pow;
static int16_t calc_num_blow(PlayerType *player_ptr, int i)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int16_t num_blow = 1;
o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
auto flags = object_flags(o_ptr);
if (!o_ptr->k_idx) {
pow += ((int)(adj_str_th[player_ptr->stat_index[A_STR]]) - 128);
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_BOW];
if (o_ptr->k_idx) {
if (o_ptr->curse_flags.has(CurseTraitType::LOW_MELEE)) {
static int16_t calc_to_damage_misc(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int16_t to_dam = 0;
static int16_t calc_to_hit_misc(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
int16_t to_hit = 0;
*/
bool player_has_no_spellbooks(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
for (int i = 0; i < INVEN_PACK; i++) {
o_ptr = &player_ptr->inventory_list[i];
if (o_ptr->k_idx && check_book_realm(player_ptr, o_ptr->tval, o_ptr->sval)) {
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
WEIGHT calc_weapon_weight_limit(PlayerType *player_ptr);
WEIGHT calc_bow_weight_limit(PlayerType *player_ptr);
WEIGHT calc_inventory_weight(PlayerType *player_ptr);
-int16_t calc_num_fire(PlayerType *player_ptr, ObjectType *o_ptr);
+int16_t calc_num_fire(PlayerType *player_ptr, ItemEntity *o_ptr);
WEIGHT calc_weight_limit(PlayerType *player_ptr);
void update_creature(PlayerType *player_ptr);
bool player_has_no_spellbooks(PlayerType *player_ptr);
*/
static void inventory_aware(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
for (int i = 0; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
*/
static void home_aware(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
store_type *store_ptr;
for (int i = 1; i < max_towns; i++) {
store_ptr = &town_info[i].store[enum2i(StoreSaleType::HOME)];
for (int j = 0; (j < 12) && (i < store_ptr->stock_num); j++, i++) {
GAME_TEXT o_name[MAX_NLEN];
char tmp_val[80];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &store_ptr->stock[i];
sprintf(tmp_val, "%c) ", I2A(j));
prt(tmp_val, j + 2, 4);
flags.clear();
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) {
continue;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
auto *o_ptr = &player_ptr->inventory_list[i];
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
uint32_t value, exp;
DEPTH level = std::max(baseitems_info[o_ptr->k_idx].level - 8, 1);
* @param o_ptr オブジェクト構造体の参照ポインタ
* @return 呪縛可能な武器ならばTRUEを返す
*/
-static bool item_tester_hook_weapon_except_bow(const ObjectType *o_ptr)
+static bool item_tester_hook_weapon_except_bow(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::SWORD:
OBJECT_IDX item;
concptr q, s;
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
q = _("どれを呪いますか？", "Which weapon do you curse?");
s = _("武器を装備していない。", "You're not wielding a weapon.");
OBJECT_IDX item;
concptr q, s;
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
q = _("どれを呪いますか？", "Which piece of armour do you curse?");
s = _("防具を装備していない。", "You're not wearing any armor.");
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP), FuncItemTester(&ObjectType::is_armour));
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP), FuncItemTester(&ItemEntity::is_armour));
if (!o_ptr) {
return "";
}
if (cast) {
OBJECT_IDX item;
concptr s, q;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
q = _("どの装備品から吸収しますか？", "Which cursed equipment do you drain mana from?");
s = _("呪われたアイテムを装備していない。", "You have no cursed equipment.");
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP), FuncItemTester(&ObjectType::is_cursed));
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP), FuncItemTester(&ItemEntity::is_cursed));
if (!o_ptr) {
return "";
}
if (cast) {
int total_damage = 0, basedam, i;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (!get_aim_dir(player_ptr, &dir)) {
return nullptr;
}
if (cast) {
int total_damage = 0, basedam, i;
POSITION y, x;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
if (!get_direction(player_ptr, &dir, false, false)) {
return nullptr;
{
if (cast) {
- ObjectType forge, *q_ptr = &forge;
+ ItemEntity forge, *q_ptr = &forge;
msg_print(_("食料を生成した。", "A food ration is produced."));
/* Create the food ration */
#include "util/enum-converter.h"
#include "util/quarks.h"
-static void write_item_flags(ObjectType *o_ptr, BIT_FLAGS *flags)
+static void write_item_flags(ItemEntity *o_ptr, BIT_FLAGS *flags)
{
if (o_ptr->pval) {
set_bits(*flags, SaveDataItemFlagType::PVAL);
wr_u32b(*flags);
}
-static void write_item_info(ObjectType *o_ptr, const BIT_FLAGS flags)
+static void write_item_info(ItemEntity *o_ptr, const BIT_FLAGS flags)
{
wr_s16b((int16_t)o_ptr->weight);
if (any_bits(flags, SaveDataItemFlagType::FIXED_ARTIFACT_IDX)) {
* @brief アイテムオブジェクトを書き込む / Write an "item" record
* @param o_ptr アイテムオブジェクト保存元ポインタ
*/
-void wr_item(ObjectType *o_ptr)
+void wr_item(ItemEntity *o_ptr)
{
BIT_FLAGS flags = 0x00000000;
write_item_flags(o_ptr, &flags);
#include "system/angband.h"
-class ObjectType;
-void wr_item(ObjectType *o_ptr);
+class ItemEntity;
+void wr_item(ItemEntity *o_ptr);
void wr_perception(KIND_OBJECT_IDX k_idx);
* @param o_ptr 鍛冶効果を付与するアイテムへのポインタ。nullptrの場合はデフォルトの消費量が返される。
* @return 鍛冶効果を付与する時のエッセンス消費量
*/
-int Smith::get_essence_consumption(SmithEffectType effect, const ObjectType *o_ptr)
+int Smith::get_essence_consumption(SmithEffectType effect, const ItemEntity *o_ptr)
{
auto info = find_smith_info(effect);
if (!info.has_value()) {
return std::make_unique<TvalItemTester>(ItemKindType::NONE);
}
- auto tester_func = [i = info.value()](const ObjectType *o_ptr) {
+ auto tester_func = [i = info.value()](const ItemEntity *o_ptr) {
return i->can_give_smith_effect(o_ptr);
};
return std::make_unique<FuncItemTester>(tester_func);
* @return アイテムに付与されている発動効果の発動ID(random_art_activation_type型)
* 付与されている発動効果が無い場合は std::nullopt
*/
-std::optional<RandomArtActType> Smith::object_activation(const ObjectType *o_ptr)
+std::optional<RandomArtActType> Smith::object_activation(const ItemEntity *o_ptr)
{
return o_ptr->smith_act_idx;
}
* @return アイテムに付与されている鍛冶効果を保持する std::optional オブジェクト返す。
* 鍛冶効果が付与できないアイテムか、何も付与されていなければ std::nullopt を返す。
*/
-std::optional<SmithEffectType> Smith::object_effect(const ObjectType *o_ptr)
+std::optional<SmithEffectType> Smith::object_effect(const ItemEntity *o_ptr)
{
return o_ptr->smith_effect;
}
* @param o_ptr 鍛冶効果を付与するアイテムへのポインタ。nullptrの場合はデフォルトの消費量での回数が返される。
* @return エッセンスを付与できる回数を返す
*/
-int Smith::get_addable_count(SmithEffectType effect, const ObjectType *o_ptr) const
+int Smith::get_addable_count(SmithEffectType effect, const ItemEntity *o_ptr) const
{
auto info = find_smith_info(effect);
if (!info.has_value()) {
* @param o_ptr エッセンスの抽出を行うアイテムへのポインタ
* @return 抽出したエッセンスと抽出した量のタプルのリストを返す
*/
-Smith::DrainEssenceResult Smith::drain_essence(ObjectType *o_ptr)
+Smith::DrainEssenceResult Smith::drain_essence(ItemEntity *o_ptr)
{
// 抽出量を揃えるためKILLフラグのみ付いている場合はSLAYフラグも付ける
auto old_flgs = object_flags(o_ptr);
const auto is_artifact = o_ptr->is_artifact();
// アイテムをエッセンス抽出後の状態にする
- const ObjectType old_o = *o_ptr;
+ const ItemEntity old_o = *o_ptr;
o_ptr->prep(o_ptr->k_idx);
o_ptr->iy = old_o.iy;
* @param number エッセンス付与数
* @return 鍛冶効果の付与に成功したら ture、失敗したら false を返す
*/
-bool Smith::add_essence(SmithEffectType effect, ObjectType *o_ptr, int number)
+bool Smith::add_essence(SmithEffectType effect, ItemEntity *o_ptr, int number)
{
auto info = find_smith_info(effect);
if (!info.has_value()) {
*
* @param o_ptr 鍛冶効果を消去するアイテムへのポインタ
*/
-void Smith::erase_essence(ObjectType *o_ptr) const
+void Smith::erase_essence(ItemEntity *o_ptr) const
{
o_ptr->smith_act_idx = std::nullopt;
#include <optional>
#include <unordered_map>
-class ObjectType;
+class ItemEntity;
class PlayerType;
class ISmithInfo;
struct essence_drain_type;
static concptr get_effect_name(SmithEffectType effect);
static std::string get_need_essences_desc(SmithEffectType effect);
static std::vector<SmithEssenceType> get_need_essences(SmithEffectType effect);
- static int get_essence_consumption(SmithEffectType effect, const ObjectType *o_ptr = nullptr);
+ static int get_essence_consumption(SmithEffectType effect, const ItemEntity *o_ptr = nullptr);
static std::unique_ptr<ItemTester> get_item_tester(SmithEffectType effect);
static TrFlags get_effect_tr_flags(SmithEffectType effect);
- static std::optional<RandomArtActType> object_activation(const ObjectType *o_ptr);
- static std::optional<SmithEffectType> object_effect(const ObjectType *o_ptr);
+ static std::optional<RandomArtActType> object_activation(const ItemEntity *o_ptr);
+ static std::optional<SmithEffectType> object_effect(const ItemEntity *o_ptr);
int get_essence_num_of_posessions(SmithEssenceType essence) const;
- DrainEssenceResult drain_essence(ObjectType *o_ptr);
- bool add_essence(SmithEffectType effect, ObjectType *o_ptr, int consumption);
- void erase_essence(ObjectType *o_ptr) const;
- int get_addable_count(SmithEffectType smith_effect, const ObjectType *o_ptr = nullptr) const;
+ DrainEssenceResult drain_essence(ItemEntity *o_ptr);
+ bool add_essence(SmithEffectType effect, ItemEntity *o_ptr, int consumption);
+ void erase_essence(ItemEntity *o_ptr) const;
+ int get_addable_count(SmithEffectType smith_effect, const ItemEntity *o_ptr = nullptr) const;
static constexpr int ESSENCE_AMOUNT_MAX = 20000;
{
}
-bool BasicSmithInfo::add_essence(PlayerType *, ObjectType *o_ptr, int) const
+bool BasicSmithInfo::add_essence(PlayerType *, ItemEntity *o_ptr, int) const
{
o_ptr->smith_effect = effect;
return true;
}
-void BasicSmithInfo::erase_essence(ObjectType *o_ptr) const
+void BasicSmithInfo::erase_essence(ItemEntity *o_ptr) const
{
o_ptr->smith_effect = std::nullopt;
auto flgs = object_flags(o_ptr);
return this->add_flags;
}
-bool BasicSmithInfo::can_give_smith_effect(const ObjectType *o_ptr) const
+bool BasicSmithInfo::can_give_smith_effect(const ItemEntity *o_ptr) const
{
/*!
* @note 固定orランダムアーティファクトもしくはすでに鍛冶済みでないかを最初にチェックし、
return this->can_give_smith_effect_impl(o_ptr);
}
-bool BasicSmithInfo::can_give_smith_effect_impl(const ObjectType *o_ptr) const
+bool BasicSmithInfo::can_give_smith_effect_impl(const ItemEntity *o_ptr) const
{
if (this->effect == SmithEffectType::XTRA_MIGHT || this->effect == SmithEffectType::XTRA_SHOTS) {
return o_ptr->tval == ItemKindType::BOW;
{
}
-bool ActivationSmithInfo::add_essence(PlayerType *, ObjectType *o_ptr, int) const
+bool ActivationSmithInfo::add_essence(PlayerType *, ItemEntity *o_ptr, int) const
{
o_ptr->smith_act_idx = this->act_idx;
return true;
}
-void ActivationSmithInfo::erase_essence(ObjectType *o_ptr) const
+void ActivationSmithInfo::erase_essence(ItemEntity *o_ptr) const
{
o_ptr->smith_act_idx = std::nullopt;
}
-bool ActivationSmithInfo::can_give_smith_effect(const ObjectType *o_ptr) const
+bool ActivationSmithInfo::can_give_smith_effect(const ItemEntity *o_ptr) const
{
if (o_ptr->is_artifact() || o_ptr->smith_act_idx.has_value()) {
return false;
{
}
-bool EnchantWeaponSmithInfo::add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int) const
+bool EnchantWeaponSmithInfo::add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int) const
{
const auto max_val = player_ptr->lev / 5 + 5;
if ((o_ptr->to_h >= max_val) && (o_ptr->to_d >= max_val)) {
return true;
}
-bool EnchantWeaponSmithInfo::can_give_smith_effect(const ObjectType *o_ptr) const
+bool EnchantWeaponSmithInfo::can_give_smith_effect(const ItemEntity *o_ptr) const
{
return o_ptr->allow_enchant_weapon();
}
{
}
-bool EnchantArmourSmithInfo::add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int) const
+bool EnchantArmourSmithInfo::add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int) const
{
const auto max_val = player_ptr->lev / 5 + 5;
if (o_ptr->to_a >= max_val) {
return true;
}
-bool EnchantArmourSmithInfo::can_give_smith_effect(const ObjectType *o_ptr) const
+bool EnchantArmourSmithInfo::can_give_smith_effect(const ItemEntity *o_ptr) const
{
return o_ptr->is_armour();
}
{
}
-bool SustainSmithInfo::add_essence(PlayerType *, ObjectType *o_ptr, int) const
+bool SustainSmithInfo::add_essence(PlayerType *, ItemEntity *o_ptr, int) const
{
o_ptr->art_flags.set(TR_IGNORE_ACID);
o_ptr->art_flags.set(TR_IGNORE_ELEC);
return true;
}
-bool SustainSmithInfo::can_give_smith_effect(const ObjectType *o_ptr) const
+bool SustainSmithInfo::can_give_smith_effect(const ItemEntity *o_ptr) const
{
return o_ptr->is_weapon_armour_ammo();
}
{
}
-bool SlayingGlovesSmithInfo::add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const
+bool SlayingGlovesSmithInfo::add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const
{
BasicSmithInfo::add_essence(player_ptr, o_ptr, number);
return true;
}
-void SlayingGlovesSmithInfo::erase_essence(ObjectType *o_ptr) const
+void SlayingGlovesSmithInfo::erase_essence(ItemEntity *o_ptr) const
{
BasicSmithInfo::erase_essence(o_ptr);
}
}
-bool SlayingGlovesSmithInfo::can_give_smith_effect_impl(const ObjectType *o_ptr) const
+bool SlayingGlovesSmithInfo::can_give_smith_effect_impl(const ItemEntity *o_ptr) const
{
return o_ptr->tval == ItemKindType::GLOVES;
}
enum class RandomArtActType : short;
class PlayerType;
-class ObjectType;
+class ItemEntity;
/*!
* @brief 鍛冶効果の情報の基底クラス
* @param number 付与を行うエッセンスの個数
* @return 鍛冶効果の付与に成功した場合は true、失敗した場合は false
*/
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const = 0;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const = 0;
/*!
* @brief 鍛冶効果を消去する
*
* @param o_ptr 鍛冶効果の消去を行うアイテム構造体へのポインタ
*/
- virtual void erase_essence(ObjectType *o_ptr) const = 0;
+ virtual void erase_essence(ItemEntity *o_ptr) const = 0;
/*!
* @brief 鍛冶効果により与えられる特性フラグ(tr_type)のFlagGroupオブジェクトを取得する
* @param o_ptr 鍛冶を行うアイテム構造体へのポインタ
* @return 鍛冶を行えるなら true、そうでなければ false
*/
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const = 0;
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const = 0;
SmithEffectType effect; //!< 鍛冶で与える効果の種類
concptr name; //!< 鍛冶で与える能力の名称
class BasicSmithInfo : public ISmithInfo {
public:
BasicSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption, TrFlags add_flags);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *o_ptr) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *o_ptr) const override;
virtual TrFlags tr_flags() const override;
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const final override;
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const final override;
private:
- virtual bool can_give_smith_effect_impl(const ObjectType *o_ptr) const;
+ virtual bool can_give_smith_effect_impl(const ItemEntity *o_ptr) const;
TrFlags add_flags; //!< 鍛冶で能力を与えることにより付与されるアイテム特性フラグ
};
class ActivationSmithInfo : public ISmithInfo {
public:
ActivationSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption, RandomArtActType act_idx);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *) const override;
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *) const override;
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const override;
private:
RandomArtActType act_idx; //!< 発動能力ID
class EnchantWeaponSmithInfo : public ISmithInfo {
public:
EnchantWeaponSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *) const override {}
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *) const override {}
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const override;
};
/*!
class EnchantArmourSmithInfo : public ISmithInfo {
public:
EnchantArmourSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *) const override {}
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *) const override {}
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const override;
};
/*!
class SustainSmithInfo : public ISmithInfo {
public:
SustainSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *) const override {}
- virtual bool can_give_smith_effect(const ObjectType *o_ptr) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *) const override {}
+ virtual bool can_give_smith_effect(const ItemEntity *o_ptr) const override;
};
/*!
class SlayingGlovesSmithInfo : public BasicSmithInfo {
public:
SlayingGlovesSmithInfo(SmithEffectType effect, concptr name, SmithCategoryType category, std::vector<SmithEssenceType> need_essences, int consumption);
- virtual bool add_essence(PlayerType *player_ptr, ObjectType *o_ptr, int number) const override;
- virtual void erase_essence(ObjectType *) const override;
+ virtual bool add_essence(PlayerType *player_ptr, ItemEntity *o_ptr, int number) const override;
+ virtual void erase_essence(ItemEntity *) const override;
private:
- virtual bool can_give_smith_effect_impl(const ObjectType *o_ptr) const override;
+ virtual bool can_give_smith_effect_impl(const ItemEntity *o_ptr) const override;
};
* @details スレイ2d2種、及びone_resistance()による耐性1d2種、pval2種を得る。
* @param o_ptr 対象のオブジェクト構造体 (ブラッディムーン)のポインタ
*/
-void get_bloody_moon_flags(ObjectType *o_ptr)
+void get_bloody_moon_flags(ItemEntity *o_ptr)
{
o_ptr->art_flags = artifacts_info.at(FixedArtifactId::BLOOD).flags;
* @param o_ptr ブラッディ・ムーンへの参照ポインタ
* @return オブジェクト情報に異常がない限りTRUE
*/
-bool activate_bloody_moon(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_bloody_moon(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::BLOOD)) {
return false;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-void get_bloody_moon_flags(ObjectType *o_ptr);
-bool activate_bloody_moon(PlayerType *player_ptr, ObjectType *o_ptr);
+void get_bloody_moon_flags(ItemEntity *o_ptr);
+bool activate_bloody_moon(PlayerType *player_ptr, ItemEntity *o_ptr);
* @param o_ptr 判定する射撃武器のアイテム情報参照ポインタ
* @return 対応する矢/弾薬のベースアイテムID
*/
-ItemKindType bow_tval_ammo(ObjectType *o_ptr)
+ItemKindType bow_tval_ammo(ItemEntity *o_ptr)
{
switch (o_ptr->sval) {
case SV_SLING:
#pragma once
enum class ItemKindType : short;
-class ObjectType;
-ItemKindType bow_tval_ammo(ObjectType *o_ptr);
+class ItemEntity;
+ItemKindType bow_tval_ammo(ItemEntity *o_ptr);
bool small;
BIT_FLAGS mode = AM_GOOD | AM_FORBID_CHEST;
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
auto *floor_ptr = this->player_ptr->current_floor_ptr;
auto *o_ptr = &floor_ptr->o_list[o_idx];
return true;
}
-bool activate_crimson(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_crimson(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::CRIMSON)) {
return false;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool activate_crimson(PlayerType *player_ptr, ObjectType *o_ptr);
+bool activate_crimson(PlayerType *player_ptr, ItemEntity *o_ptr);
#include "system/player-type-definition.h"
#include "view/display-messages.h"
-bool activate_muramasa(PlayerType *player_ptr, ObjectType *o_ptr)
+bool activate_muramasa(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (!o_ptr->is_specific_artifact(FixedArtifactId::MURAMASA)) {
return false;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool activate_muramasa(PlayerType *player_ptr, ObjectType *o_ptr);
+bool activate_muramasa(PlayerType *player_ptr, ItemEntity *o_ptr);
* @param o_ptr オブジェクトの構造体参照ポインタ
* @return 残量アリの松明ならtrue
*/
-bool is_active_torch(ObjectType *o_ptr)
+bool is_active_torch(ItemEntity *o_ptr)
{
return (o_ptr->tval == ItemKindType::LITE) && (o_ptr->sval == SV_LITE_TORCH) && (o_ptr->fuel > 0);
}
* @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
* @param flgs 特別に追加するフラグを返す参照ポインタ
*/
-void torch_flags(ObjectType *o_ptr, TrFlags &flgs)
+void torch_flags(ItemEntity *o_ptr, TrFlags &flgs)
{
if (!is_active_torch(o_ptr)) {
return;
* @param dd 特別なダイス数を返す参照ポインタ
* @param ds 特別なダイス面数を返す参照ポインタ
*/
-void torch_dice(ObjectType *o_ptr, DICE_NUMBER *dd, DICE_SID *ds)
+void torch_dice(ItemEntity *o_ptr, DICE_NUMBER *dd, DICE_SID *ds)
{
if (!is_active_torch(o_ptr)) {
return;
* Torches have special abilities when they are flaming.
* @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
*/
-void torch_lost_fuel(ObjectType *o_ptr)
+void torch_lost_fuel(ItemEntity *o_ptr)
{
if (!is_active_torch(o_ptr)) {
return;
{
player_ptr->cur_lite = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
auto flgs = object_flags(o_ptr);
#include "object-enchant/tr-flags.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool is_active_torch(ObjectType *o_ptr);
-void torch_flags(ObjectType *o_ptr, TrFlags &flgs);
-void torch_dice(ObjectType *o_ptr, DICE_NUMBER *dd, DICE_SID *ds);
-void torch_lost_fuel(ObjectType *o_ptr);
+bool is_active_torch(ItemEntity *o_ptr);
+void torch_flags(ItemEntity *o_ptr, TrFlags &flgs);
+void torch_dice(ItemEntity *o_ptr, DICE_NUMBER *dd, DICE_SID *ds);
+void torch_lost_fuel(ItemEntity *o_ptr);
void update_lite_radius(PlayerType *player_ptr);
void update_lite(PlayerType *player_ptr);
concptr s = _("魔力を充填すべきアイテムがない。", "You have nothing to recharge.");
OBJECT_IDX item;
- ObjectType *o_ptr;
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_rechargeable));
+ ItemEntity *o_ptr;
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_rechargeable));
if (!o_ptr) {
return false;
}
{
concptr q = _("どのアイテムを強化しますか? ", "Enchant which item? ");
concptr s = _("強化できるアイテムがない。", "You have nothing to enchant.");
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
OBJECT_IDX item;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), FuncItemTester(object_is_nameless_weapon_armour));
if (!o_ptr) {
{
std::unique_ptr<ItemTester> item_tester = std::make_unique<AllMatchItemTester>();
if (only_equip) {
- item_tester = std::make_unique<FuncItemTester>(&ObjectType::is_weapon_armour_ammo);
+ item_tester = std::make_unique<FuncItemTester>(&ItemEntity::is_weapon_armour_ammo);
}
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
concptr q = _("どのアイテムを凡庸化しますか？", "Mundanify which item? ");
concptr s = _("凡庸化できるアイテムがない。", "You have nothing to mundanify.");
break;
}
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[t];
if (!o_ptr->k_idx) {
return false;
void fetch_item(PlayerType *player_ptr, DIRECTION dir, WEIGHT wgt, bool require_los)
{
grid_type *g_ptr;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
if (!player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list.empty()) {
if (preserve_mode || in_generate) {
/* Scan all objects in the grid */
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
/* Hack -- Preserve unknown artifacts */
* @param o_ptr 鑑定されるアイテムの情報参照ポインタ
* @return 実際に鑑定できたらTRUEを返す
*/
-bool identify_item(PlayerType *player_ptr, ObjectType *o_ptr)
+bool identify_item(PlayerType *player_ptr, ItemEntity *o_ptr)
{
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(player_ptr, o_name, o_ptr, 0);
q = _("どのアイテムを鑑定しますか? ", "Identify which item? ");
} else {
if (only_equip) {
- item_tester = std::make_unique<FuncItemTester>(&ObjectType::is_weapon_armour_ammo);
+ item_tester = std::make_unique<FuncItemTester>(&ItemEntity::is_weapon_armour_ammo);
} else {
item_tester = std::make_unique<AllMatchItemTester>();
}
concptr s = _("鑑定するべきアイテムがない。", "You have nothing to identify.");
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), *item_tester);
if (!o_ptr) {
return false;
q = _("どのアイテムを*鑑定*しますか? ", "*Identify* which item? ");
} else {
if (only_equip) {
- item_tester = std::make_unique<FuncItemTester>(&ObjectType::is_weapon_armour_ammo);
+ item_tester = std::make_unique<FuncItemTester>(&ItemEntity::is_weapon_armour_ammo);
} else {
item_tester = std::make_unique<AllMatchItemTester>();
}
concptr s = _("*鑑定*するべきアイテムがない。", "You have nothing to *identify*.");
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), *item_tester);
if (!o_ptr) {
return false;
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
void identify_pack(PlayerType *player_ptr);
-bool identify_item(PlayerType *player_ptr, ObjectType *o_ptr);
+bool identify_item(PlayerType *player_ptr, ItemEntity *o_ptr);
bool ident_spell(PlayerType *player_ptr, bool only_equip);
bool identify_fully(PlayerType *player_ptr, bool only_equip);
if (player_ptr->muta.has(PlayerMutationType::VTELEPORT) || PlayerClass(player_ptr).equals(PlayerClassType::IMITATOR)) {
follow = true;
} else {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
INVENTORY_IDX i;
for (i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
concptr q = _("どの防具に錆止めをしますか？", "Rustproof which piece of armour? ");
concptr s = _("錆止めできるものがありません。", "You have nothing to rustproof.");
OBJECT_IDX item;
- auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ObjectType::is_armour));
+ auto *o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ItemEntity::is_armour));
if (o_ptr == nullptr) {
return false;
}
concptr q = _("どのアイテムを金に変えますか？", "Turn which item to gold? ");
concptr s = _("金に変えられる物がありません。", "You have nothing to turn to gold.");
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR));
if (!o_ptr) {
return false;
}
}
- ObjectType item;
+ ItemEntity item;
item.prep(k_idx);
if (opt_a_idx.has_value()) {
item.fixed_artifact_idx = opt_a_idx.value();
*/
void acquirement(PlayerType *player_ptr, POSITION y1, POSITION x1, int num, bool great, bool special, bool known)
{
- ObjectType *i_ptr;
- ObjectType ObjectType_body;
+ ItemEntity *i_ptr;
+ ItemEntity ObjectType_body;
BIT_FLAGS mode = AM_GOOD | (great || special ? AM_GREAT : AM_NONE) | (special ? AM_SPECIAL : AM_NONE);
/* Acquirement */
bool curse_armor(PlayerType *player_ptr)
{
/* Curse the body armor */
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_BODY];
if (!o_ptr->k_idx) {
* @return 何も持っていない場合を除き、常にTRUEを返す
* @todo 元のreturnは間違っているが、修正後の↓文がどれくらい正しいかは要チェック
*/
-bool curse_weapon_object(PlayerType *player_ptr, bool force, ObjectType *o_ptr)
+bool curse_weapon_object(PlayerType *player_ptr, bool force, ItemEntity *o_ptr)
{
if (!o_ptr->k_idx) {
return false;
* Break the curse of an item
* @param o_ptr 呪い装備情報の参照ポインタ
*/
-static void break_curse(ObjectType *o_ptr)
+static void break_curse(ItemEntity *o_ptr)
{
BIT_FLAGS is_curse_broken = o_ptr->is_cursed() && o_ptr->curse_flags.has_not(CurseTraitType::PERMA_CURSE) && o_ptr->curse_flags.has_not(CurseTraitType::HEAVY_CURSE) && (randint0(100) < 25);
if (!is_curse_broken) {
* the larger the pile, the lower the chance of success.
* </pre>
*/
-bool enchant_equipment(PlayerType *player_ptr, ObjectType *o_ptr, int n, int eflag)
+bool enchant_equipment(PlayerType *player_ptr, ItemEntity *o_ptr, int n, int eflag)
{
/* Large piles resist enchantment */
int prob = o_ptr->number * 100;
bool enchant_spell(PlayerType *player_ptr, HIT_PROB num_hit, int num_dam, ARMOUR_CLASS num_ac)
{
/* Assume enchant weapon */
- FuncItemTester item_tester(&ObjectType::allow_enchant_weapon);
+ FuncItemTester item_tester(&ItemEntity::allow_enchant_weapon);
/* Enchant armor if requested */
if (num_ac) {
- item_tester = FuncItemTester(&ObjectType::is_armour);
+ item_tester = FuncItemTester(&ItemEntity::is_armour);
}
concptr q = _("どのアイテムを強化しますか? ", "Enchant which item? ");
concptr s = _("強化できるアイテムがない。", "You have nothing to enchant.");
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), item_tester);
if (!o_ptr) {
return false;
concptr s = _("強化できる武器がない。", "You have nothing to enchant.");
OBJECT_IDX item;
- ObjectType *o_ptr;
- o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ObjectType::allow_enchant_melee_weapon));
+ ItemEntity *o_ptr;
+ o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | IGNORE_BOTHHAND_SLOT, FuncItemTester(&ItemEntity::allow_enchant_melee_weapon));
if (!o_ptr) {
return;
}
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
void generate_amusement(PlayerType *player_ptr, int num, bool known);
void acquirement(PlayerType *player_ptr, POSITION y1, POSITION x1, int num, bool great, bool special, bool known);
bool curse_armor(PlayerType *player_ptr);
-bool curse_weapon_object(PlayerType *player_ptr, bool force, ObjectType *o_ptr);
+bool curse_weapon_object(PlayerType *player_ptr, bool force, ItemEntity *o_ptr);
void brand_bolts(PlayerType *player_ptr);
/*
#define ENCH_TODAM 0x02 /*!< 装備強化処理: ダメージ強化 / Enchant to damage */
#define ENCH_TOAC 0x04 /*!< 装備強化処理: AC強化 / Enchant to AC */
#define ENCH_FORCE 0x08 /*!< 装備強化処理: 無条件に成功させる / Force enchantment */
-bool enchant_equipment(PlayerType *player_ptr, ObjectType *o_ptr, int n, int eflag);
+bool enchant_equipment(PlayerType *player_ptr, ItemEntity *o_ptr, int n, int eflag);
bool enchant_spell(PlayerType *player_ptr, HIT_PROB num_hit, int num_dam, ARMOUR_CLASS num_ac);
void brand_weapon(PlayerType *player_ptr, int brand_type);
* @details
* 脱いで落とした装備にtimeoutを設定するために装備品のアドレスを返す。
*/
-bool cosmic_cast_off(PlayerType *player_ptr, ObjectType **o_ptr_ptr)
+bool cosmic_cast_off(PlayerType *player_ptr, ItemEntity **o_ptr_ptr)
{
auto *o_ptr = (*o_ptr_ptr);
return false;
}
- ObjectType forge;
+ ItemEntity forge;
(&forge)->copy_from(o_ptr);
inven_item_increase(player_ptr, slot, (0 - o_ptr->number));
inven_item_optimize(player_ptr, slot);
#include "spell/spells-util.h"
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
struct monster_type;
bool heal_monster(PlayerType *player_ptr, DIRECTION dir, int dam);
bool restore_all_status(PlayerType *player_ptr);
bool fishing(PlayerType *player_ptr);
-bool cosmic_cast_off(PlayerType *player_ptr, ObjectType **o_ptr_ptr);
+bool cosmic_cast_off(PlayerType *player_ptr, ItemEntity **o_ptr_ptr);
void apply_nexus(monster_type *m_ptr, PlayerType *player_ptr);
void status_shuffle(PlayerType *player_ptr);
concptr q = _("どの死体を捧げますか? ", "Sacrifice which corpse? ");
concptr s = _("捧げられる死体を持っていない。", "You have nothing to sacrifice.");
OBJECT_IDX item;
- ObjectType *o_ptr;
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ObjectType::is_offerable));
+ ItemEntity *o_ptr;
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), FuncItemTester(&ItemEntity::is_offerable));
if (!o_ptr) {
return false;
}
enum summon_type : int;
-class ObjectType;
+class ItemEntity;
class PlayerType;
bool trump_summoning(PlayerType *player_ptr, int num, bool pet, POSITION y, POSITION x, DEPTH lev, summon_type type, BIT_FLAGS mode);
bool cast_summon_demon(PlayerType *player_ptr, int power);
* Based on a suggestion by "Lee Vogt" <lvogt@cig.mcel.mot.com>
* </pre>
*/
-bool black_market_crap(PlayerType *player_ptr, ObjectType *o_ptr)
+bool black_market_crap(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (o_ptr->is_ego()) {
return false;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool black_market_crap(PlayerType *player_ptr, ObjectType *o_ptr);
+bool black_market_crap(PlayerType *player_ptr, ItemEntity *o_ptr);
leave_store = true;
} else {
int item_pos;
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
GAME_TEXT o_name[MAX_NLEN];
msg_print(_("ザックからアイテムがあふれてしまった！", "Your pack overflows!"));
q_ptr = &forge;
* known, the player may have to pick stuff up and drop it again.
* </pre>
*/
-int home_carry(PlayerType *player_ptr, ObjectType *o_ptr, StoreSaleType store_num)
+int home_carry(PlayerType *player_ptr, ItemEntity *o_ptr, StoreSaleType store_num)
{
bool old_stack_force_notes = stack_force_notes;
bool old_stack_force_costs = stack_force_costs;
}
for (int slot = 0; slot < st_ptr->stock_num; slot++) {
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &st_ptr->stock[slot];
if (object_similar(j_ptr, o_ptr)) {
object_absorb(j_ptr, o_ptr);
return slot;
}
-static bool exe_combine_store_items(ObjectType *o_ptr, ObjectType *j_ptr, const int max_num, const int i, bool *combined)
+static bool exe_combine_store_items(ItemEntity *o_ptr, ItemEntity *j_ptr, const int max_num, const int i, bool *combined)
{
if (o_ptr->number + j_ptr->number > max_num) {
return false;
return true;
}
-static void sweep_reorder_store_item(ObjectType *o_ptr, const int i, bool *combined)
+static void sweep_reorder_store_item(ItemEntity *o_ptr, const int i, bool *combined)
{
for (int j = 0; j < i; j++) {
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &st_ptr->stock[j];
if (!j_ptr->k_idx) {
continue;
static void exe_reorder_store_item(PlayerType *player_ptr, bool *flag)
{
for (int i = 0; i < st_ptr->stock_num; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[i];
if (!o_ptr->k_idx) {
continue;
}
*flag = true;
- ObjectType *j_ptr;
- ObjectType forge;
+ ItemEntity *j_ptr;
+ ItemEntity forge;
j_ptr = &forge;
j_ptr->copy_from(&st_ptr->stock[i]);
for (int k = i; k > j; k--) {
while (combined) {
combined = false;
for (int i = st_ptr->stock_num - 1; i > 0; i--) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[i];
if (!o_ptr->k_idx) {
continue;
#pragma once
-class ObjectType;
+class ItemEntity;
class PlayerType;
enum class StoreSaleType;
-int home_carry(PlayerType *player_ptr, ObjectType *o_ptr, StoreSaleType store_num);
+int home_carry(PlayerType *player_ptr, ItemEntity *o_ptr, StoreSaleType store_num);
bool combine_and_reorder_home(PlayerType *player_ptr, const StoreSaleType store_num);
}
item = item + store_top;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[item];
GAME_TEXT o_name[MAX_NLEN];
* "greed" value is always something (?).
* </pre>
*/
-PRICE price_item(PlayerType *player_ptr, ObjectType *o_ptr, int greed, bool flip, StoreSaleType store_num)
+PRICE price_item(PlayerType *player_ptr, ItemEntity *o_ptr, int greed, bool flip, StoreSaleType store_num)
{
auto price = o_ptr->get_price();
if (price <= 0) {
#define LOW_PRICE_THRESHOLD 10L
enum class StoreSaleType;
-class ObjectType;
+class ItemEntity;
class PlayerType;
-PRICE price_item(PlayerType *player_ptr, ObjectType *o_ptr, int greed, bool flip, StoreSaleType store_num);
+PRICE price_item(PlayerType *player_ptr, ItemEntity *o_ptr, int greed, bool flip, StoreSaleType store_num);
* @return プレイヤーの価格に対して店主が不服ならばTRUEを返す /
* Return TRUE if purchase is NOT successful
*/
-static std::optional<PRICE> prompt_to_buy(PlayerType *player_ptr, ObjectType *o_ptr, StoreSaleType store_num)
+static std::optional<PRICE> prompt_to_buy(PlayerType *player_ptr, ItemEntity *o_ptr, StoreSaleType store_num)
{
auto price_ask = price_item(player_ptr, o_ptr, ot_ptr->inflate, false, store_num);
* @param i お店のストック数(アドレス渡し)
* @param 取得元インベントリ番号
*/
-static void take_item_from_home(PlayerType *player_ptr, ObjectType *o_ptr, ObjectType *j_ptr, const COMMAND_CODE item)
+static void take_item_from_home(PlayerType *player_ptr, ItemEntity *o_ptr, ItemEntity *j_ptr, const COMMAND_CODE item)
{
const int amt = j_ptr->number;
distribute_charges(o_ptr, j_ptr, amt);
}
item = item + store_top;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[item];
ITEM_NUMBER amt = 1;
- ObjectType forge;
+ ItemEntity forge;
auto *j_ptr = &forge;
j_ptr->copy_from(o_ptr);
const auto &artifact_name = tokens[1];
const auto &[a_idx, a_ptr] = get_artifact_definition(artifact_name);
const auto k_idx = lookup_baseitem_id(a_ptr->bi_key);
- ObjectType item;
+ ItemEntity item;
item.prep(k_idx);
item.fixed_artifact_idx = a_idx;
item.ident = IDENT_STORE;
* @param o_ptr オブジェクトの構造体参照ポインタ
* @return 売るなら(true,売値)、売らないなら(false,0)のタプル
*/
-static std::optional<PRICE> prompt_to_sell(PlayerType *player_ptr, ObjectType *o_ptr, StoreSaleType store_num)
+static std::optional<PRICE> prompt_to_sell(PlayerType *player_ptr, ItemEntity *o_ptr, StoreSaleType store_num)
{
auto price_ask = price_item(player_ptr, o_ptr, ot_ptr->inflate, true, store_num);
}
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s_none, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT, FuncItemTester(store_will_buy, player_ptr, store_num));
if (!o_ptr) {
return;
}
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->copy_from(o_ptr);
q_ptr->number = amt;
* @param o_ptr 判定したいオブジェクト構造体の参照ポインタ
* @return アイテムが祝福されたアイテムならばTRUEを返す
*/
-static bool is_blessed_item(const ObjectType *o_ptr)
+static bool is_blessed_item(const ItemEntity *o_ptr)
{
auto flgs = object_flags(o_ptr);
return flgs.has(TR_BLESSED);
}
-static bool check_store_general(const ObjectType *o_ptr)
+static bool check_store_general(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::ROD:
}
}
-static bool check_store_armoury(const ObjectType *o_ptr)
+static bool check_store_armoury(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::BOOTS:
}
}
-static bool check_store_weapon(const ObjectType *o_ptr)
+static bool check_store_weapon(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::SHOT:
}
}
-static bool check_store_temple(const ObjectType *o_ptr)
+static bool check_store_temple(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::LIFE_BOOK:
}
}
-static bool check_store_alchemist(const ObjectType *o_ptr)
+static bool check_store_alchemist(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::SCROLL:
}
}
-static bool check_store_magic(const ObjectType *o_ptr)
+static bool check_store_magic(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::SORCERY_BOOK:
}
}
-static bool check_store_book(const ObjectType *o_ptr)
+static bool check_store_book(const ItemEntity *o_ptr)
{
switch (o_ptr->tval) {
case ItemKindType::SORCERY_BOOK:
}
}
-static bool switch_store_check(const ObjectType *o_ptr, StoreSaleType store_num)
+static bool switch_store_check(const ItemEntity *o_ptr, StoreSaleType store_num)
{
switch (store_num) {
case StoreSaleType::GENERAL:
* Note that a shop-keeper must refuse to buy "worthless" items
*/
-bool store_will_buy(PlayerType *, const ObjectType *o_ptr, StoreSaleType store_num)
+bool store_will_buy(PlayerType *, const ItemEntity *o_ptr, StoreSaleType store_num)
{
if ((store_num == StoreSaleType::HOME) || (store_num == StoreSaleType::MUSEUM)) {
return true;
return size;
}
-static int mass_scroll_produce(ObjectType *o_ptr, const PRICE cost)
+static int mass_scroll_produce(ItemEntity *o_ptr, const PRICE cost)
{
int size = 1;
if (cost <= 60L) {
return size;
}
-static int mass_equipment_produce(ObjectType *o_ptr, const PRICE cost)
+static int mass_equipment_produce(ItemEntity *o_ptr, const PRICE cost)
{
int size = 1;
if (o_ptr->is_artifact() || o_ptr->is_ego()) {
return size;
}
-static int switch_mass_production(ObjectType *o_ptr, const PRICE cost, StoreSaleType store_num)
+static int switch_mass_production(ItemEntity *o_ptr, const PRICE cost, StoreSaleType store_num)
{
switch (o_ptr->tval) {
case ItemKindType::FOOD:
* Some objects can be sold at a "discount" (in small piles)
* </pre>
*/
-void mass_produce(PlayerType *, ObjectType *o_ptr, StoreSaleType store_num)
+void mass_produce(PlayerType *, ItemEntity *o_ptr, StoreSaleType store_num)
{
const auto cost = o_ptr->get_price();
int size = switch_mass_production(o_ptr, cost, store_num);
#pragma once
enum class StoreSaleType;
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool store_will_buy(PlayerType *, const ObjectType *o_ptr, StoreSaleType store_num);
-void mass_produce(PlayerType *, ObjectType *o_ptr, StoreSaleType store_num);
+bool store_will_buy(PlayerType *, const ItemEntity *o_ptr, StoreSaleType store_num);
+void mass_produce(PlayerType *, ItemEntity *o_ptr, StoreSaleType store_num);
*/
void store_item_increase(INVENTORY_IDX item, ITEM_NUMBER num)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[item];
int cnt = o_ptr->number + num;
if (cnt > 255) {
*/
void store_item_optimize(INVENTORY_IDX item)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[item];
if ((o_ptr->k_idx == 0) || (o_ptr->number != 0)) {
return;
* @details
* 回数の違う杖と魔法棒がスロットを圧迫するのでスロット数制限をかける
*/
-std::vector<PARAMETER_VALUE> store_same_magic_device_pvals(ObjectType *j_ptr)
+std::vector<PARAMETER_VALUE> store_same_magic_device_pvals(ItemEntity *j_ptr)
{
auto list = std::vector<PARAMETER_VALUE>();
for (INVENTORY_IDX i = 0; i < st_ptr->stock_num; i++) {
* See "object_similar()" for the same function for the "player"
* </pre>
*/
-bool store_object_similar(ObjectType *o_ptr, ObjectType *j_ptr)
+bool store_object_similar(ItemEntity *o_ptr, ItemEntity *j_ptr)
{
if (o_ptr == j_ptr) {
return false;
* See "object_similar()" for the same function for the "player"
* </pre>
*/
-static void store_object_absorb(ObjectType *o_ptr, ObjectType *j_ptr)
+static void store_object_absorb(ItemEntity *o_ptr, ItemEntity *j_ptr)
{
int max_num = (o_ptr->tval == ItemKindType::ROD) ? std::min(99, MAX_SHORT / baseitems_info[o_ptr->k_idx].pval) : 99;
int total = o_ptr->number + j_ptr->number;
* known, the player may have to pick stuff up and drop it again.
* </pre>
*/
-int store_carry(ObjectType *o_ptr)
+int store_carry(ItemEntity *o_ptr)
{
const auto value = o_ptr->get_price();
if (value <= 0) {
o_ptr->feeling = FEEL_NONE;
int slot;
for (slot = 0; slot < st_ptr->stock_num; slot++) {
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &st_ptr->stock[slot];
if (store_object_similar(j_ptr, o_ptr)) {
store_object_absorb(j_ptr, o_ptr);
}
for (slot = 0; slot < st_ptr->stock_num; slot++) {
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
j_ptr = &st_ptr->stock[slot];
if (o_ptr->tval > j_ptr->tval) {
break;
/*!
* @brief 店舗の情報構造体
*/
-class ObjectType;
+class ItemEntity;
struct store_type {
byte type{}; //!< Store type
byte owner{}; //!< Owner index
store_k_idx table{}; //!< Table -- Legal item kinds
int16_t stock_num{}; //!< Stock -- Number of entries
int16_t stock_size{}; //!< Stock -- Total Size of Array
- std::unique_ptr<ObjectType[]> stock; //!< Stock -- Actual stock items
+ std::unique_ptr<ItemEntity[]> stock; //!< Stock -- Actual stock items
store_type() = default;
store_type(const store_type &) = delete;
class PlayerType;
void store_delete(void);
-std::vector<PARAMETER_VALUE> store_same_magic_device_pvals(ObjectType *j_ptr);
+std::vector<PARAMETER_VALUE> store_same_magic_device_pvals(ItemEntity *j_ptr);
void store_item_increase(INVENTORY_IDX item, ITEM_NUMBER num);
void store_item_optimize(INVENTORY_IDX item);
-int store_carry(ObjectType *o_ptr);
-bool store_object_similar(ObjectType *o_ptr, ObjectType *j_ptr);
+int store_carry(ItemEntity *o_ptr);
+bool store_object_similar(ItemEntity *o_ptr, ItemEntity *j_ptr);
* 1 : Cannot be combined but there are empty spaces.
* </pre>
*/
-int store_check_num(ObjectType *o_ptr, StoreSaleType store_num)
+int store_check_num(ItemEntity *o_ptr, StoreSaleType store_num)
{
- ObjectType *j_ptr;
+ ItemEntity *j_ptr;
if ((store_num == StoreSaleType::HOME) || (store_num == StoreSaleType::MUSEUM)) {
bool old_stack_force_notes = stack_force_notes;
bool old_stack_force_costs = stack_force_costs;
return;
}
item = item + store_top;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[item];
if (!o_ptr->is_fully_known()) {
msg_print(_("このアイテムについて特に知っていることはない。", "You have no special knowledge about that item."));
st_ptr->good_buy = 0;
st_ptr->bad_buy = 0;
for (int i = 0; i < st_ptr->stock_num; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[i];
if (o_ptr->is_artifact()) {
continue;
level = rand_range(1, ow_ptr->level);
}
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->prep(k_idx);
ItemMagicApplier(player_ptr, q_ptr, level, AM_NO_FIXED_ART).execute();
void store_maintenance(PlayerType *player_ptr, int town_num, StoreSaleType store_num, int chance);
void store_init(int town_num, StoreSaleType store_num);
void store_examine(PlayerType *player_ptr, StoreSaleType store_num);
-int store_check_num(ObjectType *o_ptr, StoreSaleType store_num);
+int store_check_num(ItemEntity *o_ptr, StoreSaleType store_num);
int get_stock(COMMAND_CODE *com_val, concptr pmt, int i, int j, StoreSaleType store_num);
struct grid_type;
struct monster_type;
-class ObjectType;
+class ItemEntity;
class FloorType {
public:
FloorType() = default;
GAME_TURN generated_turn = 0; /* Turn when level began */
- std::vector<ObjectType> o_list; /*!< The array of dungeon items [max_o_idx] */
+ std::vector<ItemEntity> o_list; /*!< The array of dungeon items [max_o_idx] */
OBJECT_IDX o_max = 0; /* Number of allocated objects */
OBJECT_IDX o_cnt = 0; /* Number of live objects */
#include <set>
#include <unordered_map>
-ObjectType::ObjectType()
+ItemEntity::ItemEntity()
: fixed_artifact_idx(FixedArtifactId::NONE)
{
}
* @brief オブジェクトを初期化する
* Wipe an object clean.
*/
-void ObjectType::wipe()
+void ItemEntity::wipe()
{
*this = {};
}
* Wipe an object clean.
* @param j_ptr 複製元のオブジェクトの構造体参照ポインタ
*/
-void ObjectType::copy_from(const ObjectType *j_ptr)
+void ItemEntity::copy_from(const ItemEntity *j_ptr)
{
*this = *j_ptr;
}
* @param player_ptr プレイヤーへの参照ポインタ
* @param k_idx 新たに作成したいベースアイテム情報のID
*/
-void ObjectType::prep(KIND_OBJECT_IDX ko_idx)
+void ItemEntity::prep(KIND_OBJECT_IDX ko_idx)
{
auto *k_ptr = &baseitems_info[ko_idx];
auto old_stack_idx = this->stack_idx;
* @brief オブジェクトが武器として装備できるかどうかを返す / Check if an object is weapon (including bows)
* @return 武器として使えるならばtrueを返す
*/
-bool ObjectType::is_weapon() const
+bool ItemEntity::is_weapon() const
{
return (TV_WEAPON_BEGIN <= this->tval) && (this->tval <= TV_WEAPON_END);
}
* Rare weapons/aromors including Blade of Chaos, Dragon armors, etc.
* @return 武器や矢弾として使えるならばtrueを返す
*/
-bool ObjectType::is_weapon_ammo() const
+bool ItemEntity::is_weapon_ammo() const
{
return (TV_MISSILE_BEGIN <= this->tval) && (this->tval <= TV_WEAPON_END);
}
* @brief オブジェクトが武器、防具、矢弾として使用できるかを返す / Check if an object is weapon, armour or ammo
* @return 武器、防具、矢弾として使えるならばtrueを返す
*/
-bool ObjectType::is_weapon_armour_ammo() const
+bool ItemEntity::is_weapon_armour_ammo() const
{
return this->is_weapon_ammo() || this->is_armour();
}
* @brief オブジェクトが近接武器として装備できるかを返す / Melee weapons
* @return 近接武器として使えるならばtrueを返す
*/
-bool ObjectType::is_melee_weapon() const
+bool ItemEntity::is_melee_weapon() const
{
return (ItemKindType::DIGGING <= this->tval) && (this->tval <= ItemKindType::SWORD);
}
* @brief エッセンスの付加可能な武器や矢弾かを返す
* @return エッセンスの付加可能な武器か矢弾ならばtrueを返す。
*/
-bool ObjectType::is_melee_ammo() const
+bool ItemEntity::is_melee_ammo() const
{
switch (this->tval) {
case ItemKindType::HAFTED:
* @brief オブジェクトが装備可能であるかを返す / Wearable including all weapon, all armour, bow, light source, amulet, and ring
* @return 装備可能ならばTRUEを返す
*/
-bool ObjectType::is_wearable() const
+bool ItemEntity::is_wearable() const
{
return (TV_WEARABLE_BEGIN <= this->tval) && (this->tval <= TV_WEARABLE_END);
}
/*!
- * @brief オブジェクトが装備品であるかを返す(ObjectType::is_wearableに矢弾を含む) / Equipment including all wearable objects and ammo
+ * @brief オブジェクトが装備品であるかを返す(ItemEntity::is_wearableに矢弾を含む) / Equipment including all wearable objects and ammo
* @return 装備品ならばtrueを返す
*/
-bool ObjectType::is_equipment() const
+bool ItemEntity::is_equipment() const
{
return (TV_EQUIP_BEGIN <= this->tval) && (this->tval <= TV_EQUIP_END);
}
* @brief 武器匠の「武器」鑑定対象になるかを判定する。/ Hook to specify "weapon"
* @return 対象になるならtrueを返す。
*/
-bool ObjectType::is_orthodox_melee_weapons() const
+bool ItemEntity::is_orthodox_melee_weapons() const
{
switch (this->tval) {
case ItemKindType::HAFTED:
* @brief 修復対象となる壊れた武器かを判定する。 / Hook to specify "broken weapon"
* @return 修復対象になるならTRUEを返す。
*/
-bool ObjectType::is_broken_weapon() const
+bool ItemEntity::is_broken_weapon() const
{
if (this->tval != ItemKindType::SWORD) {
return false;
* @brief オブジェクトが投射可能な武器かどうかを返す。
* @return 投射可能な武器ならばtrue
*/
-bool ObjectType::is_throwable() const
+bool ItemEntity::is_throwable() const
{
switch (this->tval) {
case ItemKindType::DIGGING:
* @brief オブジェクトがどちらの手にも装備できる武器かどうかの判定
* @return 左右両方の手で装備できるならばtrueを返す。
*/
-bool ObjectType::is_wieldable_in_etheir_hand() const
+bool ItemEntity::is_wieldable_in_etheir_hand() const
{
switch (this->tval) {
case ItemKindType::DIGGING:
* @brief オブジェクトが強化不能武器であるかを返す / Poison needle can not be enchanted
* @return 強化不能ならばtrueを返す
*/
-bool ObjectType::refuse_enchant_weapon() const
+bool ItemEntity::refuse_enchant_weapon() const
{
return (this->tval == ItemKindType::SWORD) && (this->sval == SV_POISON_NEEDLE);
}
* Check if an object is weapon (including bows and ammo) and allows enchantment
* @return 強化可能ならばtrueを返す
*/
-bool ObjectType::allow_enchant_weapon() const
+bool ItemEntity::allow_enchant_weapon() const
{
return this->is_weapon_ammo() && !this->refuse_enchant_weapon();
}
* Check if an object is melee weapon and allows enchantment
* @return 強化可能な近接武器ならばtrueを返す
*/
-bool ObjectType::allow_enchant_melee_weapon() const
+bool ItemEntity::allow_enchant_melee_weapon() const
{
return this->is_melee_weapon() && !this->refuse_enchant_weapon();
}
* Check if an object is melee weapon and allows wielding with two-hands
* @return 両手持ち可能ならばTRUEを返す
*/
-bool ObjectType::allow_two_hands_wielding() const
+bool ItemEntity::allow_two_hands_wielding() const
{
return this->is_melee_weapon() && ((this->weight > 99) || (this->tval == ItemKindType::POLEARM));
}
* @brief オブジェクトが矢弾として使用できるかどうかを返す / Check if an object is ammo
* @return 矢弾として使えるならばtrueを返す
*/
-bool ObjectType::is_ammo() const
+bool ItemEntity::is_ammo() const
{
return (TV_MISSILE_BEGIN <= this->tval) && (this->tval <= TV_MISSILE_END);
}
* Hook to determine if an object is contertible in an arrow/bolt
* @return 材料にできるならtrueを返す
*/
-bool ObjectType::is_convertible() const
+bool ItemEntity::is_convertible() const
{
auto is_convertible = ((this->tval == ItemKindType::JUNK) || (this->tval == ItemKindType::SKELETON));
is_convertible |= ((this->tval == ItemKindType::CORPSE) && (this->sval == SV_SKELETON));
return is_convertible;
}
-bool ObjectType::is_lance() const
+bool ItemEntity::is_lance() const
{
auto is_lance = this->tval == ItemKindType::POLEARM;
is_lance &= (this->sval == SV_LANCE) || (this->sval == SV_HEAVY_LANCE);
* @brief オブジェクトが防具として装備できるかどうかを返す / Check if an object is armour
* @return 防具として装備できるならばtrueを返す
*/
-bool ObjectType::is_armour() const
+bool ItemEntity::is_armour() const
{
return (TV_ARMOR_BEGIN <= this->tval) && (this->tval <= TV_ARMOR_END);
}
* Rare weapons/aromors including Blade of Chaos, Dragon armors, etc.
* @return レアアイテムならばTRUEを返す
*/
-bool ObjectType::is_rare() const
+bool ItemEntity::is_rare() const
{
static const std::unordered_map<ItemKindType, const std::set<OBJECT_SUBTYPE_VALUE>> rare_table = {
{ ItemKindType::HAFTED, { SV_MACE_OF_DISRUPTION, SV_WIZSTAFF } },
* @brief オブジェクトがエゴアイテムかどうかを返す
* @return エゴアイテムならばtrueを返す
*/
-bool ObjectType::is_ego() const
+bool ItemEntity::is_ego() const
{
return this->ego_idx != EgoType::NONE;
}
* Check if an object is made by a smith's special ability
* @return エッセンス付加済みならばTRUEを返す
*/
-bool ObjectType::is_smith() const
+bool ItemEntity::is_smith() const
{
return Smith::object_effect(this).has_value() || Smith::object_activation(this).has_value();
}
* Check if an object is artifact
* @return アーティファクトならばtrueを返す
*/
-bool ObjectType::is_artifact() const
+bool ItemEntity::is_artifact() const
{
return this->is_fixed_artifact() || (this->art_name != 0);
}
* Check if an object is fixed artifact
* @return 固定アーティファクトならばtrueを返す
*/
-bool ObjectType::is_fixed_artifact() const
+bool ItemEntity::is_fixed_artifact() const
{
return !this->is_specific_artifact(FixedArtifactId::NONE);
}
* Check if an object is random artifact
* @return ランダムアーティファクトならばtrueを返す
*/
-bool ObjectType::is_random_artifact() const
+bool ItemEntity::is_random_artifact() const
{
return this->is_artifact() && !this->is_fixed_artifact();
}
* Check if an object is neither artifact, ego, nor 'smith' object
* @return 通常のアイテムならばtrueを返す
*/
-bool ObjectType::is_nameless() const
+bool ItemEntity::is_nameless() const
{
return !this->is_artifact() && !this->is_ego() && !this->is_smith();
}
-bool ObjectType::is_valid() const
+bool ItemEntity::is_valid() const
{
return this->k_idx != 0;
}
-bool ObjectType::is_broken() const
+bool ItemEntity::is_broken() const
{
return any_bits(this->ident, IDENT_BROKEN);
}
-bool ObjectType::is_cursed() const
+bool ItemEntity::is_cursed() const
{
return this->curse_flags.any();
}
-bool ObjectType::is_held_by_monster() const
+bool ItemEntity::is_held_by_monster() const
{
return this->held_m_idx != 0;
}
* Test One -- Check for special "known" tag
* Test Two -- Check for "Easy Know" + "Aware"
*/
-bool ObjectType::is_known() const
+bool ItemEntity::is_known() const
{
return any_bits(this->ident, IDENT_KNOWN) || (baseitems_info[this->k_idx].easy_know && baseitems_info[this->k_idx].aware);
}
-bool ObjectType::is_fully_known() const
+bool ItemEntity::is_fully_known() const
{
return any_bits(this->ident, IDENT_FULL_KNOWN);
}
* @brief 与えられたオブジェクトのベースアイテムが鑑定済かを返す / Determine if a given inventory item is "aware"
* @return 鑑定済ならtrue
*/
-bool ObjectType::is_aware() const
+bool ItemEntity::is_aware() const
{
return baseitems_info[this->k_idx].aware;
}
/*
* Determine if a given inventory item is "tried"
*/
-bool ObjectType::is_tried() const
+bool ItemEntity::is_tried() const
{
return baseitems_info[this->k_idx].tried;
}
* @brief オブジェクトが薬であるかを返す
* @return オブジェクトが薬ならばtrueを返す
*/
-bool ObjectType::is_potion() const
+bool ItemEntity::is_potion() const
{
return baseitems_info[this->k_idx].bi_key.tval() == ItemKindType::POTION;
}
* Hook to determine if an object is readable
* @return 読むことが可能ならばtrueを返す
*/
-bool ObjectType::is_readable() const
+bool ItemEntity::is_readable() const
{
auto can_read = this->tval == ItemKindType::SCROLL;
can_read |= this->tval == ItemKindType::PARCHMENT;
* An "item_tester_hook" for refilling lanterns
* @return オブジェクトがランタンの燃料になるならばTRUEを返す
*/
-bool ObjectType::can_refill_lantern() const
+bool ItemEntity::can_refill_lantern() const
{
return (this->tval == ItemKindType::FLASK) || ((this->tval == ItemKindType::LITE) && (this->sval == SV_LITE_LANTERN));
}
* An "item_tester_hook" for refilling torches
* @return オブジェクトが松明に束ねられるならばTRUEを返す
*/
-bool ObjectType::can_refill_torch() const
+bool ItemEntity::can_refill_torch() const
{
return (this->tval == ItemKindType::LITE) && (this->sval == SV_LITE_TORCH);
}
* Hook for "get_item()". Determine if something is rechargable.
* @return 魔力充填が可能ならばTRUEを返す
*/
-bool ObjectType::is_rechargeable() const
+bool ItemEntity::is_rechargeable() const
{
switch (this->tval) {
case ItemKindType::STAFF:
* @brief 悪魔領域のグレーターデーモン召喚に利用可能な死体かどうかを返す。 / An "item_tester_hook" for offer
* @return 生贄に使用可能な死体ならばTRUEを返す。
*/
-bool ObjectType::is_offerable() const
+bool ItemEntity::is_offerable() const
{
if ((this->tval != ItemKindType::CORPSE) || (this->sval != SV_CORPSE)) {
return false;
* Hook to determine if an object is activatable
* @return 魔道具として発動可能ならばTRUEを返す
*/
-bool ObjectType::is_activatable() const
+bool ItemEntity::is_activatable() const
{
if (!this->is_known()) {
return false;
* @brief オブジェクトが燃料として使えるかを判定する
* @return 燃料か否か
*/
-bool ObjectType::is_fuel() const
+bool ItemEntity::is_fuel() const
{
auto is_fuel = (this->tval == ItemKindType::LITE) && ((this->sval == SV_LITE_TORCH) || (this->sval == SV_LITE_LANTERN));
is_fuel |= (this->tval == ItemKindType::FLASK) && (this->sval == SV_FLASK_OIL);
* @brief オブジェクトが魔法書かどうかを判定する
* @return 魔法書か否か
*/
-bool ObjectType::is_book() const
+bool ItemEntity::is_book() const
{
switch (this->tval) {
case ItemKindType::LIFE_BOOK:
* @return 同一修正か
* @details 鍛冶師が篭手に殺戮エッセンスを付加した場合のみこの判定に意味がある
*/
-bool ObjectType::is_glove_same_temper(const ObjectType *j_ptr) const
+bool ItemEntity::is_glove_same_temper(const ItemEntity *j_ptr) const
{
if (!this->is_smith() || !j_ptr->is_smith()) {
return false;
* @return 重ねられるか
* @details 個別のアイテムによっては別途条件があるが、それはこの関数では判定しない
*/
-bool ObjectType::can_pile(const ObjectType *j_ptr) const
+bool ItemEntity::can_pile(const ItemEntity *j_ptr) const
{
if (this->is_known() != j_ptr->is_known()) {
return false;
* モンスターの死体は、元モンスターの色を返す
* 異常アイテム (「何か」)の場合、ベースアイテム定義に基づき黒を返す
*/
-TERM_COLOR ObjectType::get_color() const
+TERM_COLOR ItemEntity::get_color() const
{
const auto &base_item = baseitems_info[this->k_idx];
const auto flavor = base_item.flavor;
* 未鑑定名のあるアイテム (薬等)は、未鑑定名の割り当てられたシンボル
* @todo 色と違って変える必要はない……はず？
*/
-char ObjectType::get_symbol() const
+char ItemEntity::get_symbol() const
{
const auto &base_item = baseitems_info[this->k_idx];
const auto flavor = base_item.flavor;
* @brief オブジェクト価格算出のメインルーチン
* @return オブジェクトの判明している現価格
*/
-int ObjectType::get_price() const
+int ItemEntity::get_price() const
{
int value;
const auto is_worthless = this->is_broken() || this->is_cursed();
* @brief 未鑑定なベースアイテムの基本価格を返す
* @return オブジェクトの未鑑定価格
*/
-int ObjectType::get_baseitem_price() const
+int ItemEntity::get_baseitem_price() const
{
if (this->is_aware()) {
return baseitems_info[this->k_idx].cost;
}
}
-int ObjectType::calc_figurine_value() const
+int ItemEntity::calc_figurine_value() const
{
auto figure_r_idx = i2enum<MonsterRaceId>(this->pval);
auto level = monraces_info[figure_r_idx].level;
return 14000 + (level - 50) * 2000;
}
-int ObjectType::calc_capture_value() const
+int ItemEntity::calc_capture_value() const
{
auto capture_r_idx = i2enum<MonsterRaceId>(this->pval);
if (!MonsterRace(capture_r_idx).is_valid()) {
return (monraces_info[capture_r_idx].level) * 50 + 1000;
}
-bool ObjectType::is_specific_artifact(FixedArtifactId id) const
+bool ItemEntity::is_specific_artifact(FixedArtifactId id) const
{
return this->fixed_artifact_idx == id;
}
enum class SmithEffectType : int16_t;
enum class RandomArtActType : short;
-class ObjectType {
+class ItemEntity {
public:
- ObjectType();
+ ItemEntity();
KIND_OBJECT_IDX k_idx{}; /*!< Kind index (zero if "dead") */
POSITION iy{}; /*!< Y-position on map, or zero */
POSITION ix{}; /*!< X-position on map, or zero */
int artifact_bias{}; /*!< ランダムアーティファクト生成時のバイアスID */
void wipe();
- void copy_from(const ObjectType *j_ptr);
+ void copy_from(const ItemEntity *j_ptr);
void prep(KIND_OBJECT_IDX ko_idx);
bool is_weapon() const;
bool is_weapon_ammo() const;
bool is_activatable() const;
bool is_fuel() const;
bool is_book() const;
- bool is_glove_same_temper(const ObjectType *j_ptr) const;
- bool can_pile(const ObjectType *j_ptr) const;
+ bool is_glove_same_temper(const ItemEntity *j_ptr) const;
+ bool can_pile(const ItemEntity *j_ptr) const;
TERM_COLOR get_color() const;
char get_symbol() const;
int get_price() const;
enum class MonsterRaceId : int16_t;
class FloorType;
-class ObjectType;
+class ItemEntity;
class TimedEffects;
class PlayerType {
public:
byte feeling{}; /* Most recent dungeon feeling */
int32_t feeling_turn{}; /* The turn of the last dungeon feeling */
- std::shared_ptr<ObjectType[]> inventory_list{}; /* The player's inventory */
+ std::shared_ptr<ItemEntity[]> inventory_list{}; /* The player's inventory */
int16_t inven_cnt{}; /* Number of items in inventory */
int16_t equip_cnt{}; /* Number of items in equipment */
{
for (const auto this_o_idx : eg_ptr->m_ptr->hold_o_idx_list) {
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
describe_flavor(player_ptr, o_name, o_ptr, 0);
#ifdef JP
}
GAME_TEXT o_name[MAX_NLEN];
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[eg_ptr->floor_list[0]];
describe_flavor(player_ptr, o_name, o_ptr, 0);
#ifdef JP
}
}
-static int16_t describe_footing_sight(PlayerType *player_ptr, eg_type *eg_ptr, ObjectType *o_ptr)
+static int16_t describe_footing_sight(PlayerType *player_ptr, eg_type *eg_ptr, ItemEntity *o_ptr)
{
if ((o_ptr->marked & OM_FOUND) == 0) {
return CONTINUOUS_DESCRIPTION;
static int16_t sweep_footing_items(PlayerType *player_ptr, eg_type *eg_ptr)
{
for (const auto this_o_idx : eg_ptr->g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
int16_t ret = describe_footing_sight(player_ptr, eg_ptr, o_ptr);
if (within_char_util(ret)) {
}
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (o_ptr->marked & OM_FOUND) {
return true;
* @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
* @return o_ptrの方が上位ならばTRUEを返す。
*/
-bool object_sort_comp(PlayerType *player_ptr, ObjectType *o_ptr, int32_t o_value, ObjectType *j_ptr)
+bool object_sort_comp(PlayerType *player_ptr, ItemEntity *o_ptr, int32_t o_value, ItemEntity *j_ptr)
{
int o_type, j_type;
if (!j_ptr->k_idx) {
#include "system/angband.h"
-class ObjectType;
+class ItemEntity;
class PlayerType;
-bool object_sort_comp(PlayerType *player_ptr, ObjectType *o_ptr, int32_t o_value, ObjectType *j_ptr);
+bool object_sort_comp(PlayerType *player_ptr, ItemEntity *o_ptr, int32_t o_value, ItemEntity *j_ptr);
{
COMMAND_CODE i;
int k, l, z = 0;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
char tmp_val[80];
COMMAND_CODE out_index[23];
}
for (const auto this_o_idx : g_ptr->o_idx_list) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
if (!(o_ptr->marked & OM_FOUND)) {
continue;
* @param stat 能力値番号
* @param flags 装備品に立っているフラグ
*/
-static void compensate_stat_by_weapon(char *c, TERM_COLOR *a, ObjectType *o_ptr, tr_type tr_flag, const TrFlags &flags)
+static void compensate_stat_by_weapon(char *c, TERM_COLOR *a, ItemEntity *o_ptr, tr_type tr_flag, const TrFlags &flags)
{
*c = '*';
static void display_equipments_compensation(PlayerType *player_ptr, int row, int *col)
{
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
auto flags = object_flags_known(o_ptr);
for (int stat = 0; stat < A_MAX; stat++) {
*/
void display_entry(PlayerType *player_ptr, int pos, StoreSaleType store_num)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &st_ptr->stock[pos];
int i = (pos % store_bottom);
*/
void display_koff(PlayerType *player_ptr, KIND_OBJECT_IDX k_idx)
{
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
int sval;
int16_t use_realm;
GAME_TEXT o_name[MAX_NLEN];
* @param shots 射撃回数
* @param shot_frac 射撃速度
*/
-static void calc_shot_params(PlayerType *player_ptr, ObjectType *o_ptr, int *shots, int *shot_frac)
+static void calc_shot_params(PlayerType *player_ptr, ItemEntity *o_ptr, int *shots, int *shot_frac)
{
if (o_ptr->k_idx == 0) {
return;
* @param o_ptr 装備中の武器への参照ポインタ
* @return 利き手ならTRUE、反対の手ならFALSE
*/
-static bool calc_weapon_damage_limit(PlayerType *player_ptr, int hand, int *damage, int *basedam, ObjectType *o_ptr)
+static bool calc_weapon_damage_limit(PlayerType *player_ptr, int hand, int *damage, int *basedam, ItemEntity *o_ptr)
{
PLAYER_LEVEL level = player_ptr->lev;
if (hand > 0) {
* @param basedam 素手における直接攻撃のダメージ
* @return 素手ならFALSE、武器を持っていればTRUE
*/
-static bool calc_weapon_one_hand(ObjectType *o_ptr, int hand, int *damage, int *basedam)
+static bool calc_weapon_one_hand(ItemEntity *o_ptr, int hand, int *damage, int *basedam)
{
if (o_ptr->k_idx == 0) {
return false;
* @return 強化後の素手ダメージ
* @todo ヴォーパル計算処理が building-craft-weapon::compare_weapon_aux() と多重実装.
*/
-static int strengthen_basedam(PlayerType *player_ptr, ObjectType *o_ptr, int basedam, const TrFlags &flgs)
+static int strengthen_basedam(PlayerType *player_ptr, ItemEntity *o_ptr, int basedam, const TrFlags &flgs)
{
const auto is_vorpal_blade = o_ptr->is_specific_artifact(FixedArtifactId::VORPAL_BLADE);
const auto is_chainsword = o_ptr->is_specific_artifact(FixedArtifactId::CHAINSWORD);
*/
static void calc_two_hands(PlayerType *player_ptr, int *damage, int *to_h)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_BOW];
for (int i = 0; i < 2; i++) {
*/
void display_player_various(PlayerType *player_ptr)
{
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_BOW];
int tmp = player_ptr->to_h_b + o_ptr->to_h;
int xthb = player_ptr->skill_thb + (tmp * BTH_PLUS_ADJ);
// (y,x) のアイテムを1行に1個ずつ書く。
TERM_LEN term_y = 1;
for (const auto o_idx : g_ptr->o_idx_list) {
- ObjectType *const o_ptr = &floor_ptr->o_list[o_idx];
+ ItemEntity *const o_ptr = &floor_ptr->o_list[o_idx];
// 未発見アイテムおよび金は対象外。
if (none_bits(o_ptr->marked, OM_FOUND) || o_ptr->tval == ItemKindType::GOLD) {
{
COMMAND_CODE i;
int j, k, l;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
char tmp_val[80];
GAME_TEXT o_name[MAX_NLEN];
COMMAND_CODE out_index[23];
POSITION panel_row_prt;
int match_autopick;
-ObjectType *autopick_obj; /*!< 各種自動拾い処理時に使うオブジェクトポインタ */
+ItemEntity *autopick_obj; /*!< 各種自動拾い処理時に使うオブジェクトポインタ */
int feat_priority; /*!< マップ縮小表示時に表示すべき地形の優先度を保管する */
static concptr simplify_list[][2] = {
(void)term_set_cursor(v);
}
-static void display_shortened_item_name(PlayerType *player_ptr, ObjectType *o_ptr, int y)
+static void display_shortened_item_name(PlayerType *player_ptr, ItemEntity *o_ptr, int y)
{
char buf[MAX_NLEN];
describe_flavor(player_ptr, buf, o_ptr, (OD_NO_FLAVOR | OD_OMIT_PREFIX | OD_NAME_ONLY));
vector<vector<char>> mc(hgt + 2, vector<char>(wid + 2, ' '));
vector<vector<byte>> mp(hgt + 2, vector<byte>(wid + 2, 0));
vector<vector<int>> match_autopick_yx(hgt + 2, vector<int>(wid + 2, -1));
- vector<vector<ObjectType *>> object_autopick_yx(hgt + 2, vector<ObjectType *>(wid + 2, nullptr));
+ vector<vector<ItemEntity *>> object_autopick_yx(hgt + 2, vector<ItemEntity *>(wid + 2, nullptr));
vector<vector<TERM_COLOR>> bigma(floor_ptr->height + 2, vector<TERM_COLOR>(floor_ptr->width + 2, TERM_WHITE));
vector<vector<char>> bigmc(floor_ptr->height + 2, vector<char>(floor_ptr->width + 2, ' '));
#define ROW_MAP 0
#define COL_MAP 12
-class ObjectType;
-extern ObjectType *autopick_obj;
+class ItemEntity;
+extern ItemEntity *autopick_obj;
extern POSITION panel_row_min;
extern POSITION panel_row_max;
extern POSITION panel_col_min;
* @param o_ptr 記述を得たいオブジェクトの参照ポインタ
* @param desc_ptr 記述内容を返すための文字列参照ポインタ
*/
-static void analyze_general(PlayerType *player_ptr, ObjectType *o_ptr, char *desc_ptr)
+static void analyze_general(PlayerType *player_ptr, ItemEntity *o_ptr, char *desc_ptr)
{
describe_flavor(player_ptr, desc_ptr, o_ptr, OD_NAME_AND_ENCHANT | OD_STORE | OD_DEBUG);
}
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param pi_ptr pval修正構造体の参照ポインタ
*/
-static void analyze_pval(ObjectType *o_ptr, pval_info_type *pi_ptr)
+static void analyze_pval(ItemEntity *o_ptr, pval_info_type *pi_ptr)
{
concptr *affects_list;
if (!o_ptr->pval) {
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param slay_list 種族スレイ構造体の参照ポインタ
*/
-static void analyze_slay(ObjectType *o_ptr, concptr *slay_list)
+static void analyze_slay(ItemEntity *o_ptr, concptr *slay_list)
{
auto flgs = object_flags(o_ptr);
slay_list = spoiler_flag_aux(flgs, slay_flags_desc, slay_list, N_ELEMENTS(slay_flags_desc));
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param brand_list 属性ブランド構造体の参照ポインタ
*/
-static void analyze_brand(ObjectType *o_ptr, concptr *brand_list)
+static void analyze_brand(ItemEntity *o_ptr, concptr *brand_list)
{
auto flgs = object_flags(o_ptr);
brand_list = spoiler_flag_aux(flgs, brand_flags_desc, brand_list, N_ELEMENTS(brand_flags_desc));
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param resist_list 通常耐性構造体の参照ポインタ
*/
-static void analyze_resist(ObjectType *o_ptr, concptr *resist_list)
+static void analyze_resist(ItemEntity *o_ptr, concptr *resist_list)
{
auto flgs = object_flags(o_ptr);
resist_list = spoiler_flag_aux(flgs, resist_flags_desc, resist_list, N_ELEMENTS(resist_flags_desc));
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param immune_list 免疫構造体の参照ポインタ
*/
-static void analyze_immune(ObjectType *o_ptr, concptr *immune_list)
+static void analyze_immune(ItemEntity *o_ptr, concptr *immune_list)
{
auto flgs = object_flags(o_ptr);
immune_list = spoiler_flag_aux(flgs, immune_flags_desc, immune_list, N_ELEMENTS(immune_flags_desc));
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param immune_list 弱点構造体の参照ポインタ
*/
-static void analyze_vulnerable(ObjectType *o_ptr, concptr *vulnerable_list)
+static void analyze_vulnerable(ItemEntity *o_ptr, concptr *vulnerable_list)
{
auto flgs = object_flags(o_ptr);
vulnerable_list = spoiler_flag_aux(flgs, vulnerable_flags_desc, vulnerable_list, N_ELEMENTS(vulnerable_flags_desc));
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param sustain_list 維持特性構造体の参照ポインタ
*/
-static void analyze_sustains(ObjectType *o_ptr, concptr *sustain_list)
+static void analyze_sustains(ItemEntity *o_ptr, concptr *sustain_list)
{
auto flgs = object_flags(o_ptr);
if (flgs.has_all_of(EnumRange(TR_SUST_STR, TR_SUST_CHR))) {
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param misc_list その他の特性構造体の参照ポインタ
*/
-static void analyze_misc_magic(ObjectType *o_ptr, concptr *misc_list)
+static void analyze_misc_magic(ItemEntity *o_ptr, concptr *misc_list)
{
char desc[256];
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param addition 追加ランダム耐性構造体の参照ポインタ
*/
-static void analyze_addition(ObjectType *o_ptr, char *addition)
+static void analyze_addition(ItemEntity *o_ptr, char *addition)
{
const auto &a_ref = artifacts_info.at(o_ptr->fixed_artifact_idx);
strcpy(addition, "");
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param misc_desc 基本情報を収める文字列参照ポインタ
*/
-static void analyze_misc(ObjectType *o_ptr, char *misc_desc)
+static void analyze_misc(ItemEntity *o_ptr, char *misc_desc)
{
const auto &a_ref = artifacts_info.at(o_ptr->fixed_artifact_idx);
sprintf(misc_desc, _("レベル %d, 希少度 %u, %d.%d kg, ＄%ld", "Level %d, Rarity %u, %d.%d lbs, %ld Gold"), (int)a_ref.level, a_ref.rarity,
* @param o_ptr オブジェクト構造体の参照ポインタ
* @param desc_ptr 全アーティファクト情報を収める文字列参照ポインタ
*/
-void object_analyze(PlayerType *player_ptr, ObjectType *o_ptr, obj_desc_list *desc_ptr)
+void object_analyze(PlayerType *player_ptr, ItemEntity *o_ptr, obj_desc_list *desc_ptr)
{
analyze_general(player_ptr, o_ptr, desc_ptr->description);
analyze_pval(o_ptr, &desc_ptr->pval_info);
* @param o_ptr ランダムアーティファクトのオブジェクト構造体参照ポインタ
* @param desc_ptr 記述内容を収める構造体参照ポインタ
*/
-void random_artifact_analyze(PlayerType *player_ptr, ObjectType *o_ptr, obj_desc_list *desc_ptr)
+void random_artifact_analyze(PlayerType *player_ptr, ItemEntity *o_ptr, obj_desc_list *desc_ptr)
{
analyze_general(player_ptr, o_ptr, desc_ptr->description);
analyze_pval(o_ptr, &desc_ptr->pval_info);
#pragma once
-class ObjectType;
+class ItemEntity;
struct obj_desc_list;
class PlayerType;
-void object_analyze(PlayerType *player_ptr, ObjectType *o_ptr, obj_desc_list *desc_ptr);
-void random_artifact_analyze(PlayerType *player_ptr, ObjectType *o_ptr, obj_desc_list *desc_ptr);
+void object_analyze(PlayerType *player_ptr, ItemEntity *o_ptr, obj_desc_list *desc_ptr);
+void random_artifact_analyze(PlayerType *player_ptr, ItemEntity *o_ptr, obj_desc_list *desc_ptr);
* @param fixed_artifact_idx 生成するアーティファクトID
* @return 生成が成功した場合TRUEを返す
*/
-static bool make_fake_artifact(ObjectType *o_ptr, FixedArtifactId fixed_artifact_idx)
+static bool make_fake_artifact(ItemEntity *o_ptr, FixedArtifactId fixed_artifact_idx)
{
auto &a_ref = artifacts_info.at(fixed_artifact_idx);
if (a_ref.name.empty()) {
continue;
}
- ObjectType item;
+ ItemEntity item;
if (!make_fake_artifact(&item, a_idx)) {
continue;
}
*/
static void kind_info(PlayerType *player_ptr, char *buf, char *dam, char *wgt, char *chance, DEPTH *lev, PRICE *val, KIND_OBJECT_IDX k)
{
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->prep(k);
q_ptr->ident |= IDENT_KNOWN;
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 詳細を表示するアイテム情報の参照ポインタ
*/
-static void wiz_display_item(PlayerType *player_ptr, ObjectType *o_ptr)
+static void wiz_display_item(PlayerType *player_ptr, ItemEntity *o_ptr)
{
auto flgs = object_flags(o_ptr);
auto get_seq_32bits = [](const TrFlags &flgs, uint start) {
* counter flags to prevent weirdness. We use the items to collect
* statistics on item creation relative to the initial item.
*/
-static void wiz_statistics(PlayerType *player_ptr, ObjectType *o_ptr)
+static void wiz_statistics(PlayerType *player_ptr, ItemEntity *o_ptr)
{
concptr q = "Rolls: %ld Correct: %ld Matches: %ld Better: %ld Worse: %ld Other: %ld";
concptr p = "Enter number of items to roll: ";
term_fresh();
}
- ObjectType forge;
+ ItemEntity forge;
auto *q_ptr = &forge;
q_ptr->wipe();
make_object(player_ptr, q_ptr, mode);
* Apply magic to an item or turn it into an artifact. -Bernd-
* @param o_ptr 再生成の対象となるアイテム情報の参照ポインタ
*/
-static void wiz_reroll_item(PlayerType *player_ptr, ObjectType *o_ptr)
+static void wiz_reroll_item(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (o_ptr->is_artifact()) {
return;
}
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->copy_from(o_ptr);
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 調整するアイテムの参照ポインタ
*/
-static void wiz_tweak_item(PlayerType *player_ptr, ObjectType *o_ptr)
+static void wiz_tweak_item(PlayerType *player_ptr, ItemEntity *o_ptr)
{
if (o_ptr->is_artifact()) {
return;
* @param player_ptr プレイヤーへの参照ポインタ
* @param o_ptr 変更するアイテム情報構造体の参照ポインタ
*/
-static void wiz_quantity_item(ObjectType *o_ptr)
+static void wiz_quantity_item(ItemEntity *o_ptr)
{
if (o_ptr->is_artifact()) {
return;
concptr q = "Play with which object? ";
concptr s = "You have nothing to play with.";
OBJECT_IDX item;
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = choose_object(player_ptr, &item, q, s, USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT);
if (!o_ptr) {
return;
screen_save();
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
q_ptr = &forge;
q_ptr->copy_from(o_ptr);
char ch;
/*!
* @brief オブジェクトの装備スロットがエゴが有効なスロットかどうか判定
*/
-static int is_slot_able_to_be_ego(PlayerType *player_ptr, ObjectType *o_ptr)
+static int is_slot_able_to_be_ego(PlayerType *player_ptr, ItemEntity *o_ptr)
{
int slot = wield_slot(player_ptr, o_ptr);
char buf[MAX_NLEN] = "\0";
char *str = buf;
- ObjectType forge;
+ ItemEntity forge;
auto *o_ptr = &forge;
char o_name[MAX_NLEN];
}
}
- ObjectType item;
+ ItemEntity item;
item.prep(bi_id);
ItemMagicApplier(player_ptr, &item, player_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART).execute();
(void)drop_near(player_ptr, &item, -1, player_ptr->y, player_ptr->x);
static std::string wiz_make_named_artifact_desc(PlayerType *player_ptr, FixedArtifactId a_idx)
{
const auto &a_ref = artifacts_info.at(a_idx);
- ObjectType item;
+ ItemEntity item;
item.prep(lookup_baseitem_id(a_ref.bi_key));
item.fixed_artifact_idx = a_idx;
object_known(&item);
*/
void wiz_learn_items_all(PlayerType *player_ptr)
{
- ObjectType forge;
- ObjectType *q_ptr;
+ ItemEntity forge;
+ ItemEntity *q_ptr;
for (const auto &k_ref : baseitems_info) {
if (k_ref.idx > 0 && k_ref.level <= command_arg) {
q_ptr = &forge;
auto magic_ptr = &class_magics_info[c];
concptr book_name = "なし";
if (magic_ptr->spell_book != ItemKindType::NONE) {
- ObjectType book;
+ ItemEntity book;
auto o_ptr = &book;
o_ptr->prep(lookup_baseitem_id({ magic_ptr->spell_book, 0 }));
describe_flavor(&dummy_p, title, o_ptr, OD_NAME_ONLY);
}
for (OBJECT_IDX i = 1; i < floor_ptr->o_max; i++) {
- ObjectType *o_ptr;
+ ItemEntity *o_ptr;
o_ptr = &floor_ptr->o_list[i];
if (o_ptr->k_idx) {
continue;
OSDN Git Service
