<ClCompile Include="..\..\src\store\sell-order.cpp" />\r
<ClCompile Include="..\..\src\store\service-checker.cpp" />\r
<ClCompile Include="..\..\src\system\angband-version.cpp" />\r
+ <ClCompile Include="..\..\src\system\object-type-definition.cpp" />\r
<ClCompile Include="..\..\src\system\player-type-definition.cpp" />\r
<ClCompile Include="..\..\src\target\grid-selector.cpp" />\r
<ClCompile Include="..\..\src\target\projection-path-calculator.cpp" />\r
<ClCompile Include="..\..\src\object\object-stack.cpp" />\r
<ClCompile Include="..\..\src\object\object-value-calc.cpp" />\r
<ClCompile Include="..\..\src\perception\object-perception.cpp" />\r
- <ClCompile Include="..\..\src\object\object-generator.cpp" />\r
<ClCompile Include="..\..\src\object\object-value.cpp" />\r
<ClCompile Include="..\..\src\pet\pet-fall-off.cpp" />\r
<ClCompile Include="..\..\src\mspell\mspell-floor.cpp" />\r
<ClInclude Include="..\..\src\cmd-action\cmd-tunnel.h" />\r
<ClInclude Include="..\..\src\action\movement-execution.h" />\r
<ClInclude Include="..\..\src\core\score-util.h" />\r
+ <ClInclude Include="..\..\src\dungeon\dungeon-flag-mask.h" />\r
<ClInclude Include="..\..\src\main-win\commandline-win.h" />\r
<ClInclude Include="..\..\src\main-win\graphics-win.h" />\r
<ClInclude Include="..\..\src\object-enchant\apply-magic-amulet.h" />\r
<ClInclude Include="..\..\src\object\object-stack.h" />\r
<ClInclude Include="..\..\src\object\object-value-calc.h" />\r
<ClInclude Include="..\..\src\perception\object-perception.h" />\r
- <ClInclude Include="..\..\src\object\object-generator.h" />\r
<ClInclude Include="..\..\src\object\object-value.h" />\r
<ClInclude Include="..\..\src\pet\pet-fall-off.h" />\r
<ClInclude Include="..\..\src\pet\pet-util.h" />\r
<ClCompile Include="..\..\src\world\world-object.cpp">\r
<Filter>world</Filter>\r
</ClCompile>\r
- <ClCompile Include="..\..\src\object\object-generator.cpp">\r
- <Filter>object</Filter>\r
- </ClCompile>\r
<ClCompile Include="..\..\src\object-enchant\object-boost.cpp">\r
<Filter>object-enchant</Filter>\r
</ClCompile>\r
<ClCompile Include="..\..\src\object-enchant\apply-magic-amulet.cpp">\r
<Filter>object-enchant</Filter>\r
</ClCompile>\r
+ <ClCompile Include="..\..\src\system\object-type-definition.cpp">\r
+ <Filter>system</Filter>\r
+ </ClCompile>\r
</ItemGroup>\r
<ItemGroup>\r
<ClInclude Include="..\..\src\combat\shoot.h">\r
<ClInclude Include="..\..\src\world\world-object.h">\r
<Filter>world</Filter>\r
</ClInclude>\r
- <ClInclude Include="..\..\src\object\object-generator.h">\r
- <Filter>object</Filter>\r
- </ClInclude>\r
<ClInclude Include="..\..\src\sv-definition\sv-armor-types.h">\r
<Filter>sv-definition</Filter>\r
</ClInclude>\r
<ClInclude Include="..\..\src\object-enchant\apply-magic-amulet.h">\r
<Filter>object-enchant</Filter>\r
</ClInclude>\r
+ <ClInclude Include="..\..\src\dungeon\dungeon-flag-mask.h">\r
+ <Filter>dungeon</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
<None Include="..\..\src\wall.bmp" />\r
X:17:8:10:10
D: %%%%
D: %%##%%
-D: %%.. .%%
-D:%%.#. #.%%
+D: %%....%%
+D:%%.#..#.%%
D:%#..##..#%
D:%#..##..#%
-D:%%.#. #.%%
-D: %%.. .%%
+D:%%.#..#.%%
+D: %%....%%
D: %%##%%
D: %%%%
core/window-redrawer.cpp core/window-redrawer.h \
\
dungeon/dungeon.cpp dungeon/dungeon.h \
+ dungeon/dungeon-flag-mask.h \
dungeon/dungeon-flag-types.h \
dungeon/dungeon-processor.cpp dungeon/dungeon-processor.h \
dungeon/quest.h dungeon/quest.cpp \
object/item-tester-hooker.cpp object/item-tester-hooker.h \
object/object-broken.cpp object/object-broken.h \
object/object-flags.cpp object/object-flags.h \
- object/object-generator.cpp object/object-generator.h \
object/object-info.cpp object/object-info.h \
object/object-kind.cpp object/object-kind.h \
object/object-kind-hook.cpp object/object-kind-hook.h \
system/h-define.h system/h-system.h system/h-type.h \
system/monster-race-definition.h \
system/monster-type-definition.h \
- system/object-type-definition.h \
+ system/object-type-definition.cpp system/object-type-definition.h \
system/player-type-definition.cpp system/player-type-definition.h \
system/system-variables.cpp system/system-variables.h \
system/gamevalue.h \
*/
bool cmd_limit_cast(player_type *creature_ptr)
{
- if (is_in_dungeon(creature_ptr) && (d_info[creature_ptr->dungeon_idx].flags1 & DF1_NO_MAGIC)) {
+ if (is_in_dungeon(creature_ptr) && (d_info[creature_ptr->dungeon_idx].flags.has(DF::NO_MAGIC))) {
msg_print(_("ダンジョンが魔法を吸収した！", "The dungeon absorbs all attempted magic!"));
msg_print(NULL);
return TRUE;
#include "inventory/inventory-slot-types.h"
#include "object-hook/hook-checker.h"
#include "object-hook/hook-weapon.h"
-#include "object/object-generator.h"
#include "player-info/equipment-info.h"
#include "player-status/player-hand-types.h"
#include "system/object-type-definition.h"
}
new_o_ptr = &owner_ptr->inventory_list[INVEN_MAIN_HAND];
- object_copy(new_o_ptr, o_ptr);
+ new_o_ptr->copy_from(o_ptr);
inven_item_increase(owner_ptr, INVEN_SUB_HAND, -((int)o_ptr->number));
inven_item_optimize(owner_ptr, INVEN_SUB_HAND);
if (object_allow_two_hands_wielding(o_ptr) && can_two_hands_wielding(owner_ptr))
return;
new_o_ptr = &owner_ptr->inventory_list[INVEN_SUB_HAND];
- object_copy(new_o_ptr, o_ptr);
+ new_o_ptr->copy_from(o_ptr);
inven_item_increase(owner_ptr, INVEN_MAIN_HAND, -((int)o_ptr->number));
inven_item_optimize(owner_ptr, INVEN_MAIN_HAND);
msg_format(_("%sを持ち替えた。", "You switched hand of %s."), o_name);
#include "object-enchant/tr-types.h"
#include "object-enchant/trc-types.h"
#include "object-enchant/trg-types.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
#include "player/player-sex.h"
object_type forge;
auto q_ptr = &forge;
- object_prep(player_ptr, q_ptr, i);
+ q_ptr->prep(player_ptr, i);
q_ptr->name1 = a_idx;
(void)apply_artifact(player_ptr, q_ptr);
/*! @note 前述の条件を満たしたら、後のIDのアーティファクトはチェックせずすぐ確定し生成処理に移す /
* Assign the template. Mega-Hack -- mark the item as an artifact. Hack: Some artifacts get random extra powers. Success. */
- object_prep(player_ptr, o_ptr, k_idx);
+ o_ptr->prep(player_ptr, k_idx);
o_ptr->name1 = i;
return true;
#include "monster-race/monster-race.h"
#include "monster-race/race-flags1.h"
#include "monster-race/race-flags7.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "pet/pet-util.h"
#include "player/digestion-processor.h"
creature_ptr->inven_cnt = 0;
creature_ptr->equip_cnt = 0;
for (int i = 0; i < INVEN_TOTAL; i++)
- object_wipe(&creature_ptr->inventory_list[i]);
+ (&creature_ptr->inventory_list[i])->wipe();
for (int i = 0; i < max_a_idx; i++) {
artifact_type *a_ptr = &a_info[i];
#include "object-enchant/apply-magic.h"
#include "object-enchant/item-apply-magic.h"
#include "object-enchant/object-ego.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
object_type *i_ptr;
i_ptr = &object_type_body;
- object_copy(i_ptr, o_ptr);
+ i_ptr->copy_from(o_ptr);
i_ptr->number = 1;
if (item >= 0) {
}
o_ptr = &creature_ptr->inventory_list[slot];
- object_copy(o_ptr, i_ptr);
+ o_ptr->copy_from(i_ptr);
creature_ptr->equip_cnt++;
}
}
/* Demon can drain vitality from humanoid corpse */
get_mon_num_prep(creature_ptr, monster_hook_human, NULL);
for (int i = rand_range(3, 4); i > 0; i--) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_CORPSE, SV_CORPSE));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_CORPSE, SV_CORPSE));
q_ptr->pval = get_mon_num(creature_ptr, 0, 2, 0);
if (q_ptr->pval) {
q_ptr->number = 1;
case RACE_ZOMBIE:
case RACE_SPECTRE:
/* Staff (of Nothing) */
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_STAFF, SV_STAFF_NOTHING));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_STAFF, SV_STAFF_NOTHING));
q_ptr->number = 1;
add_outfit(creature_ptr, q_ptr);
break;
case RACE_ENT:
/* Potions of Water */
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_POTION, SV_POTION_WATER));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_POTION, SV_POTION_WATER));
q_ptr->number = (ITEM_NUMBER)rand_range(15, 23);
add_outfit(creature_ptr, q_ptr);
break;
case RACE_ANDROID:
/* Flasks of oil */
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FLASK, SV_ANY));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FLASK, SV_ANY));
apply_magic_to_object(creature_ptr, q_ptr, 1, AM_NO_FIXED_ART);
q_ptr->number = (ITEM_NUMBER)rand_range(7, 12);
add_outfit(creature_ptr, q_ptr);
break;
default:
/* Food rations */
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
q_ptr->number = (ITEM_NUMBER)rand_range(3, 7);
add_outfit(creature_ptr, q_ptr);
}
q_ptr = &forge;
if ((creature_ptr->prace == RACE_VAMPIRE) && (creature_ptr->pclass != CLASS_NINJA)) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_SCROLL, SV_SCROLL_DARKNESS));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_SCROLL, SV_SCROLL_DARKNESS));
q_ptr->number = (ITEM_NUMBER)rand_range(2, 5);
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass != CLASS_NINJA) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_LITE, SV_LITE_TORCH));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_LITE, SV_LITE_TORCH));
q_ptr->number = (ITEM_NUMBER)rand_range(3, 7);
q_ptr->xtra4 = rand_range(3, 7) * 500;
q_ptr = &forge;
if (creature_ptr->prace == RACE_MERFOLK) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_RING, SV_RING_LEVITATION_FALL));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_RING, SV_RING_LEVITATION_FALL));
q_ptr->number = 1;
add_outfit(creature_ptr, q_ptr);
}
if ((creature_ptr->pclass == CLASS_RANGER) || (creature_ptr->pclass == CLASS_CAVALRY)) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_ARROW, SV_AMMO_NORMAL));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_ARROW, SV_AMMO_NORMAL));
q_ptr->number = (byte)rand_range(15, 20);
add_outfit(creature_ptr, q_ptr);
}
if (creature_ptr->pclass == CLASS_RANGER) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_BOW, SV_SHORT_BOW));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_BOW, SV_SHORT_BOW));
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass == CLASS_ARCHER) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_ARROW, SV_AMMO_NORMAL));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_ARROW, SV_AMMO_NORMAL));
q_ptr->number = (ITEM_NUMBER)rand_range(15, 20);
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass == CLASS_HIGH_MAGE || creature_ptr->pclass == CLASS_ELEMENTALIST) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_WAND, SV_WAND_MAGIC_MISSILE));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_WAND, SV_WAND_MAGIC_MISSILE));
q_ptr->number = 1;
q_ptr->pval = (PARAMETER_VALUE)rand_range(25, 30);
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass == CLASS_SORCERER) {
int book_tval;
for (book_tval = TV_LIFE_BOOK; book_tval <= TV_LIFE_BOOK + static_cast<int>(MAX_MAGIC) - 1; book_tval++) {
- object_prep(creature_ptr, q_ptr, lookup_kind(static_cast<tval_type>(book_tval), 0));
+ q_ptr->prep(creature_ptr, lookup_kind(static_cast<tval_type>(book_tval), 0));
q_ptr->number = 1;
add_outfit(creature_ptr, q_ptr);
}
} else if (creature_ptr->pclass == CLASS_TOURIST) {
if (creature_ptr->pseikaku != PERSONALITY_SEXY) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_SHOT, SV_AMMO_LIGHT));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_SHOT, SV_AMMO_LIGHT));
q_ptr->number = rand_range(15, 20);
add_outfit(creature_ptr, q_ptr);
}
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_BISCUIT));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_BISCUIT));
q_ptr->number = rand_range(2, 4);
add_outfit(creature_ptr, q_ptr);
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_WAYBREAD));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_WAYBREAD));
q_ptr->number = rand_range(2, 4);
add_outfit(creature_ptr, q_ptr);
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_JERKY));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_JERKY));
q_ptr->number = rand_range(1, 3);
add_outfit(creature_ptr, q_ptr);
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_PINT_OF_ALE));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_PINT_OF_ALE));
q_ptr->number = rand_range(2, 4);
add_outfit(creature_ptr, q_ptr);
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_PINT_OF_WINE));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_PINT_OF_WINE));
q_ptr->number = rand_range(2, 4);
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass == CLASS_NINJA) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_SPIKE, 0));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_SPIKE, 0));
q_ptr->number = rand_range(15, 20);
add_outfit(creature_ptr, q_ptr);
} else if (creature_ptr->pclass == CLASS_SNIPER) {
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_BOLT, SV_AMMO_NORMAL));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_BOLT, SV_AMMO_NORMAL));
q_ptr->number = rand_range(15, 20);
add_outfit(creature_ptr, q_ptr);
}
}
q_ptr = &forge;
- object_prep(creature_ptr, q_ptr, lookup_kind(static_cast<tval_type>(tv), sv));
+ q_ptr->prep(creature_ptr, lookup_kind(static_cast<tval_type>(tv), sv));
if ((tv == TV_SWORD || tv == TV_HAFTED)
&& (creature_ptr->pclass == CLASS_ROGUE && creature_ptr->realm1 == REALM_DEATH)) /* Only assassins get a poisoned weapon */
q_ptr->name2 = EGO_BRAND_POIS;
}
}
- if (d_info[attacker_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) {
+ if (d_info[attacker_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
msg_print(_("なぜか攻撃することができない。", "Something prevents you from attacking."));
return FALSE;
}
#include "object-hook/hook-expendable.h"
#include "object-hook/hook-magic.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-stack.h"
#include "object/object-value.h"
#include "player-info/avatar.h"
static void exe_destroy_item(player_type *creature_ptr, destroy_type *destroy_ptr)
{
- object_copy(destroy_ptr->q_ptr, destroy_ptr->o_ptr);
+ destroy_ptr->q_ptr->copy_from(destroy_ptr->o_ptr);
msg_format(_("%sを壊した。", "You destroy %s."), destroy_ptr->o_name);
sound(SOUND_DESTITEM);
reduce_charges(destroy_ptr->o_ptr, destroy_ptr->amt);
#include "object-hook/hook-expendable.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
/* Modify quantity */
q_ptr->number = 1;
object_type *q_ptr = &forge;
msg_print(_("食べ物がアゴを素通りして落ちた！", "The food falls through your jaws!"));
- object_prep(creature_ptr, q_ptr, lookup_kind(o_ptr->tval, o_ptr->sval));
+ q_ptr->prep(creature_ptr, lookup_kind(o_ptr->tval, o_ptr->sval));
/* Drop the object from heaven */
(void)drop_near(creature_ptr, q_ptr, -1, creature_ptr->y, creature_ptr->x);
#include "object-hook/hook-weapon.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-mark-types.h"
#include "perception/object-perception.h"
object_type *otmp_ptr = &object_tmp;
GAME_TEXT switch_name[MAX_NLEN];
describe_flavor(creature_ptr, switch_name, switch_o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
- object_copy(otmp_ptr, switch_o_ptr);
- object_copy(switch_o_ptr, slot_o_ptr);
- object_copy(slot_o_ptr, otmp_ptr);
+ otmp_ptr->copy_from(switch_o_ptr);
+ switch_o_ptr->copy_from(slot_o_ptr);
+ slot_o_ptr->copy_from(otmp_ptr);
msg_format(_("%sを%sに構えなおした。", "You wield %s at %s hand."), switch_name,
(slot == INVEN_MAIN_HAND) ? (left_hander ? _("左手", "left") : _("右手", "right")) : (left_hander ? _("右手", "right") : _("左手", "left")));
slot = need_switch_wielding;
PlayerEnergy(creature_ptr).set_player_turn_energy(100);
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = 1;
if (item >= 0) {
inven_item_increase(creature_ptr, item, -1);
if (o_ptr->k_idx)
(void)inven_takeoff(creature_ptr, slot, 255);
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
o_ptr->marked |= OM_TOUCHED;
creature_ptr->equip_cnt++;
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
#include "object/object-flags.h" //!< @todo 相互参照している.
-#include "object/object-generator.h"
#include "perception/object-perception.h"
#include "player-status/player-energy.h"
#include "system/object-type-definition.h"
marked = o_ptr->marked;
number = o_ptr->number;
- object_prep(creature_ptr, o_ptr, o_ptr->k_idx);
+ o_ptr->prep(creature_ptr, o_ptr->k_idx);
o_ptr->iy = iy;
o_ptr->ix = ix;
#include "object/item-use-flags.h"
#include "object/object-broken.h"
#include "object/object-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "object/object-stack.h"
static void calc_throw_range(player_type *creature_ptr, it_type *it_ptr)
{
- object_copy(it_ptr->q_ptr, it_ptr->o_ptr);
+ it_ptr->q_ptr->copy_from(it_ptr->o_ptr);
object_flags(creature_ptr, it_ptr->q_ptr, it_ptr->obj_flags);
torch_flags(it_ptr->q_ptr, it_ptr->obj_flags);
distribute_charges(it_ptr->o_ptr, it_ptr->q_ptr, 1);
}
it_ptr->o_ptr = &creature_ptr->inventory_list[it_ptr->item];
- object_copy(it_ptr->o_ptr, it_ptr->q_ptr);
+ it_ptr->o_ptr->copy_from(it_ptr->q_ptr);
creature_ptr->equip_cnt++;
creature_ptr->update |= PU_BONUS | PU_TORCH | PU_MANA;
creature_ptr->window_flags |= PW_EQUIP;
#include "monster-floor/place-monster-types.h"
#include "object-enchant/special-object-flags.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "perception/object-perception.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
/* Modify quantity */
q_ptr->number = 1;
#include "knowledge/lighting-level-table.h"
#include "main/sound-of-music.h"
#include "monster-race/monster-race.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "system/monster-race-definition.h"
#include "system/object-type-definition.h"
if (!k_ptr->flavor) {
strip_name(o_name, k_idx);
} else {
- object_type forge;
- object_prep(creature_ptr, &forge, k_idx);
- describe_flavor(creature_ptr, o_name, &forge, OD_FORCE_FLAVOR);
+ object_type dummy;
+ dummy.prep(creature_ptr, k_idx);
+ describe_flavor(creature_ptr, o_name, &dummy, OD_FORCE_FLAVOR);
}
auto_dump_printf(auto_dump_stream, "# %s\n", o_name);
#include "object-hook/hook-enchant.h"
#include "object/object-broken.h"
#include "object/object-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "object/object-mark-types.h"
y = shooter_ptr->y;
x = shooter_ptr->x;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
/* Single object */
q_ptr->number = 1;
}
o_ptr = &shooter_ptr->current_floor_ptr->o_list[o_idx];
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
/* Forget mark */
reset_bits(o_ptr->marked, OM_TOUCHED);
#include "grid/grid.h"
#include "object-hook/hook-checker.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "system/floor-type-definition.h"
#include "system/monster-type-definition.h"
// 要素番号i1のオブジェクトを要素番号i2に移動
floor_ptr->o_list[i2] = floor_ptr->o_list[i1];
- object_wipe(o_ptr);
+ o_ptr->wipe();
}
/*!
--- /dev/null
+#pragma once
+
+#include "dungeon/dungeon-flag-types.h"
+#include "util/flag-group.h"
+
+inline const EnumClassFlagGroup<DF> DF_LAKE_MASK({ DF::LAKE_WATER, DF::LAKE_LAVA, DF::LAKE_RUBBLE, DF::LAKE_TREE, DF::LAKE_POISONOUS, DF::LAKE_ACID });
+inline const EnumClassFlagGroup<DF> DF_RIVER_MASK({ DF::WATER_RIVER, DF::LAVA_RIVER, DF::ACID_RIVER, DF::POISONOUS_RIVER });
#pragma once
-enum dungeon_flag_type {
- DF1_WINNER = 0x00000001L,
- DF1_MAZE = 0x00000002L,
- DF1_SMALLEST = 0x00000004L,
- DF1_BEGINNER = 0x00000008L,
- DF1_BIG = 0x00000010L,
- DF1_NO_DOORS = 0x00000020L,
- DF1_WATER_RIVER = 0x00000040L,
- DF1_LAVA_RIVER = 0x00000080L,
- DF1_CURTAIN = 0x00000100L,
- DF1_GLASS_DOOR = 0x00000200L,
- DF1_CAVE = 0x00000400L,
- DF1_CAVERN = 0x00000800L,
- DF1_ARCADE = 0x00001000L,
- DF1_LAKE_ACID = 0x00002000L,
- DF1_LAKE_POISONOUS = 0x00004000L,
- DF1_XXX15 = 0x00008000L,
- DF1_FORGET = 0x00010000L,
- DF1_LAKE_WATER = 0x00020000L,
- DF1_LAKE_LAVA = 0x00040000L,
- DF1_LAKE_RUBBLE = 0x00080000L,
- DF1_LAKE_TREE = 0x00100000L,
- DF1_NO_VAULT = 0x00200000L,
- DF1_ARENA = 0x00400000L,
- DF1_DESTROY = 0x00800000L,
- DF1_GLASS_ROOM = 0x01000000L,
- DF1_NO_CAVE = 0x02000000L,
- DF1_NO_MAGIC = 0x04000000L,
- DF1_NO_MELEE = 0x08000000L,
- DF1_CHAMELEON = 0x10000000L,
- DF1_DARKNESS = 0x20000000L,
- DF1_ACID_RIVER = 0x40000000L,
- DF1_POISONOUS_RIVER = 0x80000000L,
+enum class DF {
+ WINNER,
+ MAZE,
+ SMALLEST,
+ BEGINNER,
+ BIG,
+ NO_DOORS,
+ WATER_RIVER,
+ LAVA_RIVER,
+ CURTAIN,
+ GLASS_DOOR,
+ CAVE,
+ CAVERN,
+ ARCADE,
+ LAKE_ACID,
+ LAKE_POISONOUS,
+ NO_ROOM,
+ FORGET,
+ LAKE_WATER,
+ LAKE_LAVA,
+ LAKE_RUBBLE,
+ LAKE_TREE,
+ NO_VAULT,
+ ARENA,
+ DESTROY,
+ GLASS_ROOM,
+ NO_CAVE,
+ NO_MAGIC,
+ NO_MELEE,
+ CHAMELEON,
+ DARKNESS,
+ ACID_RIVER,
+ POISONOUS_RIVER,
+ MAX,
};
-
-#define DF1_LAKE_MASK (DF1_LAKE_WATER | DF1_LAKE_LAVA | DF1_LAKE_RUBBLE | DF1_LAKE_TREE | DF1_LAKE_POISONOUS | DF1_LAKE_ACID)
#include <string>
#include <vector>
+#include "dungeon/dungeon-flag-types.h"
#include "monster-race/race-ability-flags.h"
#include "system/angband.h"
#include "util/flag-group.h"
int min_m_alloc_level{}; /* Minimal number of monsters per level */
int max_m_alloc_chance{}; /* There is a 1/max_m_alloc_chance chance per round of creating a new monster */
- BIT_FLAGS flags1{}; /* Flags 1 */
+ EnumClassFlagGroup<DF> flags{}; /* Dungeon Flags */
BIT_FLAGS mflags1{}; /* The monster flags that are allowed */
BIT_FLAGS mflags2{};
#include "grid/grid.h"
#include "monster/monster-info.h"
#include "object-enchant/item-apply-magic.h"
-#include "object/object-generator.h"
#include "system/floor-type-definition.h"
#include "system/monster-type-definition.h"
#include "system/object-type-definition.h"
object_type *o_ptr;
for (int i = 0; i < (floor_ptr->dun_level / 15) + 1; i++) {
o_ptr = &forge;
- object_wipe(o_ptr);
+ o_ptr->wipe();
make_object(player_ptr, o_ptr, AM_GOOD | AM_GREAT);
(void)drop_near(player_ptr, o_ptr, -1, y, x);
}
#include "monster/smart-learn-types.h"
#include "object-enchant/item-apply-magic.h"
#include "object-enchant/trg-types.h"
-#include "object/object-generator.h"
#include "player-status/player-energy.h"
#include "player/player-personality-types.h"
#include "player/player-status.h"
}
case GF_LITE_WEAK:
case GF_LITE: {
- if ((d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS) != 0)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
break;
g_ptr->info |= (CAVE_GLOW);
#include "monster/monster-status.h"
#include "monster/monster-update.h"
#include "object-enchant/special-object-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "player-info/avatar.h"
#include "util/bit-flags-calculator.h"
object_type *q_ptr;
object_type forge;
q_ptr = &forge;
- object_prep(caster_ptr, q_ptr, lookup_kind(TV_STATUE, SV_PHOTO));
+ q_ptr->prep(caster_ptr, lookup_kind(TV_STATUE, SV_PHOTO));
q_ptr->pval = em_ptr->photo;
q_ptr->ident |= (IDENT_FULL_KNOWN);
(void)drop_near(caster_ptr, q_ptr, -1, caster_ptr->y, caster_ptr->x);
* @param t 保管先文字列ポインタ
* @param n コピーしたい数値
* @details
- * Print an unsigned number "n" into a string "t", as if by
+ * Print an unsigned number "n" into a string "t", actually by
* sprintf(t, "%u", n), and return a pointer to the terminator.
*/
char *object_desc_num(char *t, uint n)
{
- /* loop */
- uint p;
- for (p = 1; n >= p * 10; p = p * 10)
- ;
-
- while (p >= 1) {
- *t++ = '0' + n / p;
- n = n % p;
- p = p / 10;
+ int ret = sprintf(t, "%u", n);
+ if (ret < 0) {
+ // error
+ ret = 0;
+ *t = '\0';
}
-
- *t = '\0';
- return t;
+ return t + ret;
}
/*!
g_ptr = &player_ptr->current_floor_ptr->grid_array[dd_ptr->tunnel_y][dd_ptr->tunnel_x];
g_ptr->mimic = 0;
place_grid(player_ptr, g_ptr, GB_FLOOR);
- if ((randint0(100) < dt_ptr->dun_tun_pen) && !(d_ptr->flags1 & DF1_NO_DOORS))
+ if ((randint0(100) < dt_ptr->dun_tun_pen) && d_ptr->flags.has_not(DF::NO_DOORS))
place_random_door(player_ptr, dd_ptr->tunnel_y, dd_ptr->tunnel_x, TRUE);
}
}
}
}
+static void make_only_tunnel_points(floor_type *floor_ptr, dun_data_type *dd_ptr)
+{
+ int point_num = (floor_ptr->width * floor_ptr->height) / 200 + randint1(3);
+ dd_ptr->cent_n = point_num;
+ for (int i = 0; i < point_num; i++) {
+ dd_ptr->cent[i].y = randint0(floor_ptr->height);
+ dd_ptr->cent[i].x = randint0(floor_ptr->width);
+ }
+}
+
static bool make_one_floor(player_type *player_ptr, dun_data_type *dd_ptr, dungeon_type *d_ptr)
{
- if (!generate_rooms(player_ptr, dd_ptr)) {
- *dd_ptr->why = _("部屋群の生成に失敗", "Failed to generate rooms");
- return FALSE;
+ floor_type *floor_ptr = player_ptr->current_floor_ptr;
+
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_ROOM)) {
+ make_only_tunnel_points(floor_ptr, dd_ptr);
+ } else {
+ if (!generate_rooms(player_ptr, dd_ptr)) {
+ *dd_ptr->why = _("部屋群の生成に失敗", "Failed to generate rooms");
+ return FALSE;
+ }
}
place_cave_contents(player_ptr, dd_ptr, d_ptr);
static bool switch_making_floor(player_type *player_ptr, dun_data_type *dd_ptr, dungeon_type *d_ptr)
{
- if (d_ptr->flags1 & DF1_MAZE) {
+ if (d_ptr->flags.has(DF::MAZE)) {
floor_type *floor_ptr = player_ptr->current_floor_ptr;
build_maze_vault(player_ptr, floor_ptr->width / 2 - 1, floor_ptr->height / 2 - 1, floor_ptr->width - 4, floor_ptr->height - 4, FALSE);
if (!alloc_stairs(player_ptr, feat_down_stair, rand_range(2, 3), 3)) {
(void)alloc_monster(player_ptr, 0, PM_ALLOW_SLEEP, summon_specific);
alloc_object(player_ptr, ALLOC_SET_BOTH, ALLOC_TYP_TRAP, randint1(dd_ptr->alloc_object_num));
- if (!(d_ptr->flags1 & DF1_NO_CAVE))
+ if (d_ptr->flags.has_not(DF::NO_CAVE))
alloc_object(player_ptr, ALLOC_SET_CORR, ALLOC_TYP_RUBBLE, randint1(dd_ptr->alloc_object_num));
floor_type *floor_ptr = player_ptr->current_floor_ptr;
{
bool is_empty_or_dark = dd_ptr->empty_level;
is_empty_or_dark &= !one_in_(DARK_EMPTY) || (randint1(100) > floor_ptr->dun_level);
- is_empty_or_dark &= (d_ptr->flags1 & DF1_DARKNESS) == 0;
+ is_empty_or_dark &= d_ptr->flags.has_not(DF::DARKNESS);
if (!is_empty_or_dark)
return;
dd_ptr->cent_n = 0;
dungeon_type *d_ptr = &d_info[floor_ptr->dungeon_idx];
- if (ironman_empty_levels || ((d_ptr->flags1 & DF1_ARENA) && (empty_levels && one_in_(EMPTY_LEVEL)))) {
+ if (ironman_empty_levels || (d_ptr->flags.has(DF::ARENA) && (empty_levels && one_in_(EMPTY_LEVEL)))) {
dd_ptr->empty_level = TRUE;
msg_print_wizard(player_ptr, CHEAT_DUNGEON, _("アリーナレベルを生成。", "Arena level."));
}
#include "object-enchant/item-apply-magic.h"
#include "object-enchant/object-ego.h"
#include "object-enchant/trg-types.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
OBJECT_IDX o_idx = o_pop(floor_ptr);
object_type *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
- object_copy(o_ptr, j_ptr);
+ o_ptr->copy_from(j_ptr);
o_ptr->iy = y;
o_ptr->ix = x;
o_ptr->held_m_idx = 0;
KIND_OBJECT_IDX k_idx = lookup_kind(TV_SCROLL, SV_SCROLL_ACQUIREMENT);
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, k_idx);
+ q_ptr->prep(player_ptr, k_idx);
drop_here(player_ptr->current_floor_ptr, q_ptr, *qtwg_ptr->y, *qtwg_ptr->x);
}
} else if (object_index) {
object_type tmp_object;
object_type *o_ptr = &tmp_object;
- object_prep(player_ptr, o_ptr, object_index);
+ o_ptr->prep(player_ptr, object_index);
if (o_ptr->tval == TV_GOLD) {
coin_type = object_index - OBJ_GOLD_LIST;
make_gold(player_ptr, o_ptr);
*/
void glow_deep_lava_and_bldg(player_type *subject_ptr)
{
- if (d_info[subject_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[subject_ptr->dungeon_idx].flags.has(DF::DARKNESS))
return;
floor_type *floor_ptr = subject_ptr->current_floor_ptr;
{
floor_type *floor_ptr = player_ptr->current_floor_ptr;
DUNGEON_IDX d_idx = floor_ptr->dungeon_idx;
- if ((always_small_levels || ironman_small_levels || (one_in_(SMALL_LEVEL) && small_levels) || (d_info[d_idx].flags1 & DF1_BEGINNER)
- || (d_info[d_idx].flags1 & DF1_SMALLEST))
- && !(d_info[d_idx].flags1 & DF1_BIG)) {
+ if ((always_small_levels || ironman_small_levels || (one_in_(SMALL_LEVEL) && small_levels) || d_info[d_idx].flags.has(DF::BEGINNER)
+ || d_info[d_idx].flags.has(DF::SMALLEST))
+ && d_info[d_idx].flags.has_not(DF::BIG)) {
int level_height;
int level_width;
- if (d_info[d_idx].flags1 & DF1_SMALLEST) {
+ if (d_info[d_idx].flags.has(DF::SMALLEST)) {
level_height = 1;
level_width = 1;
- } else if (d_info[d_idx].flags1 & DF1_BEGINNER) {
+ } else if (d_info[d_idx].flags.has(DF::BEGINNER)) {
level_height = 2;
level_width = 2;
} else {
#include "object-enchant/special-object-flags.h"
#include "object-hook/hook-checker.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
if (!k_idx)
return FALSE;
- object_prep(owner_ptr, j_ptr, k_idx);
+ j_ptr->prep(owner_ptr, k_idx);
}
apply_magic_to_object(owner_ptr, j_ptr, floor_ptr->object_level, mode);
i = coin_type;
if (i >= MAX_GOLD)
i = MAX_GOLD - 1;
- object_prep(player_ptr, j_ptr, OBJ_GOLD_LIST + i);
+ j_ptr->prep(player_ptr, OBJ_GOLD_LIST + i);
s32b base = k_info[OBJ_GOLD_LIST + i].cost;
j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
for (const auto this_o_idx : g_ptr->o_idx_list) {
object_type *o_ptr;
o_ptr = &floor_ptr->o_list[this_o_idx];
- object_wipe(o_ptr);
+ o_ptr->wipe();
floor_ptr->o_cnt--;
}
lite_spot(player_ptr, y, x);
}
- object_wipe(j_ptr);
+ j_ptr->wipe();
floor_ptr->o_cnt--;
set_bits(player_ptr->window_flags, PW_FLOOR_ITEM_LIST);
}
if (!done) {
- object_copy(&floor_ptr->o_list[o_idx], j_ptr);
+ (&floor_ptr->o_list[o_idx])->copy_from(j_ptr);
j_ptr = &floor_ptr->o_list[o_idx];
j_ptr->iy = by;
j_ptr->ix = bx;
/* Lava terrain glows */
if (has_flag(f_info[feat1].flags, FF_LAVA)) {
- if (!(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
g_ptr->info |= CAVE_GLOW;
}
dungeon_ptr = &d_info[floor_ptr->dungeon_idx];
/* Choose water mainly */
- if ((randint1(MAX_DEPTH * 2) - 1 > floor_ptr->dun_level) && (dungeon_ptr->flags1 & DF1_WATER_RIVER)) {
+ if ((randint1(MAX_DEPTH * 2) - 1 > floor_ptr->dun_level) && dungeon_ptr->flags.has(DF::WATER_RIVER)) {
feat1 = feat_deep_water;
feat2 = feat_shallow_water;
} else /* others */
FEAT_IDX select_shallow_feat[10];
int select_id_max = 0, selected;
- if (dungeon_ptr->flags1 & DF1_LAVA_RIVER) {
+ if (dungeon_ptr->flags.has(DF::LAVA_RIVER)) {
select_deep_feat[select_id_max] = feat_deep_lava;
select_shallow_feat[select_id_max] = feat_shallow_lava;
select_id_max++;
}
- if (dungeon_ptr->flags1 & DF1_POISONOUS_RIVER) {
+ if (dungeon_ptr->flags.has(DF::POISONOUS_RIVER)) {
select_deep_feat[select_id_max] = feat_deep_poisonous_puddle;
select_shallow_feat[select_id_max] = feat_shallow_poisonous_puddle;
select_id_max++;
}
- if (dungeon_ptr->flags1 & DF1_ACID_RIVER) {
+ if (dungeon_ptr->flags.has(DF::ACID_RIVER)) {
select_deep_feat[select_id_max] = feat_deep_acid_puddle;
select_shallow_feat[select_id_max] = feat_shallow_acid_puddle;
select_id_max++;
g_ptr->mimic = 0;
/* Light area since is open above */
- if (!(d_info[player_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (d_info[player_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
floor_ptr->grid_array[j][i].info |= (CAVE_GLOW | CAVE_ROOM);
}
}
#include "grid/grid.h"
#include "object-hook/hook-checker.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "perception/object-perception.h"
#include "system/artifact-type-definition.h"
#include "system/floor-type-definition.h"
auto &list = get_o_idx_list_contains(floor_ptr, i);
list.clear();
- object_wipe(o_ptr);
+ o_ptr->wipe();
}
floor_ptr->o_max = 1;
bool is_winner = wilderness[y][x].entrance > 0;
is_winner &= (wilderness[y][x].town == 0);
- bool is_wild_winner = (d_info[wilderness[y][x].entrance].flags1 & DF1_WINNER) == 0;
+ bool is_wild_winner = d_info[wilderness[y][x].entrance].flags.has_not(DF::WINNER);
is_winner &= ((current_world_ptr->total_winner != 0) || is_wild_winner);
if (!is_winner)
return;
continue;
}
- if (wilderness[j][i].entrance && (current_world_ptr->total_winner || !(d_info[wilderness[j][i].entrance].flags1 & DF1_WINNER))) {
+ if (wilderness[j][i].entrance && (current_world_ptr->total_winner || d_info[wilderness[j][i].entrance].flags.has_not(DF::WINNER))) {
floor_ptr->grid_array[j][i].feat = feat_entrance;
floor_ptr->grid_array[j][i].special = (byte)wilderness[j][i].entrance;
floor_ptr->grid_array[j][i].info |= (CAVE_GLOW | CAVE_MARK);
void place_secret_door(player_type *player_ptr, POSITION y, POSITION x, int type)
{
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS) {
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_DOORS)) {
place_bold(player_ptr, y, x, GB_FLOOR);
return;
}
if (type == DOOR_DEFAULT) {
- type = ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 16 : 256))
+ type = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 16 : 256))
? DOOR_CURTAIN
- : ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+ : (d_info[floor_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
}
place_closed_door(player_ptr, y, x, type);
void place_locked_door(player_type *player_ptr, POSITION y, POSITION x)
{
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS) {
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_DOORS)) {
place_bold(player_ptr, y, x, GB_FLOOR);
return;
}
- set_cave_feat(floor_ptr, y, x, feat_locked_door_random((d_info[player_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR));
+ set_cave_feat(floor_ptr, y, x, feat_locked_door_random(d_info[player_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR));
floor_ptr->grid_array[y][x].info &= ~(CAVE_FLOOR);
delete_monster(player_ptr, y, x);
}
grid_type *g_ptr = &floor_ptr->grid_array[y][x];
g_ptr->mimic = 0;
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS) {
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_DOORS)) {
place_bold(player_ptr, y, x, GB_FLOOR);
return;
}
- int type = ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 16 : 256))
+ int type = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 16 : 256))
? DOOR_CURTAIN
- : ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+ : (d_info[floor_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
int tmp = randint0(1000);
FEAT_IDX feat = feat_none;
void place_closed_door(player_type *player_ptr, POSITION y, POSITION x, int type)
{
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS) {
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_DOORS)) {
place_bold(player_ptr, y, x, GB_FLOOR);
return;
}
#include "grid/feature-generator.h"
+#include "dungeon/dungeon-flag-mask.h"
#include "dungeon/dungeon-flag-types.h"
#include "dungeon/dungeon.h"
#include "dungeon/quest.h"
void gen_caverns_and_lakes(player_type *owner_ptr, dungeon_type *dungeon_ptr, dun_data_type *dd_ptr)
{
floor_type *floor_ptr = owner_ptr->current_floor_ptr;
- if ((floor_ptr->dun_level > 30) && one_in_(DUN_DEST * 2) && small_levels && (dungeon_ptr->flags1 & DF1_DESTROY)) {
+ if ((floor_ptr->dun_level > 30) && one_in_(DUN_DEST * 2) && small_levels && dungeon_ptr->flags.has(DF::DESTROY)) {
dd_ptr->destroyed = TRUE;
build_lake(owner_ptr, one_in_(2) ? LAKE_T_CAVE : LAKE_T_EARTH_VAULT);
}
- if (one_in_(LAKE_LEVEL) && !dd_ptr->empty_level && !dd_ptr->destroyed && (dungeon_ptr->flags1 & DF1_LAKE_MASK)) {
+ if (one_in_(LAKE_LEVEL) && !dd_ptr->empty_level && !dd_ptr->destroyed && dungeon_ptr->flags.has_any_of(DF_LAKE_MASK)) {
int count = 0;
- if (dungeon_ptr->flags1 & DF1_LAKE_WATER)
+ if (dungeon_ptr->flags.has(DF::LAKE_WATER))
count += 3;
- if (dungeon_ptr->flags1 & DF1_LAKE_LAVA)
+ if (dungeon_ptr->flags.has(DF::LAKE_LAVA))
count += 3;
- if (dungeon_ptr->flags1 & DF1_LAKE_RUBBLE)
+ if (dungeon_ptr->flags.has(DF::LAKE_RUBBLE))
count += 3;
- if (dungeon_ptr->flags1 & DF1_LAKE_TREE)
+ if (dungeon_ptr->flags.has(DF::LAKE_TREE))
count += 3;
- if (dungeon_ptr->flags1 & DF1_LAKE_LAVA) {
+ if (dungeon_ptr->flags.has(DF::LAKE_LAVA)) {
if ((floor_ptr->dun_level > 80) && (randint0(count) < 2))
dd_ptr->laketype = LAKE_T_LAVA;
count--;
}
- if ((dungeon_ptr->flags1 & DF1_LAKE_WATER) && !dd_ptr->laketype) {
+ if (dungeon_ptr->flags.has(DF::LAKE_WATER) && !dd_ptr->laketype) {
if ((floor_ptr->dun_level > 50) && randint0(count) < 2)
dd_ptr->laketype = LAKE_T_WATER;
count--;
}
- if ((dungeon_ptr->flags1 & DF1_LAKE_RUBBLE) && !dd_ptr->laketype) {
+ if (dungeon_ptr->flags.has(DF::LAKE_RUBBLE) && !dd_ptr->laketype) {
if ((floor_ptr->dun_level > 35) && (randint0(count) < 2))
dd_ptr->laketype = LAKE_T_CAVE;
count--;
}
- if ((floor_ptr->dun_level > 5) && (dungeon_ptr->flags1 & DF1_LAKE_TREE) && !dd_ptr->laketype)
+ if ((floor_ptr->dun_level > 5) && dungeon_ptr->flags.has(DF::LAKE_TREE) && !dd_ptr->laketype)
dd_ptr->laketype = LAKE_T_AIR_VAULT;
if (dd_ptr->laketype) {
}
}
- if ((floor_ptr->dun_level > DUN_CAVERN) && !dd_ptr->empty_level && (dungeon_ptr->flags1 & DF1_CAVERN) && !dd_ptr->laketype && !dd_ptr->destroyed
+ if ((floor_ptr->dun_level > DUN_CAVERN) && !dd_ptr->empty_level && dungeon_ptr->flags.has(DF::CAVERN) && !dd_ptr->laketype && !dd_ptr->destroyed
&& (randint1(1000) < floor_ptr->dun_level)) {
dd_ptr->cavern = TRUE;
msg_print_wizard(owner_ptr, CHEAT_DUNGEON, _("洞窟を生成。", "Cavern on level."));
bool has_river_flag(dungeon_type *dungeon_ptr)
{
- return (dungeon_ptr->flags1 & (DF1_WATER_RIVER | DF1_LAVA_RIVER | DF1_ACID_RIVER | DF1_POISONOUS_RIVER)) != 0;
+ return dungeon_ptr->flags.has_any_of(DF_RIVER_MASK);
}
/*!
bool can_place_door = randint0(100) < dt_ptr->dun_tun_jct;
can_place_door &= possible_doorway(floor_ptr, y, x);
- can_place_door &= (d_info[player_ptr->dungeon_idx].flags1 & DF1_NO_DOORS) == 0;
+ can_place_door &= d_info[player_ptr->dungeon_idx].flags.has_not(DF::NO_DOORS);
if (can_place_door)
place_random_door(player_ptr, y, x, FALSE);
}
if (!current_world_ptr->character_dungeon) {
g_ptr->mimic = 0;
g_ptr->feat = feat;
- if (has_flag(f_ptr->flags, FF_GLOW) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS)) {
+ if (has_flag(f_ptr->flags, FF_GLOW) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS)) {
for (DIRECTION i = 0; i < 9; i++) {
POSITION yy = y + ddy_ddd[i];
POSITION xx = x + ddx_ddd[i];
g_ptr->mimic = 0;
g_ptr->feat = feat;
g_ptr->info &= ~(CAVE_OBJECT);
- if (old_mirror && (d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS)) {
+ if (old_mirror && d_info[floor_ptr->dungeon_idx].flags.has(DF::DARKNESS)) {
g_ptr->info &= ~(CAVE_GLOW);
if (!view_torch_grids)
g_ptr->info &= ~(CAVE_MARK);
if (old_los ^ has_flag(f_ptr->flags, FF_LOS))
player_ptr->update |= PU_VIEW | PU_LITE | PU_MON_LITE | PU_MONSTERS;
- if (!has_flag(f_ptr->flags, FF_GLOW) || (d_info[player_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (!has_flag(f_ptr->flags, FF_GLOW) || d_info[player_ptr->dungeon_idx].flags.has(DF::DARKNESS))
return;
for (DIRECTION i = 0; i < 9; i++) {
g_ptr->info &= ~(CAVE_OBJECT);
g_ptr->mimic = 0;
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS)) {
g_ptr->info &= ~(CAVE_GLOW);
if (!view_torch_grids)
g_ptr->info &= ~(CAVE_MARK);
#include "floor/floor-object.h"
#include "grid/grid.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "system/artifact-type-definition.h"
#include "system/floor-type-definition.h"
#include "system/object-type-definition.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
if (!make_gold(player_ptr, q_ptr))
return;
object_type *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
o_ptr->iy = y;
o_ptr->ix = x;
return;
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
if (!make_object(owner_ptr, q_ptr, mode))
return;
object_type *o_ptr;
o_ptr = &floor_ptr->o_list[o_idx];
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
o_ptr->iy = y;
o_ptr->ix = x;
#include "info-reader/dungeon-info-tokens-table.h"
+#include "dungeon/dungeon-flag-types.h"
/*!
* ダンジョン特性トークンの定義 /
* Dungeon flags
*/
-concptr d_info_flags1[NUM_D_FLAGS] = {
- "WINNER",
- "MAZE",
- "SMALLEST",
- "BEGINNER",
- "BIG",
- "NO_DOORS",
- "WATER_RIVER",
- "LAVA_RIVER",
- "CURTAIN",
- "GLASS_DOOR",
- "CAVE",
- "CAVERN",
- "ARCADE",
- "LAKE_ACID",
- "LAKE_POISONOUS",
- "XXX",
- "FORGET",
- "LAKE_WATER",
- "LAKE_LAVA",
- "LAKE_RUBBLE",
- "LAKE_TREE",
- "NO_VAULT",
- "ARENA",
- "DESTROY",
- "GLASS_ROOM",
- "NO_CAVE",
- "NO_MAGIC",
- "NO_MELEE",
- "CHAMELEON",
- "DARKNESS",
- "ACID_RIVER",
- "POISONOUS_RIVER"
+const std::unordered_map<std::string_view, DF> d_info_flags = {
+ { "WINNER", DF::WINNER },
+ { "MAZE", DF::MAZE },
+ { "SMALLEST", DF::SMALLEST },
+ { "BEGINNER", DF::BEGINNER },
+ { "BIG", DF::BIG },
+ { "NO_DOORS", DF::NO_DOORS },
+ { "WATER_RIVER", DF::WATER_RIVER },
+ { "LAVA_RIVER", DF::LAVA_RIVER },
+ { "CURTAIN", DF::CURTAIN },
+ { "GLASS_DOOR", DF::GLASS_DOOR },
+ { "CAVE", DF::CAVE },
+ { "CAVERN", DF::CAVERN },
+ { "ARCADE", DF::ARCADE },
+ { "LAKE_ACID", DF::LAKE_ACID },
+ { "LAKE_POISONOUS", DF::LAKE_POISONOUS },
+ { "NO_ROOM", DF::NO_ROOM },
+ { "FORGET", DF::FORGET },
+ { "LAKE_WATER", DF::LAKE_WATER },
+ { "LAKE_LAVA", DF::LAKE_LAVA },
+ { "LAKE_RUBBLE", DF::LAKE_RUBBLE },
+ { "LAKE_TREE", DF::LAKE_TREE },
+ { "NO_VAULT", DF::NO_VAULT },
+ { "ARENA", DF::ARENA },
+ { "DESTROY", DF::DESTROY },
+ { "GLASS_ROOM", DF::GLASS_ROOM },
+ { "NO_CAVE", DF::NO_CAVE },
+ { "NO_MAGIC", DF::NO_MAGIC },
+ { "NO_MELEE", DF::NO_MELEE },
+ { "CHAMELEON", DF::CHAMELEON },
+ { "DARKNESS", DF::DARKNESS },
+ { "ACID_RIVER", DF::ACID_RIVER },
+ { "POISONOUS_RIVER", DF::POISONOUS_RIVER },
};
-
#include "system/angband.h"
-#define NUM_D_FLAGS 32
+#include <string_view>
+#include <unordered_map>
-extern concptr d_info_flags1[NUM_D_FLAGS];
+enum class DF;
+
+extern const std::unordered_map<std::string_view, DF> d_info_flags;
*/
static errr grab_one_dungeon_flag(dungeon_type *d_ptr, concptr what)
{
- if (grab_one_flag(&d_ptr->flags1, d_info_flags1, what) == 0)
+ if (EnumClassFlagGroup<DF>::grab_one_flag(d_ptr->flags, d_info_flags, what))
return 0;
msg_format(_("未知のダンジョン・フラグ '%s'。", "Unknown dungeon type flag '%s'."), what);
#include "floor/floor-object.h"
#include "inventory/inventory-slot-types.h"
#include "object-hook/hook-weapon.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-mark-types.h"
#include "object/object-stack.h"
if (item >= INVEN_MAIN_HAND) {
owner_ptr->equip_cnt--;
- object_wipe(&owner_ptr->inventory_list[item]);
+ (&owner_ptr->inventory_list[item])->wipe();
owner_ptr->update |= PU_BONUS;
owner_ptr->update |= PU_TORCH;
owner_ptr->update |= PU_MANA;
owner_ptr->inventory_list[i] = owner_ptr->inventory_list[i + 1];
}
- object_wipe(&owner_ptr->inventory_list[i]);
+ (&owner_ptr->inventory_list[i])->wipe();
owner_ptr->window_flags |= PW_INVEN;
owner_ptr->window_flags |= PW_SPELL;
}
}
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
distribute_charges(o_ptr, q_ptr, amt);
q_ptr->number = amt;
owner_ptr->inventory_list[k] = owner_ptr->inventory_list[k + 1];
}
- object_wipe(&owner_ptr->inventory_list[k]);
+ (&owner_ptr->inventory_list[k])->wipe();
} else {
int old_num = o_ptr->number;
int remain = j_ptr->number + o_ptr->number - max_num;
flag = TRUE;
q_ptr = &forge;
- object_copy(q_ptr, &owner_ptr->inventory_list[i]);
+ q_ptr->copy_from(&owner_ptr->inventory_list[i]);
for (k = i; k > j; k--) {
- object_copy(&owner_ptr->inventory_list[k], &owner_ptr->inventory_list[k - 1]);
+ (&owner_ptr->inventory_list[k])->copy_from(&owner_ptr->inventory_list[k - 1]);
}
- object_copy(&owner_ptr->inventory_list[j], q_ptr);
+ (&owner_ptr->inventory_list[j])->copy_from(q_ptr);
owner_ptr->window_flags |= (PW_INVEN);
}
i = j;
for (k = n; k >= i; k--) {
- object_copy(&owner_ptr->inventory_list[k + 1], &owner_ptr->inventory_list[k]);
+ (&owner_ptr->inventory_list[k + 1])->copy_from(&owner_ptr->inventory_list[k]);
}
- object_wipe(&owner_ptr->inventory_list[i]);
+ (&owner_ptr->inventory_list[i])->wipe();
}
- object_copy(&owner_ptr->inventory_list[i], o_ptr);
+ (&owner_ptr->inventory_list[i])->copy_from(o_ptr);
j_ptr = &owner_ptr->inventory_list[i];
j_ptr->held_m_idx = 0;
j_ptr->iy = j_ptr->ix = 0;
if (amt > o_ptr->number)
amt = o_ptr->number;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = amt;
describe_flavor(owner_ptr, o_name, q_ptr, 0);
if (((item == INVEN_MAIN_HAND) || (item == INVEN_SUB_HAND)) && object_is_melee_weapon(o_ptr)) {
break;
}
- if (floor_ptr->dun_level && (d_info[creature_ptr->dungeon_idx].flags1 & DF1_NO_MAGIC) && (creature_ptr->pclass != CLASS_BERSERKER)
+ if (floor_ptr->dun_level && d_info[creature_ptr->dungeon_idx].flags.has(DF::NO_MAGIC) && (creature_ptr->pclass != CLASS_BERSERKER)
&& (creature_ptr->pclass != CLASS_SMITH)) {
msg_print(_("ダンジョンが魔法を吸収した！", "The dungeon absorbs all attempted magic!"));
msg_print(NULL);
#include "knowledge/object-group-table.h"
#include "object-enchant/special-object-flags.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
#include "perception/identification.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_prep(player_ptr, q_ptr, z);
+ q_ptr->prep(player_ptr, z);
q_ptr->name1 = who[k];
q_ptr->ident |= IDENT_STORE;
describe_flavor(player_ptr, base_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
object_type *o_ptr;
object_type object_type_body;
o_ptr = &object_type_body;
- object_wipe(o_ptr);
- object_prep(creature_ptr, o_ptr, k_idx);
+ o_ptr->wipe();
+ o_ptr->prep(creature_ptr, k_idx);
o_ptr->ident |= IDENT_KNOWN;
handle_stuff(creature_ptr);
#include "locale/english.h"
#include "monster-race/monster-race.h"
#include "object-enchant/special-object-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "system/artifact-type-definition.h"
#include "system/floor-type-definition.h"
object_type forge;
object_type *q_ptr = &forge;
KIND_OBJECT_IDX k_idx = lookup_kind(a_ptr->tval, a_ptr->sval);
- object_prep(creature_ptr, q_ptr, k_idx);
+ q_ptr->prep(creature_ptr, k_idx);
q_ptr->name1 = quest[i].k_idx;
q_ptr->ident = IDENT_STORE;
describe_flavor(creature_ptr, name, q_ptr, OD_NAME_ONLY);
#include "inventory/inventory-slot-types.h"
#include "load/item-loader.h"
#include "load/load-util.h"
-#include "object/object-generator.h"
#include "object/object-mark-types.h"
#include "system/object-type-definition.h"
#include "system/player-type-definition.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
rd_item(player_ptr, q_ptr);
if (!q_ptr->k_idx)
if (n >= INVEN_MAIN_HAND) {
q_ptr->marked |= OM_TOUCHED;
- object_copy(&player_ptr->inventory_list[n], q_ptr);
+ (&player_ptr->inventory_list[n])->copy_from(q_ptr);
player_ptr->equip_cnt++;
continue;
}
n = slot++;
q_ptr->marked |= OM_TOUCHED;
- object_copy(&player_ptr->inventory_list[n], q_ptr);
+ (&player_ptr->inventory_list[n])->copy_from(q_ptr);
player_ptr->inven_cnt++;
}
#include "load/store-loader.h"
-#include "object/object-generator.h"
#include "floor/floor-town.h"
#include "load/angband-version-comparer.h"
#include "load/item-loader.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
rd_item(player_ptr, q_ptr);
home_carry_load(player_ptr, store_ptr, q_ptr);
} else {
int k = store_ptr->stock_num++;
- object_copy(&store_ptr->stock[k], q_ptr);
+ (&store_ptr->stock[k])->copy_from(q_ptr);
}
}
#include "monster/monster-util.h"
#include "object-enchant/apply-magic.h"
#include "object-enchant/item-apply-magic.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind-hook.h"
#include "perception/object-perception.h"
msg_format(_("これで合計 %d ポイント獲得しました。", "You earned %d point%s total."), num, (num > 1 ? "s" : ""));
- object_prep(player_ptr, &forge, lookup_kind(prize_list[num - 1].tval, prize_list[num - 1].sval));
+ (&forge)->prep(player_ptr, lookup_kind(prize_list[num - 1].tval, prize_list[num - 1].sval));
apply_magic_to_object(player_ptr, &forge, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART);
object_aware(player_ptr, &forge);
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
#include "object/object-flags.h"
-#include "object/object-generator.h"
#include "realm/realm-hex-numbers.h"
#include "spell-realm/spells-hex.h"
#include "sv-definition/sv-weapon-types.h"
screen_save();
clear_bldg(0, 22);
i_ptr = &customer_ptr->inventory_list[INVEN_MAIN_HAND];
- object_copy(&orig_weapon, i_ptr);
+ (&orig_weapon)->copy_from(i_ptr);
item_tester_hook = item_tester_hook_orthodox_melee_weapons;
concptr q = _("第一の武器は？", "What is your first weapon? ");
for (int i = 0; i < n; i++) {
int col = (wid * i + mgn);
if (o_ptr[i] != i_ptr)
- object_copy(i_ptr, o_ptr[i]);
+ i_ptr->copy_from(o_ptr[i]);
customer_ptr->update |= PU_BONUS;
handle_stuff(customer_ptr);
list_weapon(customer_ptr, o_ptr[i], row, col);
compare_weapon_aux(customer_ptr, o_ptr[i], col, row + 8);
- object_copy(i_ptr, &orig_weapon);
+ i_ptr->copy_from(&orig_weapon);
}
customer_ptr->update |= PU_BONUS;
if ((ms_ptr->r_ptr->flags2 & RF2_STUPID) != 0)
return;
- if (d_info[target_ptr->dungeon_idx].flags1 & DF1_DARKNESS) {
+ if (d_info[target_ptr->dungeon_idx].flags.has(DF::DARKNESS)) {
ms_ptr->ability_flags.reset(RF_ABILITY::DARKNESS);
return;
}
ms_ptr->see_m = is_seen(target_ptr, ms_ptr->m_ptr);
ms_ptr->maneable = player_has_los_bold(target_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx);
ms_ptr->pet = is_pet(ms_ptr->m_ptr);
- ms_ptr->in_no_magic_dungeon = (d_info[target_ptr->dungeon_idx].flags1 & DF1_NO_MAGIC) && floor_ptr->dun_level
+ ms_ptr->in_no_magic_dungeon = d_info[target_ptr->dungeon_idx].flags.has(DF::NO_MAGIC) && floor_ptr->dun_level
&& (!floor_ptr->inside_quest || is_fixed_quest_idx(floor_ptr->inside_quest));
return ms_ptr;
}
if (r_ptr->flags1 & RF1_NEVER_BLOW)
return FALSE;
- if (d_info[subject_ptr->dungeon_idx].flags1 & DF1_NO_MELEE)
+ if (d_info[subject_ptr->dungeon_idx].flags.has(DF::NO_MELEE))
return FALSE;
return TRUE;
#include "object-hook/hook-bow.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "perception/object-perception.h"
#include "system/floor-type-definition.h"
object_type forge;
object_type *q_ptr = &forge;
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_SHOT, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_SHOT, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
q_ptr->number = (byte)rand_range(15, 30);
object_aware(creature_ptr, q_ptr);
object_known(q_ptr);
object_type forge;
q_ptr = &forge;
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_ARROW, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_ARROW, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
q_ptr->number = (byte)rand_range(5, 10);
object_aware(creature_ptr, q_ptr);
object_known(q_ptr);
object_type forge;
q_ptr = &forge;
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_BOLT, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_BOLT, (OBJECT_SUBTYPE_VALUE)m_bonus(1, creature_ptr->lev) + 1));
q_ptr->number = (byte)rand_range(4, 8);
object_aware(creature_ptr, q_ptr);
object_known(q_ptr);
#include "floor/floor-object.h"
#include "object-enchant/object-boost.h"
#include "object-enchant/object-ego.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "sv-definition/sv-weapon-types.h"
#include "system/floor-type-definition.h"
dummy2 = SV_BLADE_OF_CHAOS;
}
- object_prep(creature_ptr, q_ptr, lookup_kind(dummy, dummy2));
+ q_ptr->prep(creature_ptr, lookup_kind(dummy, dummy2));
q_ptr->to_h = 3 + randint1(creature_ptr->current_floor_ptr->dun_level) % 10;
q_ptr->to_d = 3 + randint1(creature_ptr->current_floor_ptr->dun_level) % 10;
one_resistance(q_ptr);
#include "mind/mind-hobbit.h"
#include "floor/floor-object.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "sv-definition/sv-food-types.h"
#include "system/object-type-definition.h"
{
object_type forge;
object_type *q_ptr = &forge;
- object_prep(creature_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
+ q_ptr->prep(creature_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
(void)drop_near(creature_ptr, q_ptr, -1, creature_ptr->y, creature_ptr->x);
msg_print(_("食事を料理して作った。", "You cook some food."));
return TRUE;
#include "object-hook/hook-magic.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "player/player-realm.h"
#include "system/object-type-definition.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = 1;
o_ptr->pval++;
#include "monster/monster-status.h"
#include "monster/monster-update.h"
#include "object-enchant/trc-types.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "player-attack/player-attack-util.h"
#include "player-info/equipment-info.h"
POSITION x = caster_ptr->x;
teleport_player(caster_ptr, 10 + randint1(90), TELEPORT_SPONTANEOUS);
- object_wipe(q_ptr);
+ q_ptr->wipe();
const int SV_WOODEN_STATUE = 0;
- object_prep(caster_ptr, q_ptr, lookup_kind(TV_STATUE, SV_WOODEN_STATUE));
+ q_ptr->prep(caster_ptr, lookup_kind(TV_STATUE, SV_WOODEN_STATUE));
q_ptr->pval = MON_NINJA;
(void)drop_near(caster_ptr, q_ptr, -1, y, x);
if (r_ptr->flags1 & (RF1_NEVER_BLOW))
return FALSE;
- if (d_info[target_ptr->dungeon_idx].flags1 & DF1_NO_MELEE)
+ if (d_info[target_ptr->dungeon_idx].flags.has(DF::NO_MELEE))
return FALSE;
if (!is_hostile(monap_ptr->m_ptr))
turn_flags_ptr->do_move = FALSE;
}
- if (turn_flags_ptr->do_move && ((d_info[target_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) != 0) && !monster_confused_remaining(m_ptr)) {
+ if (turn_flags_ptr->do_move && d_info[target_ptr->dungeon_idx].flags.has(DF::NO_MELEE) && !monster_confused_remaining(m_ptr)) {
if (!(r_ptr->flags2 & RF2_STUPID))
turn_flags_ptr->do_move = FALSE;
else if (is_original_ap_and_seen(target_ptr, m_ptr))
return FALSE;
if (monst_attack_monst(target_ptr, m_idx, g_ptr->m_idx))
return TRUE;
- if ((d_info[target_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) == 0)
+ if (d_info[target_ptr->dungeon_idx].flags.has_not(DF::NO_MELEE))
return FALSE;
if (monster_confused_remaining(m_ptr))
return TRUE;
#include "monster-attack/monster-attack-util.h"
#include "monster/monster-status.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "object/object-mark-types.h"
object_type *j_ptr;
j_ptr = &target_ptr->current_floor_ptr->o_list[o_idx];
- object_copy(j_ptr, monap_ptr->o_ptr);
+ j_ptr->copy_from(monap_ptr->o_ptr);
j_ptr->number = 1;
if ((monap_ptr->o_ptr->tval == TV_ROD) || (monap_ptr->o_ptr->tval == TV_WAND)) {
j_ptr->pval = monap_ptr->o_ptr->pval / monap_ptr->o_ptr->number;
#include "monster/monster-list.h"
#include "object-enchant/apply-magic.h"
#include "object-enchant/item-apply-magic.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "pet/pet-fall-off.h"
#include "player/patron.h"
if (arena_info[player_ptr->arena_number].tval) {
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(arena_info[player_ptr->arena_number].tval, arena_info[player_ptr->arena_number].sval));
+ q_ptr->prep(player_ptr, lookup_kind(arena_info[player_ptr->arena_number].tval, arena_info[player_ptr->arena_number].sval));
apply_magic_to_object(player_ptr, q_ptr, floor_ptr->object_level, AM_NO_FIXED_ART);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
}
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_CORPSE, (corpse ? SV_CORPSE : SV_SKELETON)));
+ q_ptr->prep(player_ptr, lookup_kind(TV_CORPSE, (corpse ? SV_CORPSE : SV_SKELETON)));
apply_magic_to_object(player_ptr, q_ptr, floor_ptr->object_level, AM_NO_FIXED_ART);
q_ptr->pval = md_ptr->m_ptr->r_idx;
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
if (k_idx != 0) {
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, k_idx);
+ q_ptr->prep(player_ptr, k_idx);
apply_magic_to_object(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART | AM_GOOD);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
}
for (int i = 0; i < drop_numbers; i++) {
object_type forge;
object_type *q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
if (md_ptr->do_gold && (!md_ptr->do_item || (randint0(100) < 50))) {
if (!make_gold(player_ptr, q_ptr))
continue;
std::vector<Pos2D> points;
void (*add_mon_lite)(player_type *, std::vector<Pos2D> &, const POSITION, const POSITION, const monster_lite_type *);
- int dis_lim = ((d_info[subject_ptr->dungeon_idx].flags1 & DF1_DARKNESS) && !subject_ptr->see_nocto) ? (MAX_SIGHT / 2 + 1) : (MAX_SIGHT + 3);
+ int dis_lim = (d_info[subject_ptr->dungeon_idx].flags.has(DF::DARKNESS) && !subject_ptr->see_nocto) ? (MAX_SIGHT / 2 + 1) : (MAX_SIGHT + 3);
floor_type *floor_ptr = subject_ptr->current_floor_ptr;
for (int i = 0; i < floor_ptr->mon_lite_n; i++) {
grid_type *g_ptr;
&& (monster_csleep_remaining(m_ptr) || (!floor_ptr->dun_level && is_daytime()) || subject_ptr->phase_out))
continue;
- if (d_info[subject_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[subject_ptr->dungeon_idx].flags.has(DF::DARKNESS))
rad = 1;
add_mon_lite = update_monster_lite;
#include "object-enchant/tr-types.h"
#include "object-hook/hook-enchant.h"
#include "object/object-flags.h"
-#include "object/object-generator.h"
#include "object/object-mark-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
const OBJECT_IDX this_o_idx = *it++;
o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->held_m_idx = 0;
delete_object_idx(player_ptr, this_o_idx);
(void)drop_near(player_ptr, q_ptr, -1, m_ptr->fy, m_ptr->fx);
&& monster_has_hostile_align(player_ptr, NULL, 10, -10, r_ptr))
return FALSE;
- if ((r_ptr->flags7 & RF7_CHAMELEON) && (d_info[player_ptr->dungeon_idx].flags1 & DF1_CHAMELEON))
+ if ((r_ptr->flags7 & RF7_CHAMELEON) && d_info[player_ptr->dungeon_idx].flags.has(DF::CHAMELEON))
return TRUE;
if (summon_specific_who > 0) {
#include "object-enchant/apply-magic.h"
#include "object-enchant/item-apply-magic.h"
#include "object-hook/hook-checker.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "spell/spell-types.h"
#include "spell/summon-types.h"
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_SWORD, SV_BLADE_OF_CHAOS));
+ q_ptr->prep(player_ptr, lookup_kind(TV_SWORD, SV_BLADE_OF_CHAOS));
apply_magic_to_object(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART | md_ptr->mo_mode);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
}
object_type forge;
object_type *q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
if ((floor_ptr->dun_level > 49) && one_in_(5))
get_obj_num_hook = kind_is_good_book;
else
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_HAFTED, SV_GROND));
+ q_ptr->prep(player_ptr, lookup_kind(TV_HAFTED, SV_GROND));
q_ptr->name1 = ART_GROND;
apply_magic_to_object(player_ptr, q_ptr, -1, AM_GOOD | AM_GREAT);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_CROWN, SV_CHAOS));
+ q_ptr->prep(player_ptr, lookup_kind(TV_CROWN, SV_CHAOS));
q_ptr->name1 = ART_CHAOS;
apply_magic_to_object(player_ptr, q_ptr, -1, AM_GOOD | AM_GREAT);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_SWORD, randint1(2)));
+ q_ptr->prep(player_ptr, lookup_kind(TV_SWORD, randint1(2)));
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
}
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, lookup_kind(TV_CHEST, SV_CHEST_KANDUME));
+ q_ptr->prep(player_ptr, lookup_kind(TV_CHEST, SV_CHEST_KANDUME));
apply_magic_to_object(player_ptr, q_ptr, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
}
*/
static bool make_equipment(player_type *player_ptr, object_type *q_ptr, const BIT_FLAGS drop_mode, const bool is_object_hook_null)
{
- object_wipe(q_ptr);
+ q_ptr->wipe();
(void)make_object(player_ptr, q_ptr, drop_mode);
if (!is_object_hook_null) {
return true;
{
object_type forge;
object_type *q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
get_obj_num_hook = object_hook_pf;
(void)make_object(player_ptr, q_ptr, md_ptr->mo_mode);
(void)drop_near(player_ptr, q_ptr, -1, md_ptr->md_y, md_ptr->md_x);
#include "monster/monster-info.h"
#include "monster/monster-update.h"
#include "monster/monster-util.h"
-#include "object/object-generator.h"
#include "pet/pet-fall-off.h"
#include "player/player-status.h"
#include "system/alloc-entries.h"
/* starts from 0, reaches +25lv after 75days from a max_level dependent base date */
pls_max_level = MIN(NASTY_MON_PLUS_MAX, over_days / 3);
- if (d_info[player_ptr->dungeon_idx].flags1 & DF1_MAZE) {
+ if (d_info[player_ptr->dungeon_idx].flags.has(DF::MAZE)) {
pls_kakuritu = MIN(pls_kakuritu / 2, pls_kakuritu - 10);
if (pls_kakuritu < 2)
pls_kakuritu = 2;
}
/* Boost the max_level */
- if ((option & GMN_ARENA) || !(d_info[player_ptr->dungeon_idx].flags1 & DF1_BEGINNER)) {
+ if ((option & GMN_ARENA) || d_info[player_ptr->dungeon_idx].flags.has_not(DF::BEGINNER)) {
/* Nightmare mode allows more out-of depth monsters */
if (ironman_nightmare && !randint0(pls_kakuritu)) {
/* What a bizarre calculation */
else
level = floor_ptr->dun_level;
- if (d_info[player_ptr->dungeon_idx].flags1 & DF1_CHAMELEON)
+ if (d_info[player_ptr->dungeon_idx].flags.has(DF::CHAMELEON))
level += 2 + randint1(3);
r_idx = get_mon_num(player_ptr, 0, level, 0);
#endif
}
- if (!(d_info[target_ptr->dungeon_idx].flags1 & DF1_BEGINNER)) {
+ if (d_info[target_ptr->dungeon_idx].flags.has_not(DF::BEGINNER)) {
if (!target_ptr->current_floor_ptr->dun_level && !target_ptr->ambush_flag && !target_ptr->current_floor_ptr->inside_arena) {
chg_virtue(target_ptr, V_VALOUR, -1);
} else if (r_ptr->level > target_ptr->current_floor_ptr->dun_level) {
um_ptr->fx = um_ptr->m_ptr->fx;
um_ptr->flag = FALSE;
um_ptr->easy = FALSE;
- um_ptr->in_darkness = (d_info[subject_ptr->dungeon_idx].flags1 & DF1_DARKNESS) && !subject_ptr->see_nocto;
+ um_ptr->in_darkness = d_info[subject_ptr->dungeon_idx].flags.has(DF::DARKNESS) && !subject_ptr->see_nocto;
um_ptr->full = full;
return um_ptr;
}
dungeon_type *d_ptr = &d_info[d_idx];
monster_race *r_ptr = &r_info[r_idx];
- if (d_ptr->flags1 & DF1_CHAMELEON) {
+ if (d_ptr->flags.has(DF::CHAMELEON)) {
if (chameleon_change_m_idx)
return TRUE;
}
- if (d_ptr->flags1 & DF1_NO_MAGIC) {
+ if (d_ptr->flags.has(DF::NO_MAGIC)) {
if (r_idx != MON_CHAMELEON && r_ptr->freq_spell && r_ptr->ability_flags.has_none_of(RF_ABILITY_NOMAGIC_MASK))
return FALSE;
}
- if (d_ptr->flags1 & DF1_NO_MELEE) {
+ if (d_ptr->flags.has(DF::NO_MELEE)) {
if (r_idx == MON_CHAMELEON)
return TRUE;
if (r_ptr->ability_flags.has_none_of(RF_ABILITY_BOLT_MASK | RF_ABILITY_BEAM_MASK | RF_ABILITY_BALL_MASK)
}
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if (d_ptr->flags1 & DF1_BEGINNER) {
+ if (d_ptr->flags.has(DF::BEGINNER)) {
if (r_ptr->level > floor_ptr->dun_level)
return FALSE;
}
if (d_ptr->special_div >= 64)
return TRUE;
- if (summon_specific_type && !(d_ptr->flags1 & DF1_CHAMELEON))
+ if (summon_specific_type && d_ptr->flags.has_not(DF::CHAMELEON))
return TRUE;
byte a;
static void check_mspell_stupid(player_type *target_ptr, msa_type *msa_ptr)
{
floor_type *floor_ptr = target_ptr->current_floor_ptr;
- msa_ptr->in_no_magic_dungeon = (d_info[target_ptr->dungeon_idx].flags1 & DF1_NO_MAGIC) && floor_ptr->dun_level
+ msa_ptr->in_no_magic_dungeon = d_info[target_ptr->dungeon_idx].flags.has(DF::NO_MAGIC) && floor_ptr->dun_level
&& (!floor_ptr->inside_quest || is_fixed_quest_idx(floor_ptr->inside_quest));
if (!msa_ptr->in_no_magic_dungeon || ((msa_ptr->r_ptr->flags2 & RF2_STUPID) != 0))
return;
if ((msa_ptr->r_ptr->flags2 & RF2_STUPID) != 0)
return;
- if (d_info[target_ptr->dungeon_idx].flags1 & DF1_DARKNESS) {
+ if (d_info[target_ptr->dungeon_idx].flags.has(DF::DARKNESS)) {
msa_ptr->ability_flags.reset(RF_ABILITY::DARKNESS);
return;
}
#include "main/sound-of-music.h"
#include "mutation/mutation-investor-remover.h"
#include "object/object-broken.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "perception/object-perception.h"
o_ptr = ref_item(creature_ptr, item);
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = 1;
vary_item(creature_ptr, item, -1);
sound(SOUND_QUAFF);
+++ /dev/null
-#include "object/object-generator.h"
-#include "object-enchant/object-curse.h"
-#include "object-enchant/special-object-flags.h"
-#include "object-enchant/trc-types.h"
-#include "object-enchant/trg-types.h"
-#include "object/object-kind.h"
-#include "system/object-type-definition.h"
-#include "system/player-type-definition.h"
-
-/*!
- * @brief オブジェクトを初期化する
- * Wipe an object clean.
- * @param o_ptr 初期化したいオブジェクトの構造体参照ポインタ
- */
-void object_wipe(object_type *o_ptr) { (void)WIPE(o_ptr, object_type); }
-
-/*!
- * @brief オブジェクトを複製する
- * Wipe an object clean.
- * @param o_ptr 複製元のオブジェクトの構造体参照ポインタ
- * @param j_ptr 複製先のオブジェクトの構造体参照ポインタ
- */
-void object_copy(object_type *o_ptr, object_type *j_ptr) { (void)COPY(o_ptr, j_ptr, object_type); }
-
-/*!
- * @brief オブジェクト構造体にベースアイテムを作成する
- * Prepare an object based on an object kind.
- * @param o_ptr 代入したいオブジェクトの構造体参照ポインタ
- * @param k_idx 新たに作成したいベースアイテム情報のID
- */
-void object_prep(player_type *player_ptr, object_type *o_ptr, KIND_OBJECT_IDX k_idx)
-{
- object_kind *k_ptr = &k_info[k_idx];
- object_wipe(o_ptr);
- o_ptr->k_idx = k_idx;
- o_ptr->tval = k_ptr->tval;
- o_ptr->sval = k_ptr->sval;
- o_ptr->pval = k_ptr->pval;
- o_ptr->number = 1;
- o_ptr->weight = k_ptr->weight;
- o_ptr->to_h = k_ptr->to_h;
- o_ptr->to_d = k_ptr->to_d;
- o_ptr->to_a = k_ptr->to_a;
- o_ptr->ac = k_ptr->ac;
- o_ptr->dd = k_ptr->dd;
- o_ptr->ds = k_ptr->ds;
-
- if (k_ptr->act_idx > 0)
- o_ptr->xtra2 = (XTRA8)k_ptr->act_idx;
- if (k_info[o_ptr->k_idx].cost <= 0)
- o_ptr->ident |= (IDENT_BROKEN);
-
- if (k_ptr->gen_flags.has(TRG::CURSED))
- o_ptr->curse_flags |= (TRC_CURSED);
- if (k_ptr->gen_flags.has(TRG::HEAVY_CURSE))
- o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
- if (k_ptr->gen_flags.has(TRG::PERMA_CURSE))
- o_ptr->curse_flags |= (TRC_PERMA_CURSE);
- if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE0))
- o_ptr->curse_flags |= get_curse(player_ptr, 0, o_ptr);
- if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE1))
- o_ptr->curse_flags |= get_curse(player_ptr, 1, o_ptr);
- if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE2))
- o_ptr->curse_flags |= get_curse(player_ptr, 2, o_ptr);
-}
+++ /dev/null
-#pragma once
-
-#include "system/angband.h"
-
-typedef struct object_type object_type;
-typedef struct player_type player_type;
-void object_wipe(object_type *o_ptr);
-void object_copy(object_type *o_ptr, object_type *j_ptr);
-void object_prep(player_type *player_ptr, object_type *o_ptr, KIND_OBJECT_IDX k_idx);
if (projectable(creature_ptr, my, mx, yy, xx)) {
const auto flags = r_ptr->ability_flags;
- if (!(d_info[creature_ptr->dungeon_idx].flags1 & DF1_NO_MAGIC)) {
+ if (d_info[creature_ptr->dungeon_idx].flags.has_not(DF::NO_MAGIC)) {
if (flags.has(RF_ABILITY::BA_CHAO))
spell_damcalc_by_spellnum(creature_ptr, RF_ABILITY::BA_CHAO, GF_CHAOS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BA_MANA))
}
/* Monster melee attacks */
- if ((r_ptr->flags1 & RF1_NEVER_BLOW) || (d_info[creature_ptr->dungeon_idx].flags1 & DF1_NO_MELEE)) {
+ if ((r_ptr->flags1 & RF1_NEVER_BLOW) || d_info[creature_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
dam_max += dam_max0;
continue;
}
#include "object-enchant/special-object-flags.h"
#include "object-enchant/trg-types.h"
#include "object/item-tester-hooker.h" // 暫定、このファイルへ引っ越す.
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "system/object-type-definition.h"
#include "system/player-type-definition.h"
GAME_TEXT o_name[MAX_NLEN];
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = 1;
describe_flavor(owner_ptr, o_name, q_ptr, OD_NAME_ONLY);
if ((!creature_ptr->blind && !no_lite(creature_ptr)) || !is_trap(creature_ptr, g_ptr->feat))
g_ptr->info &= ~(CAVE_UNSAFE);
- if (floor_ptr->dun_level && (d_info[creature_ptr->dungeon_idx].flags1 & DF1_FORGET))
+ if (floor_ptr->dun_level && d_info[creature_ptr->dungeon_idx].flags.has(DF::FORGET))
wiz_dark(creature_ptr);
if (mpe_mode & MPE_HANDLE_STUFF)
#include "object-enchant/trg-types.h"
#include "object-hook/hook-enchant.h"
#include "object-hook/hook-weapon.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "object/object-value-calc.h"
#include "object/object-value.h"
if (!o_ptr->k_idx)
continue;
- object_wipe(q_ptr);
- object_copy(q_ptr, o_ptr);
+ q_ptr->wipe();
+ q_ptr->copy_from(o_ptr);
q_ptr->discount = 0;
q_ptr->curse_flags = 0L;
bool vampirism(player_type *caster_ptr)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
msg_print(_("なぜか攻撃することができない。", "Something prevents you from attacking."));
return FALSE;
}
msg_print(_("その方向にはモンスターはいません。", "There is no monster."));
return NULL;
}
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
return "";
}
if (caster_ptr->current_floor_ptr->grid_array[y][x].m_idx) {
return NULL;
}
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
return "";
}
y = caster_ptr->y + ddy[dir];
x = caster_ptr->x + ddx[dir];
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::NO_MELEE)) {
msg_print(_("なぜか攻撃することができない。", "Something prevents you from attacking."));
return "";
}
#include "hpmp/hp-mp-processor.h"
#include "monster-floor/monster-summon.h"
#include "monster-floor/place-monster-types.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "player-attack/player-attack.h"
#include "player-info/avatar.h"
msg_print(_("食料を生成した。", "A food ration is produced."));
/* Create the food ration */
- object_prep(caster_ptr, q_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
+ q_ptr->prep(caster_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
/* Drop the object from heaven */
(void)drop_near(caster_ptr, q_ptr, -1, caster_ptr->y, caster_ptr->x);
floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
if (cave_has_flag_bold(floor_ptr, y0 + y - yhsize, x0 + x - xhsize, FF_LAVA)) {
- if (!(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info |= CAVE_GLOW;
}
}
* かつ「常に通常でない部屋を生成する」フラグがONならば、
* GRATER_VAULTのみを生成対象とする。 / Ironman sees only Greater Vaults
*/
- if (ironman_rooms && !((d_info[floor_ptr->dungeon_idx].flags1 & (DF1_BEGINNER | DF1_CHAMELEON | DF1_SMALLEST)))) {
+ if (ironman_rooms && d_info[floor_ptr->dungeon_idx].flags.has_none_of( {DF::BEGINNER, DF::CHAMELEON, DF::SMALLEST })) {
for (int i = 0; i < ROOM_T_MAX; i++) {
if (i == ROOM_T_GREATER_VAULT)
prob_list[i] = 1;
else
prob_list[i] = 0;
}
- } else if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_VAULT) {
+ } else if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_VAULT)) {
/*! @details ダンジョンにNO_VAULTフラグがあるならば、LESSER_VAULT / GREATER_VAULT/ RANDOM_VAULTを除外 / Forbidden vaults */
prob_list[ROOM_T_LESSER_VAULT] = 0;
prob_list[ROOM_T_GREATER_VAULT] = 0;
}
/*! @details ダンジョンにBEGINNERフラグがあるならば、FIXED_ROOMを除外 / Forbidden vaults */
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_BEGINNER)
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::BEGINNER))
prob_list[ROOM_T_FIXED] = 0;
/*! @details ダンジョンにNO_CAVEフラグがある場合、FRACAVEの生成枠がNORMALに与えられる。CRIPT、OVALの生成枠がINNER_Fに与えられる。/ NO_CAVE dungeon */
- if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) {
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE)) {
move_prob_list(ROOM_T_NORMAL, ROOM_T_FRACAVE, prob_list);
move_prob_list(ROOM_T_INNER_FEAT, ROOM_T_CRYPT, prob_list);
move_prob_list(ROOM_T_INNER_FEAT, ROOM_T_OVAL, prob_list);
- } else if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_CAVE) {
+ } else if (d_info[floor_ptr->dungeon_idx].flags.has(DF::CAVE)) {
/*! @details ダンジョンにCAVEフラグがある場合、NORMALの生成枠がFRACAVEに与えられる。/ CAVE dungeon (Orc floor_ptr->grid_array etc.) */
move_prob_list(ROOM_T_FRACAVE, ROOM_T_NORMAL, prob_list);
} else if (dd_ptr->cavern || dd_ptr->empty_level) {
}
/*! @details ダンジョンに最初からGLASS_ROOMフラグがある場合、GLASS を生成から除外。/ Forbidden glass rooms */
- if (!(d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_ROOM))
+ if (d_info[floor_ptr->dungeon_idx].flags.has_not(DF::GLASS_ROOM))
prob_list[ROOM_T_GLASS] = 0;
/*! @details ARCADEは同フラグがダンジョンにないと生成されない。 / Forbidden glass rooms */
- if (!(d_info[floor_ptr->dungeon_idx].flags1 & DF1_ARCADE))
+ if (d_info[floor_ptr->dungeon_idx].flags.has_not(DF::ARCADE))
prob_list[ROOM_T_ARCADE] = 0;
ProbabilityTable<int> prob_table;
bool light = FALSE;
bool done = FALSE;
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if ((floor_ptr->dun_level <= randint1(50)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if ((floor_ptr->dun_level <= randint1(50)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
light = TRUE;
POSITION xsize = floor_ptr->width - 1;
light = done = FALSE;
room = TRUE;
- if ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS)) light = TRUE;
+ if ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS)) light = TRUE;
while (!done)
{
{
msg_print_wizard(player_ptr, CHEAT_DUNGEON, _("迷路ランダムVaultを生成しました。", "Maze Vault."));
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- bool light = ((floor_ptr->dun_level <= randint1(25)) && is_vault && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ bool light = ((floor_ptr->dun_level <= randint1(25)) && is_vault && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
POSITION dy = ysize / 2 - 1;
POSITION dx = xsize / 2 - 1;
POSITION y1 = y0 - dy;
grid_type *g_ptr;
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- bool curtain = (d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 48 : 512);
+ bool curtain = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN)) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 48 : 512);
/* Pick a room size */
y1 = randint1(4);
}
/* Choose lite or dark */
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* Get corner values */
y1 = yval - ysize / 2;
}
/* Hack -- Occasional divided room */
else if (one_in_(50)) {
- bool curtain2 = (d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 2 : 128);
+ bool curtain2 = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN)) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 2 : 128);
if (randint1(100) < 50) {
/* Horizontal wall */
return FALSE;
/* Choose lite or dark */
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* Determine extents of the first room */
y1a = yval - randint1(4);
return FALSE;
/* Choose lite or dark */
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* For now, always 3x3 */
wx = wy = 1;
/* Sometimes shut using secret doors */
if (one_in_(3)) {
int door_type
- = ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 16 : 256))
+ = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 16 : 256))
? DOOR_CURTAIN
- : ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+ : (d_info[floor_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
place_secret_door(player_ptr, yval, x1a - 1, door_type);
place_secret_door(player_ptr, yval, x2a + 1, door_type);
return FALSE;
/* Choose lite or dark */
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* Large room */
y1 = yval - 4;
/* Occasionally, some Inner rooms */
if (one_in_(3)) {
- int door_type = ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 16 : 256))
+ int door_type = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 16 : 256))
? DOOR_CURTAIN
- : ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+ : (d_info[floor_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
/* Long horizontal walls */
for (x = xval - 5; x <= xval + 5; x++) {
/* Four small rooms. */
case 5: {
- int door_type = ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_CURTAIN) && one_in_((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) ? 16 : 256))
+ int door_type = (d_info[floor_ptr->dungeon_idx].flags.has(DF::CURTAIN) && one_in_(d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) ? 16 : 256))
? DOOR_CURTAIN
- : ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+ : (d_info[floor_ptr->dungeon_idx].flags.has(DF::GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
/* Inner "cross" */
for (y = y1; y <= y2; y++) {
/* Occasional light */
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if ((randint1(floor_ptr->dun_level) <= 15) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if ((randint1(floor_ptr->dun_level) <= 15) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
light = TRUE;
rad = randint0(9);
/* Occasional light */
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- if ((randint1(floor_ptr->dun_level) <= 5) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if ((randint1(floor_ptr->dun_level) <= 5) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS))
light = TRUE;
rad = randint1(9);
return FALSE;
/* Choose lite or dark */
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* Get corner values */
y1 = yval - ysize / 2;
/* Choose lite or dark */
floor_type *floor_ptr = player_ptr->current_floor_ptr;
- light = ((floor_ptr->dun_level <= randint1(25)) && !(d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS));
+ light = ((floor_ptr->dun_level <= randint1(25)) && d_info[floor_ptr->dungeon_idx].flags.has_not(DF::DARKNESS));
/* Get corner values */
y1 = yval - ysize / 2;
/* Select type of vault */
do {
vtype = randint1(15);
- } while ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE) && ((vtype == 1) || (vtype == 3) || (vtype == 8) || (vtype == 9) || (vtype == 11)));
+ } while (d_info[floor_ptr->dungeon_idx].flags.has(DF::NO_CAVE) && ((vtype == 1) || (vtype == 3) || (vtype == 8) || (vtype == 9) || (vtype == 11)));
switch (vtype) {
/* Build an appropriate room */
if (!candidates)
return FALSE;
- if (!(d_info[player_ptr->current_floor_ptr->dungeon_idx].flags1 & DF1_NO_CAVE))
+ if (d_info[player_ptr->current_floor_ptr->dungeon_idx].flags.has_not(DF::NO_CAVE))
pick = randint1(candidates);
else
pick = candidates / 2 + 1;
wr_u32b(tmp32u);
for (int i = tmp32u - 1; i >= 0; i--)
- wr_string(message_str((s16b)i));
+ wr_string(message_str(i));
u16b tmp16u = max_r_idx;
wr_u16b(tmp16u);
#include "monster-floor/monster-summon.h"
#include "monster-floor/place-monster-types.h"
#include "object-enchant/item-apply-magic.h"
-#include "object/object-generator.h"
#include "perception/object-perception.h"
#include "player/player-class.h"
#include "player/player-damage.h"
for (; number > 0; --number)
{
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
/* Small chests often drop gold */
if (small && (randint0(100) < 25))
creature_ptr->cur_lite += rad;
}
- if (d_info[creature_ptr->dungeon_idx].flags1 & DF1_DARKNESS && creature_ptr->cur_lite > 1)
+ if (d_info[creature_ptr->dungeon_idx].flags.has(DF::DARKNESS) && creature_ptr->cur_lite > 1)
creature_ptr->cur_lite = 1;
if (creature_ptr->cur_lite <= 0 && creature_ptr->lite)
continue;
}
- if ((d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
continue;
grid_type *cc_ptr;
*/
static bool detect_feat_flag(player_type *caster_ptr, POSITION range, int flag, bool known)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
grid_type *g_ptr;
bool detect_objects_gold(player_type *caster_ptr, POSITION range)
{
POSITION range2 = range;
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range2 /= 3;
/* Scan objects */
bool detect_objects_normal(player_type *caster_ptr, POSITION range)
{
POSITION range2 = range;
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range2 /= 3;
bool detect = FALSE;
*/
bool detect_objects_magic(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
tval_type tv;
*/
bool detect_monsters_normal(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_invis(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_evil(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_nonliving(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_mind(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_string(player_type *caster_ptr, POSITION range, concptr Match)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
*/
bool detect_monsters_xxx(player_type *caster_ptr, POSITION range, u32b match_flag)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
bool flag = FALSE;
#include "object-hook/hook-weapon.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "player-info/avatar.h"
#include "racial/racial-android.h"
#include "system/object-type-definition.h"
byte marked = o_ptr->marked;
u16b inscription = o_ptr->inscription;
- object_prep(owner_ptr, o_ptr, o_ptr->k_idx);
+ o_ptr->prep(owner_ptr, o_ptr->k_idx);
o_ptr->iy = iy;
o_ptr->ix = ix;
f_ptr = &f_info[get_feat_mimic(g_ptr)];
/* Perma-lite the grid */
- if (!(d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS) && !ninja) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has_not(DF::DARKNESS) && !ninja) {
g_ptr->info |= (CAVE_GLOW);
}
*/
void map_area(player_type *caster_ptr, POSITION range)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS))
range /= 3;
/* Scan that area */
continue;
}
- if ((d_info[floor_ptr->dungeon_idx].flags1 & DF1_DARKNESS))
+ if (d_info[floor_ptr->dungeon_idx].flags.has(DF::DARKNESS))
continue;
DIRECTION i;
*/
bool lite_area(player_type *caster_ptr, HIT_POINT dam, POSITION rad)
{
- if (d_info[caster_ptr->dungeon_idx].flags1 & DF1_DARKNESS) {
+ if (d_info[caster_ptr->dungeon_idx].flags.has(DF::DARKNESS)) {
msg_print(_("ダンジョンが光を吸収した。", "The darkness of this dungeon absorbs your light."));
return FALSE;
}
#include "object-hook/hook-weapon.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
#include "perception/object-perception.h"
break;
}
i_ptr = &object_type_body;
- object_wipe(i_ptr);
+ i_ptr->wipe();
k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
/* Paranoia - reroll if nothing */
}
/* Make an object (if possible) */
- object_prep(creature_ptr, i_ptr, k_idx);
+ i_ptr->prep(creature_ptr, k_idx);
if (a_idx)
i_ptr->name1 = a_idx;
apply_magic_to_object(creature_ptr, i_ptr, 1, AM_NO_FIXED_ART);
/* Acquirement */
while (num--) {
i_ptr = &object_type_body;
- object_wipe(i_ptr);
+ i_ptr->wipe();
/* Make a good (or great) object (if possible) */
if (!make_object(caster_ptr, i_ptr, mode))
#include "inventory/inventory-slot-types.h"
#include "mind/mind-force-trainer.h"
#include "monster/monster-describer.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "object/object-kind.h"
#include "player-info/avatar.h"
return FALSE;
object_type forge;
- object_copy(&forge, o_ptr);
+ (&forge)->copy_from(o_ptr);
inven_item_increase(creature_ptr, slot, (0 - o_ptr->number));
inven_item_optimize(creature_ptr, slot);
#include "io/input-key-requester.h"
#include "main/music-definitions-table.h"
#include "main/sound-of-music.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "player-status/player-energy.h"
#include "store/cmd-store.h"
GAME_TEXT o_name[MAX_NLEN];
msg_print(_("ザックからアイテムがあふれてしまった！", "Your pack overflows!"));
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
describe_flavor(player_ptr, o_name, q_ptr, 0);
msg_format(_("%sが落ちた。(%c)", "You drop %s (%c)."), o_name, index_to_label(item));
vary_item(player_ptr, item, -255);
#include "floor/floor-town.h"
#include "game-option/birth-options.h"
#include "game-option/game-play-options.h"
-#include "object/object-generator.h"
#include "object/object-stack.h"
#include "object/object-value.h"
#include "player-info/avatar.h"
for (k = i; k < st_ptr->stock_num; k++)
st_ptr->stock[k] = st_ptr->stock[k + 1];
- object_wipe(&st_ptr->stock[k]);
+ (&st_ptr->stock[k])->wipe();
*combined = TRUE;
return TRUE;
}
object_type *j_ptr;
object_type forge;
j_ptr = &forge;
- object_copy(j_ptr, &st_ptr->stock[i]);
+ j_ptr->copy_from(&st_ptr->stock[i]);
for (int k = i; k > j; k--)
- object_copy(&st_ptr->stock[k], &st_ptr->stock[k - 1]);
+ (&st_ptr->stock[k])->copy_from(&st_ptr->stock[k - 1]);
- object_copy(&st_ptr->stock[j], j_ptr);
+ (&st_ptr->stock[j])->copy_from(j_ptr);
}
}
#include "main/sound-of-music.h"
#include "object-enchant/item-feeling.h"
#include "object-enchant/special-object-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-stack.h"
#include "object/object-value.h"
ITEM_NUMBER amt = 1;
object_type forge;
object_type *j_ptr = &forge;
- object_copy(j_ptr, o_ptr);
+ j_ptr->copy_from(o_ptr);
/*
* If a rod or wand, allocate total maximum timeouts or charges
}
j_ptr = &forge;
- object_copy(j_ptr, o_ptr);
+ j_ptr->copy_from(o_ptr);
/*
* If a rod or wand, allocate total maximum timeouts or charges
#include "io/tokenizer.h"
#include "monster-race/monster-race.h"
#include "object-enchant/special-object-flags.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "system/artifact-type-definition.h"
#include "system/monster-race-definition.h"
KIND_OBJECT_IDX k_idx = lookup_kind(a_ptr->tval, a_ptr->sval);
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, k_idx);
+ q_ptr->prep(player_ptr, k_idx);
q_ptr->name1 = a_idx;
q_ptr->ident = IDENT_STORE;
describe_flavor(player_ptr, fullname, q_ptr, OD_NAME_ONLY);
#include "object-hook/hook-checker.h"
#include "object/item-tester-hooker.h"
#include "object/item-use-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-stack.h"
#include "object/object-value.h"
object_type forge;
object_type *q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = amt;
if ((o_ptr->tval == TV_ROD) || (o_ptr->tval == TV_WAND))
identify_item(owner_ptr, o_ptr);
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
q_ptr->number = amt;
q_ptr->ident |= IDENT_STORE;
#include "object-enchant/item-feeling.h"
#include "object-enchant/special-object-flags.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "object/object-value.h"
#include "perception/object-perception.h"
for (int j = item; j < st_ptr->stock_num; j++)
st_ptr->stock[j] = st_ptr->stock[j + 1];
- object_wipe(&st_ptr->stock[st_ptr->stock_num]);
+ (&st_ptr->stock[st_ptr->stock_num])->wipe();
}
/*!
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_prep(player_ptr, q_ptr, k_idx);
+ q_ptr->prep(player_ptr, k_idx);
apply_magic_to_object(player_ptr, q_ptr, level, AM_NO_FIXED_ART);
if (!(*store_will_buy)(player_ptr, q_ptr))
continue;
#include "main/sound-of-music.h"
#include "object-enchant/special-object-flags.h"
#include "object-hook/hook-enchant.h"
-#include "object/object-generator.h"
#include "object/object-stack.h"
#include "perception/identification.h"
#include "perception/object-perception.h"
st_ptr->stock_num = 0;
st_ptr->last_visit = -10L * TURNS_PER_TICK * STORE_TICKS;
for (int k = 0; k < st_ptr->stock_size; k++)
- object_wipe(&st_ptr->stock[k]);
+ (&st_ptr->stock[k])->wipe();
}
--- /dev/null
+/*
+ * @file object-type-definition.h
+ * @brief アイテム定義の構造体とエンティティ処理実装
+ * @author Hourier
+ * @date 2021/05/02
+ */
+
+#include "system/object-type-definition.h"
+#include "object-enchant/object-curse.h"
+#include "object-enchant/special-object-flags.h"
+#include "object-enchant/trc-types.h"
+#include "object-enchant/trg-types.h"
+#include "object/object-kind.h"
+#include "system/player-type-definition.h"
+
+/*!
+ * @brief オブジェクトを初期化する
+ * Wipe an object clean.
+ */
+void object_type::wipe()
+{
+ (void)WIPE(this, object_type);
+}
+
+/*!
+ * @brief オブジェクトを複製する
+ * Wipe an object clean.
+ * @param j_ptr 複製元のオブジェクトの構造体参照ポインタ
+ */
+void object_type::copy_from(object_type *j_ptr)
+{
+ (void)COPY(this, j_ptr, object_type);
+}
+
+/*!
+ * @brief オブジェクト構造体にベースアイテムを作成する
+ * Prepare an object based on an object kind.
+ * @param player_ptr プレーヤーへの参照ポインタ
+ * @param k_idx 新たに作成したいベースアイテム情報のID
+ */
+void object_type::prep(player_type *player_ptr, KIND_OBJECT_IDX ko_idx)
+{
+ object_kind *k_ptr = &k_info[ko_idx];
+ wipe();
+ this->k_idx = ko_idx;
+ this->tval = k_ptr->tval;
+ this->sval = k_ptr->sval;
+ this->pval = k_ptr->pval;
+ this->number = 1;
+ this->weight = k_ptr->weight;
+ this->to_h = k_ptr->to_h;
+ this->to_d = k_ptr->to_d;
+ this->to_a = k_ptr->to_a;
+ this->ac = k_ptr->ac;
+ this->dd = k_ptr->dd;
+ this->ds = k_ptr->ds;
+
+ if (k_ptr->act_idx > 0)
+ this->xtra2 = (XTRA8)k_ptr->act_idx;
+ if (k_info[this->k_idx].cost <= 0)
+ this->ident |= (IDENT_BROKEN);
+
+ if (k_ptr->gen_flags.has(TRG::CURSED))
+ this->curse_flags |= (TRC_CURSED);
+ if (k_ptr->gen_flags.has(TRG::HEAVY_CURSE))
+ this->curse_flags |= (TRC_HEAVY_CURSE);
+ if (k_ptr->gen_flags.has(TRG::PERMA_CURSE))
+ this->curse_flags |= (TRC_PERMA_CURSE);
+ if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE0))
+ this->curse_flags |= get_curse(player_ptr, 0, this);
+ if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE1))
+ this->curse_flags |= get_curse(player_ptr, 1, this);
+ if (k_ptr->gen_flags.has(TRG::RANDOM_CURSE2))
+ this->curse_flags |= get_curse(player_ptr, 2, this);
+}
#pragma once
+/*
+ * @file object-type-definition.h
+ * @brief アイテム定義の構造体とエンティティ処理定義
+ * @author Hourier
+ * @date 2021/05/02
+ */
+
#include "object/tval-types.h"
#include "system/angband.h"
#include "system/system-variables.h"
+struct player_type;
typedef struct object_type {
KIND_OBJECT_IDX k_idx; /* Kind index (zero if "dead") */
POSITION iy; /* Y-position on map, or zero */
BIT_FLAGS curse_flags; /* Flags for curse */
MONSTER_IDX held_m_idx; /*!< アイテムを所持しているモンスターID (いないなら 0) / Monster holding us (if any) */
ARTIFACT_BIAS_IDX artifact_bias; /*!< ランダムアーティファクト生成時のバイアスID */
+
+ void wipe();
+ void copy_from(object_type *j_ptr);
+ void prep(player_type *player_ptr, KIND_OBJECT_IDX ko_idx);
} object_type;
#pragma once
+#include "mutation/mutation-flag-types.h"
#include "player-ability/player-ability-types.h"
#include "player/player-race-types.h"
#include "player/player-class-types.h"
#define MAX_SKILLS 10
#define MAX_MANE 16
-enum class MUTA;
enum class RF_ABILITY;
typedef struct floor_type floor_type;
#include <bitset>
-#include "mutation/mutation-flag-types.h"
-
/**
* @brief フラグ集合を扱う、FlagGroupクラス
*
return;
}
}
+
+ char_stat.syms.emplace_back(".");
}
/*!
#include "flavor/flavor-describer.h"
#include "flavor/object-flavor-types.h"
#include "object-enchant/special-object-flags.h"
-#include "object/object-generator.h"
#include "perception/object-perception.h"
#include "realm/realm-names-table.h"
#include "spell/spell-info.h"
return;
q_ptr = &forge;
- object_prep(owner_ptr, q_ptr, k_idx);
+ q_ptr->prep(owner_ptr, k_idx);
describe_flavor(owner_ptr, o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
term_putstr(0, 0, -1, TERM_WHITE, o_name);
#include "window/main-window-equipments.h"
#include "window/main-window-util.h"
#include "world/world.h"
-#include <string>
-#include <sstream>
#include <mutex>
+#include <sstream>
+#include <string>
/*!
* @brief サブウィンドウに所持品一覧を表示する / Hack -- display inventory in sub-windows
else if (g_ptr->m_idx > 0) {
const monster_type *const m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
- if (m_ptr->r_idx == 0)
+ if (player_ptr->image) {
+ sprintf(line, _("(X:%03d Y:%03d) 何か奇妙な物の足元の発見済みアイテム一覧", "Found items at (%03d,%03d) under something strange"), x, y);
+ } else if (m_ptr->r_idx == 0) {
sprintf(line, _("(X:%03d Y:%03d) 奇妙な物体の足元のアイテム一覧", "Items at (%03d,%03d) under an odd object"), x, y);
- else {
+ } else {
const monster_race *const r_ptr = &r_info[m_ptr->r_idx];
sprintf(line, _("(X:%03d Y:%03d) %sの足元の発見済みアイテム一覧", "Found items at (%03d,%03d) under %s"), x, y, r_ptr->name.c_str());
}
else
sprintf(buf, _("%s", "on %s"), fn);
sprintf(line, _("(X:%03d Y:%03d) %sの上の発見済みアイテム一覧", "Found items at (X:%03d Y:%03d) %s"), x, y, buf);
-
}
term_addstr(-1, TERM_WHITE, line);
#include "wizard/fixed-artifacts-spoiler.h"
#include "io/files-util.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "system/angband-version.h"
#include "system/artifact-type-definition.h"
if (!i)
return FALSE;
- object_prep(player_ptr, o_ptr, i);
+ o_ptr->prep(player_ptr, i);
o_ptr->name1 = name1;
o_ptr->pval = a_ptr->pval;
o_ptr->ac = a_ptr->ac;
continue;
q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
if (!make_fake_artifact(&dummy, q_ptr, j))
continue;
#include "io/files-util.h"
#include "object-enchant/special-object-flags.h"
#include "object-enchant/trg-types.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "object/object-value.h"
#include "system/angband-version.h"
{
object_type forge;
object_type *q_ptr = &forge;
- object_prep(player_ptr, q_ptr, k);
+ q_ptr->prep(player_ptr, k);
q_ptr->ident |= IDENT_KNOWN;
q_ptr->pval = 0;
q_ptr->to_a = 0;
#include "object-hook/hook-checker.h"
#include "object/item-use-flags.h"
#include "object/object-flags.h"
-#include "object/object-generator.h"
#include "object/object-info.h"
#include "object/object-kind.h"
#include "object/object-kind-hook.h"
#include "util/int-char-converter.h"
#include "wizard/wizard-special-process.h"
#include "world/world.h"
+#include <algorithm>
#include <sstream>
#include <vector>
}
}
+/*!
+ * @brief キャスト先の型の最小値、最大値でclampする。
+ */
+template <typename T>
+T clamp_cast(int val)
+{
+ return static_cast<T>(std::clamp(val,
+ static_cast<int>(std::numeric_limits<T>::min()),
+ static_cast<int>(std::numeric_limits<T>::max())));
+}
+
void wiz_restore_aware_flag_of_fixed_arfifact(ARTIFACT_IDX a_idx, bool aware = false);
void wiz_modify_item_activation(player_type *caster_ptr);
void wiz_identify_full_inventory(player_type *caster_ptr);
object_type forge;
object_type *q_ptr = &forge;
- object_wipe(q_ptr);
+ q_ptr->wipe();
make_object(caster_ptr, q_ptr, mode);
if (object_is_fixed_artifact(q_ptr))
a_info[q_ptr->name1].cur_num = 0;
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
char ch;
bool changed = FALSE;
switch (tolower(ch)) {
/* Apply bad magic, but first clear object */
case 'w':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_GREAT | AM_CURSED);
break;
/* Apply bad magic, but first clear object */
case 'c':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_CURSED);
break;
/* Apply normal magic, but first clear object */
case 'n':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART);
break;
/* Apply good magic, but first clear object */
case 'g':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD);
break;
/* Apply great magic, but first clear object */
case 'e':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_GREAT);
break;
/* Apply special magic, but first clear object */
case 's':
- object_prep(owner_ptr, q_ptr, o_ptr->k_idx);
+ q_ptr->prep(owner_ptr, o_ptr->k_idx);
apply_magic_to_object(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_GOOD | AM_GREAT | AM_SPECIAL);
if (!object_is_artifact(q_ptr))
become_random_artifact(owner_ptr, q_ptr, FALSE);
if (!changed)
return;
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
set_bits(owner_ptr->update, PU_BONUS | PU_COMBINE | PU_REORDER);
set_bits(owner_ptr->window_flags, PW_INVEN | PW_EQUIP | PW_SPELL | PW_PLAYER | PW_FLOOR_ITEM_LIST);
}
if (!get_string(p, tmp_val, 5))
return;
- o_ptr->pval = (s16b)atoi(tmp_val);
+ o_ptr->pval = clamp_cast<s16b>(atoi(tmp_val));
wiz_display_item(player_ptr, o_ptr);
p = "Enter new 'to_a' setting: ";
sprintf(tmp_val, "%d", o_ptr->to_a);
if (!get_string(p, tmp_val, 5))
return;
- o_ptr->to_a = (s16b)atoi(tmp_val);
+ o_ptr->to_a = clamp_cast<s16b>(atoi(tmp_val));
wiz_display_item(player_ptr, o_ptr);
p = "Enter new 'to_h' setting: ";
sprintf(tmp_val, "%d", o_ptr->to_h);
if (!get_string(p, tmp_val, 5))
return;
- o_ptr->to_h = (s16b)atoi(tmp_val);
+ o_ptr->to_h = clamp_cast<s16b>(atoi(tmp_val));
wiz_display_item(player_ptr, o_ptr);
p = "Enter new 'to_d' setting: ";
sprintf(tmp_val, "%d", (int)o_ptr->to_d);
if (!get_string(p, tmp_val, 5))
return;
- o_ptr->to_d = (s16b)atoi(tmp_val);
+ o_ptr->to_d = clamp_cast<s16b>(atoi(tmp_val));
wiz_display_item(player_ptr, o_ptr);
}
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_copy(q_ptr, o_ptr);
+ q_ptr->copy_from(o_ptr);
char ch;
bool changed = FALSE;
while (TRUE) {
if (changed) {
msg_print("Changes accepted.");
- object_copy(o_ptr, q_ptr);
+ o_ptr->copy_from(q_ptr);
set_bits(creature_ptr->update, PU_BONUS | PU_COMBINE | PU_REORDER);
set_bits(creature_ptr->window_flags, PW_INVEN | PW_EQUIP | PW_SPELL | PW_PLAYER | PW_FLOOR_ITEM_LIST);
} else {
if (k_ptr->name.empty())
continue;
- object_prep(caster_ptr, o_ptr, k);
+ o_ptr->prep(caster_ptr, k);
describe_flavor(caster_ptr, o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
#ifndef JP
str_tolower(o_name);
if (allow_ego && k_ids.size() == 1) {
KIND_OBJECT_IDX k_idx = k_ids.back();
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
for (EGO_IDX k = 1; k < max_e_idx; k++) {
ego_item_type *e_ptr = &e_info[k];
if (!k_idx)
continue;
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
o_ptr->name1 = i;
describe_flavor(caster_ptr, o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
if (wish_randart) {
if (must || ok_art) {
do {
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
apply_magic_to_object(caster_ptr, o_ptr, k_ptr->level, (AM_SPECIAL | AM_NO_FIXED_ART));
} while (!o_ptr->art_name || o_ptr->name1 || o_ptr->name2 || object_is_cursed(o_ptr));
if (allow_ego && (wish_ego || e_ids.size() > 0)) {
if (must || ok_ego) {
if (e_ids.size() > 0) {
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
o_ptr->name2 = e_ids[0];
apply_ego(caster_ptr, o_ptr, caster_ptr->current_floor_ptr->base_level);
} else {
int max_roll = 1000;
int i = 0;
for (i = 0; i < max_roll; i++) {
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
(void)apply_magic_to_object(caster_ptr, o_ptr, k_ptr->level, (AM_GREAT | AM_NO_FIXED_ART));
if (o_ptr->name1 || o_ptr->art_name)
res = WishResult::EGO;
} else {
for (int i = 0; i < 100; i++) {
- object_prep(caster_ptr, o_ptr, k_idx);
+ o_ptr->prep(caster_ptr, k_idx);
apply_magic_to_object(caster_ptr, o_ptr, 0, (AM_NO_FIXED_ART));
if (!object_is_cursed(o_ptr))
break;
#include "object-enchant/item-apply-magic.h"
#include "object-enchant/trc-types.h"
#include "object-enchant/trg-types.h"
-#include "object/object-generator.h"
#include "object/object-kind.h"
#include "perception/object-perception.h"
#include "player-info/self-info.h"
object_type forge;
object_type *q_ptr;
q_ptr = &forge;
- object_prep(caster_ptr, q_ptr, k_idx);
+ q_ptr->prep(caster_ptr, k_idx);
apply_magic_to_object(caster_ptr, q_ptr, caster_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART);
(void)drop_near(caster_ptr, q_ptr, -1, caster_ptr->y, caster_ptr->x);
msg_print("Allocated.");
object_kind *k_ptr = &k_info[i];
if (k_ptr->level <= command_arg) {
q_ptr = &forge;
- object_prep(caster_ptr, q_ptr, i);
+ q_ptr->prep(caster_ptr, i);
object_aware(caster_ptr, q_ptr);
}
}
#include "monster-race/monster-race.h"
#include "monster-race/race-flags7.h"
#include "monster-race/race-flags8.h"
-#include "object/object-generator.h"
#include "object/object-kind-hook.h"
#include "player/player-class.h"
#include "realm/realm-names-table.h"
if (magic_ptr->spell_book != 0) {
object_type book;
auto o_ptr = &book;
- object_prep(&dummy_p, o_ptr, lookup_kind(magic_ptr->spell_book, 0));
+ o_ptr->prep(&dummy_p, lookup_kind(magic_ptr->spell_book, 0));
describe_flavor(&dummy_p, title, o_ptr, OD_NAME_ONLY);
book_name = title;
char *s = angband_strchr(book_name, '[');
if (level > MAX_DEPTH - 1)
level = MAX_DEPTH - 1;
- if ((level > 0) && !(d_info[owner_ptr->dungeon_idx].flags1 & DF1_BEGINNER)) {
+ if ((level > 0) && d_info[owner_ptr->dungeon_idx].flags.has_not(DF::BEGINNER)) {
if (one_in_(GREAT_OBJ)) {
level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
}
OSDN Git Service
