<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">\r
<ConfigurationType>Application</ConfigurationType>\r
<CharacterSet>Unicode</CharacterSet>\r
- <PlatformToolset>v142</PlatformToolset>\r
+ <PlatformToolset>v143</PlatformToolset>\r
<WholeProgramOptimization>true</WholeProgramOptimization>\r
</PropertyGroup>\r
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='English-Release|Win32'" Label="Configuration">\r
<ConfigurationType>Application</ConfigurationType>\r
<CharacterSet>Unicode</CharacterSet>\r
<WholeProgramOptimization>true</WholeProgramOptimization>\r
- <PlatformToolset>v142</PlatformToolset>\r
+ <PlatformToolset>v143</PlatformToolset>\r
</PropertyGroup>\r
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">\r
<ConfigurationType>Application</ConfigurationType>\r
<CharacterSet>Unicode</CharacterSet>\r
- <PlatformToolset>v142</PlatformToolset>\r
+ <PlatformToolset>v143</PlatformToolset>\r
</PropertyGroup>\r
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='English-Debug|Win32'" Label="Configuration">\r
<ConfigurationType>Application</ConfigurationType>\r
<CharacterSet>Unicode</CharacterSet>\r
- <PlatformToolset>v142</PlatformToolset>\r
+ <PlatformToolset>v143</PlatformToolset>\r
<UseDebugLibraries>true</UseDebugLibraries>\r
</PropertyGroup>\r
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
<ClInclude Include="..\..\src\io\uid-checker.h" />\r
<ClInclude Include="..\..\src\spell-realm\spells-song.h" />\r
<ClInclude Include="..\..\src\effect\effect-processor.h" />\r
- <ClInclude Include="..\..\src\spell\spell-types.h" />\r
+ <ClInclude Include="..\..\src\effect\attribute-types.h" />\r
<ClInclude Include="..\..\src\spell\spells-util.h" />\r
<ClInclude Include="..\..\src\spell\spells-execution.h" />\r
<ClInclude Include="..\..\src\spell-realm\spells-crusade.h" />\r
<ClInclude Include="..\..\src\player-info\class-types.h">\r
<Filter>player-info</Filter>\r
</ClInclude>\r
- <ClInclude Include="..\..\src\spell\spell-types.h">\r
- <Filter>spell</Filter>\r
- </ClInclude>\r
<ClInclude Include="..\..\src\system\monster-race-definition.h">\r
<Filter>system</Filter>\r
</ClInclude>\r
<ClInclude Include="..\..\src\load\monster\monster-loader-version-types.h">\r
<Filter>load\monster</Filter>\r
</ClInclude>\r
+ <ClInclude Include="..\..\src\effect\attribute-types.h">\r
+ <Filter>effect</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
<None Include="..\..\src\wall.bmp" />\r
dungeon/quest-completion-checker.cpp dungeon/quest-completion-checker.h \
dungeon/quest-monster-placer.cpp dungeon/quest-monster-placer.h \
\
+ effect/attribute-types.h \
effect/effect-feature.cpp effect/effect-feature.h \
effect/effect-item.cpp effect/effect-item.h \
effect/spells-effect-util.cpp effect/spells-effect-util.h \
spell/spells-staff-only.cpp spell/spells-staff-only.h \
spell/spells-summon.cpp spell/spells-summon.h \
spell/spells-status.cpp spell/spells-status.h \
- spell/spell-types.h spell/spells-util.h \
+ spell/spells-util.h \
spell/summon-types.h \
spell/technic-info-table.cpp spell/technic-info-table.h \
\
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "sv-definition/sv-lite-types.h"
#include "sv-definition/sv-ring-types.h"
#include "system/artifact-type-definition.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-sorcery.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "spell/summon-types.h"
#include "status/element-resistance.h"
stop_mouth(player_ptr);
msg_print(_("酸を吐きかけた...", "You spit acid..."));
- fire_ball(player_ptr, GF_ACID, dir, lvl, 1 + (lvl / 30));
+ fire_ball(player_ptr, AttributeType::ACID, dir, lvl, 1 + (lvl / 30));
return true;
case MUTA::BR_FIRE:
if (!get_aim_dir(player_ptr, &dir))
stop_mouth(player_ptr);
msg_print(_("あなたは火炎のブレスを吐いた...", "You breathe fire..."));
- fire_breath(player_ptr, GF_FIRE, dir, lvl * 2, 1 + (lvl / 20));
+ fire_breath(player_ptr, AttributeType::FIRE, dir, lvl * 2, 1 + (lvl / 20));
return true;
case MUTA::HYPN_GAZE:
if (!get_aim_dir(player_ptr, &dir))
return false;
msg_print(_("集中している...", "You concentrate..."));
- fire_bolt(player_ptr, GF_PSI, dir, damroll(3 + ((lvl - 1) / 5), 3));
+ fire_bolt(player_ptr, AttributeType::PSI, dir, damroll(3 + ((lvl - 1) / 5), 3));
return true;
case MUTA::RADIATION:
msg_print(_("体から放射能が発生した！", "Radiation flows from your body!"));
- fire_ball(player_ptr, GF_NUKE, 0, (lvl * 2), 3 + (lvl / 20));
+ fire_ball(player_ptr, AttributeType::NUKE, 0, (lvl * 2), 3 + (lvl / 20));
return true;
case MUTA::VAMPIRISM:
vampirism(player_ptr);
return true;
case MUTA::SHRIEK:
stop_mouth(player_ptr);
- (void)fire_ball(player_ptr, GF_SOUND, 0, 2 * lvl, 8);
+ (void)fire_ball(player_ptr, AttributeType::SOUND, 0, 2 * lvl, 8);
(void)aggravate_monsters(player_ptr, 0);
return true;
case MUTA::ILLUMINE:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_LITE, dir, 2 * lvl);
+ fire_beam(player_ptr, AttributeType::LITE, dir, 2 * lvl);
return true;
case MUTA::RECALL:
return recall_player(player_ptr, randint0(21) + 15);
return true;
}
- fire_bolt(player_ptr, GF_COLD, dir, 2 * lvl);
+ fire_bolt(player_ptr, AttributeType::COLD, dir, 2 * lvl);
return true;
}
case MUTA::LAUNCHER: {
#include "monster-race/race-ability-flags.h"
#include "mspell/mspell-damage-calculator.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
msg_print(_("アシッド・ボールの呪文を唱えた。", "You cast an acid ball."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_ACID, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_ACID, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::ACID, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("サンダー・ボールの呪文を唱えた。", "You cast a lightning ball."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_ELEC, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_ELEC, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::ELEC, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("ファイア・ボールの呪文を唱えた。", "You cast a fire ball."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_FIRE, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_FIRE, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::FIRE, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("アイス・ボールの呪文を唱えた。", "You cast a frost ball."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_COLD, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_COLD, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::COLD, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("悪臭雲の呪文を唱えた。", "You cast a stinking cloud."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_POIS, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_POIS, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::POIS, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("放射能球を放った。", "You cast a ball of radiation."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_NUKE, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_NUKE, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::NUKE, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("地獄球の呪文を唱えた。", "You cast a nether ball."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_NETH, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_NETHER, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_ball(player_ptr, AttributeType::NETHER, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("純ログルスを放った。", "You invoke a raw Logrus."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_CHAO, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_CHAOS, bmc_ptr->dir, bmc_ptr->damage, 4);
+ fire_ball(player_ptr, AttributeType::CHAOS, bmc_ptr->dir, bmc_ptr->damage, 4);
return true;
}
msg_print(_("流れるような身振りをした。", "You gesture fluidly."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_WATE, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_WATER, bmc_ptr->dir, bmc_ptr->damage, 4);
+ fire_ball(player_ptr, AttributeType::WATER, bmc_ptr->dir, bmc_ptr->damage, 4);
return true;
}
msg_print(_("スターバーストの呪文を念じた。", "You invoke a starburst."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_LITE, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_LITE, bmc_ptr->dir, bmc_ptr->damage, 4);
+ fire_ball(player_ptr, AttributeType::LITE, bmc_ptr->dir, bmc_ptr->damage, 4);
return true;
}
msg_print(_("暗黒の嵐の呪文を念じた。", "You invoke a darkness storm."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_DARK, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_DARK, bmc_ptr->dir, bmc_ptr->damage, 4);
+ fire_ball(player_ptr, AttributeType::DARK, bmc_ptr->dir, bmc_ptr->damage, 4);
return true;
}
msg_print(_("魔力の嵐の呪文を念じた。", "You invoke a mana storm."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BA_MANA, bmc_ptr->plev, DAM_ROLL);
- fire_ball(player_ptr, GF_MANA, bmc_ptr->dir, bmc_ptr->damage, 4);
+ fire_ball(player_ptr, AttributeType::MANA, bmc_ptr->dir, bmc_ptr->damage, 4);
return true;
}
msg_print(_("アシッド・ボルトの呪文を唱えた。", "You cast an acid bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_ACID, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_ACID, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::ACID, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("サンダー・ボルトの呪文を唱えた。", "You cast a lightning bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_ELEC, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_ELEC, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::ELEC, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("ファイア・ボルトの呪文を唱えた。", "You cast a fire bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_FIRE, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_FIRE, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::FIRE, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("アイス・ボルトの呪文を唱えた。", "You cast a frost bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_COLD, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_COLD, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::COLD, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("地獄の矢の呪文を唱えた。", "You cast a nether bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_NETH, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_NETHER, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::NETHER, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("ウォーター・ボルトの呪文を唱えた。", "You cast a water bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_WATE, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_WATER, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::WATER, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("魔力の矢の呪文を唱えた。", "You cast a mana bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_MANA, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_MANA, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::MANA, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("プラズマ・ボルトの呪文を唱えた。", "You cast a plasma bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_PLAS, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_PLASMA, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::PLASMA, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("極寒の矢の呪文を唱えた。", "You cast a ice bolt."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BO_ICEE, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_ICE, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::ICE, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
msg_print(_("マジック・ミサイルの呪文を唱えた。", "You cast a magic missile."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::MISSILE, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_MISSILE, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::MISSILE, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
#include "monster-race/race-ability-flags.h"
#include "mspell/mspell-damage-calculator.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
msg_print(_("酸のブレスを吐いた。", "You breathe acid."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_ACID, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_ACID, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::ACID, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("稲妻のブレスを吐いた。", "You breathe lightning."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_ELEC, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_ELEC, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::ELEC, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("火炎のブレスを吐いた。", "You breathe fire."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_FIRE, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_FIRE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::FIRE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("冷気のブレスを吐いた。", "You breathe frost."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_COLD, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_COLD, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::COLD, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("ガスのブレスを吐いた。", "You breathe gas."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_POIS, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_POIS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::POIS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("地獄のブレスを吐いた。", "You breathe nether."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_NETH, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_NETHER, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NETHER, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("閃光のブレスを吐いた。", "You breathe light."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_LITE, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_LITE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::LITE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("暗黒のブレスを吐いた。", "You breathe darkness."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_DARK, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_DARK, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DARK, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("混乱のブレスを吐いた。", "You breathe confusion."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_CONF, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_CONFUSION, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::CONFUSION, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("轟音のブレスを吐いた。", "You breathe sound."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_SOUN, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_SOUND, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::SOUND, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("カオスのブレスを吐いた。", "You breathe chaos."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_CHAO, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_CHAOS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::CHAOS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("劣化のブレスを吐いた。", "You breathe disenchantment."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_DISE, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_DISENCHANT, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DISENCHANT, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("因果混乱のブレスを吐いた。", "You breathe nexus."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_NEXU, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_NEXUS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NEXUS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("時間逆転のブレスを吐いた。", "You breathe time."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_TIME, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_TIME, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::TIME, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("遅鈍のブレスを吐いた。", "You breathe inertia."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_INER, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_INERTIAL, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::INERTIAL, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("重力のブレスを吐いた。", "You breathe gravity."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_GRAV, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_GRAVITY, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::GRAVITY, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("破片のブレスを吐いた。", "You breathe shards."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_SHAR, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_SHARDS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::SHARDS, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("プラズマのブレスを吐いた。", "You breathe plasma."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_PLAS, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_PLASMA, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::PLASMA, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("フォースのブレスを吐いた。", "You breathe force."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_FORC, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_FORCE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::FORCE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("魔力のブレスを吐いた。", "You breathe mana."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_MANA, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_MANA, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::MANA, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("放射性廃棄物のブレスを吐いた。", "You breathe toxic waste."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_NUKE, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_NUKE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NUKE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
msg_print(_("分解のブレスを吐いた。", "You breathe disintegration."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BR_DISI, bmc_ptr->plev, DAM_ROLL);
- fire_breath(player_ptr, GF_DISINTEGRATE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DISINTEGRATE, bmc_ptr->dir, bmc_ptr->damage, (bmc_ptr->plev > 40 ? 3 : 2));
return true;
}
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/bad-status-setter.h"
#include "status/body-improvement.h"
msg_print(_("ロケットを発射した。", "You fire a rocket."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::ROCKET, bmc_ptr->plev, DAM_ROLL);
- fire_rocket(player_ptr, GF_ROCKET, bmc_ptr->dir, bmc_ptr->damage, 2);
+ fire_rocket(player_ptr, AttributeType::ROCKET, bmc_ptr->dir, bmc_ptr->damage, 2);
return true;
}
msg_print(_("矢を放った。", "You fire an arrow."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::SHOOT, bmc_ptr->plev, DAM_ROLL);
- fire_bolt(player_ptr, GF_ARROW, bmc_ptr->dir, bmc_ptr->damage);
+ fire_bolt(player_ptr, AttributeType::ARROW, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
return false;
msg_print(_("<破滅の手>を放った！", "You invoke the Hand of Doom!"));
- fire_ball_hide(player_ptr, GF_HAND_DOOM, bmc_ptr->dir, bmc_ptr->plev * 3, 0);
+ fire_ball_hide(player_ptr, AttributeType::HAND_DOOM, bmc_ptr->dir, bmc_ptr->plev * 3, 0);
return true;
}
if (!get_aim_dir(player_ptr, &bmc_ptr->dir))
return false;
- (void)fire_beam(player_ptr, GF_AWAY_ALL, bmc_ptr->dir, 100);
+ (void)fire_beam(player_ptr, AttributeType::AWAY_ALL, bmc_ptr->dir, 100);
return true;
}
msg_print(_("光の剣を放った。", "You throw a psycho-spear."));
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::PSY_SPEAR, bmc_ptr->plev, DAM_ROLL);
- (void)fire_beam(player_ptr, GF_PSY_SPEAR, bmc_ptr->dir, bmc_ptr->damage);
+ (void)fire_beam(player_ptr, AttributeType::PSY_SPEAR, bmc_ptr->dir, bmc_ptr->damage);
return true;
}
#include "monster-race/race-ability-flags.h"
#include "mspell/mspell-damage-calculator.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::DRAIN_MANA, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_DRAIN_MANA, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::DRAIN_MANA, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::MIND_BLAST, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_MIND_BLAST, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::MIND_BLAST, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::BRAIN_SMASH, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_BRAIN_SMASH, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::BRAIN_SMASH, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::CAUSE_1, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_CAUSE_1, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_1, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::CAUSE_2, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_CAUSE_2, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_2, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::CAUSE_3, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_CAUSE_3, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_3, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
return false;
bmc_ptr->damage = monspell_bluemage_damage(player_ptr, RF_ABILITY::CAUSE_4, bmc_ptr->plev, DAM_ROLL);
- fire_ball_hide(player_ptr, GF_CAUSE_4, bmc_ptr->dir, bmc_ptr->damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_4, bmc_ptr->dir, bmc_ptr->damage, 0);
return true;
}
#include "player/player-status-flags.h"
#include "player/player-status.h"
#include "player/special-defense-types.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/action-setter.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
switch (attack) {
case MUTA::SCOR_TAIL:
- project(player_ptr, 0, 0, m_ptr->fy, m_ptr->fx, k, GF_POIS, PROJECT_KILL);
+ project(player_ptr, 0, 0, m_ptr->fy, m_ptr->fx, k, AttributeType::POIS, PROJECT_KILL);
*mdeath = (m_ptr->r_idx == 0);
break;
case MUTA::HORNS:
case MUTA::TRUNK:
case MUTA::TENTACLES:
default: {
- MonsterDamageProcessor mdp(player_ptr, m_idx, k, fear, GF_ATTACK);
+ MonsterDamageProcessor mdp(player_ptr, m_idx, k, fear, AttributeType::ATTACK);
*mdeath = mdp.mon_take_hit(nullptr);
break;
}
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "spell/spells-summon.h"
#include "spell/summon-types.h"
return false;
else
msg_print(_("ロケットを発射した。", "You fire a rocket."));
- fire_rocket(player_ptr, GF_ROCKET, dir, damage, 2);
+ fire_rocket(player_ptr, AttributeType::ROCKET, dir, damage, 2);
break;
case RF_ABILITY::SHOOT:
return false;
else
msg_print(_("矢を放った。", "You fire an arrow."));
- fire_bolt(player_ptr, GF_ARROW, dir, damage);
+ fire_bolt(player_ptr, AttributeType::ARROW, dir, damage);
break;
case RF_ABILITY::XXX2:
return false;
else
msg_print(_("酸のブレスを吐いた。", "You breathe acid."));
- fire_breath(player_ptr, GF_ACID, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::ACID, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_ELEC:
return false;
else
msg_print(_("稲妻のブレスを吐いた。", "You breathe lightning."));
- fire_breath(player_ptr, GF_ELEC, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::ELEC, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_FIRE:
return false;
else
msg_print(_("火炎のブレスを吐いた。", "You breathe fire."));
- fire_breath(player_ptr, GF_FIRE, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::FIRE, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_COLD:
return false;
else
msg_print(_("冷気のブレスを吐いた。", "You breathe frost."));
- fire_breath(player_ptr, GF_COLD, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::COLD, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_POIS:
return false;
else
msg_print(_("ガスのブレスを吐いた。", "You breathe gas."));
- fire_breath(player_ptr, GF_POIS, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::POIS, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_NETH:
return false;
else
msg_print(_("地獄のブレスを吐いた。", "You breathe nether."));
- fire_breath(player_ptr, GF_NETHER, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NETHER, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_LITE:
return false;
else
msg_print(_("閃光のブレスを吐いた。", "You breathe light."));
- fire_breath(player_ptr, GF_LITE, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::LITE, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_DARK:
return false;
else
msg_print(_("暗黒のブレスを吐いた。", "You breathe darkness."));
- fire_breath(player_ptr, GF_DARK, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DARK, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_CONF:
return false;
else
msg_print(_("混乱のブレスを吐いた。", "You breathe confusion."));
- fire_breath(player_ptr, GF_CONFUSION, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::CONFUSION, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_SOUN:
return false;
else
msg_print(_("轟音のブレスを吐いた。", "You breathe sound."));
- fire_breath(player_ptr, GF_SOUND, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::SOUND, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_CHAO:
return false;
else
msg_print(_("カオスのブレスを吐いた。", "You breathe chaos."));
- fire_breath(player_ptr, GF_CHAOS, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::CHAOS, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_DISE:
return false;
else
msg_print(_("劣化のブレスを吐いた。", "You breathe disenchantment."));
- fire_breath(player_ptr, GF_DISENCHANT, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DISENCHANT, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_NEXU:
return false;
else
msg_print(_("因果混乱のブレスを吐いた。", "You breathe nexus."));
- fire_breath(player_ptr, GF_NEXUS, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NEXUS, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_TIME:
return false;
else
msg_print(_("時間逆転のブレスを吐いた。", "You breathe time."));
- fire_breath(player_ptr, GF_TIME, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::TIME, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_INER:
return false;
else
msg_print(_("遅鈍のブレスを吐いた。", "You breathe inertia."));
- fire_breath(player_ptr, GF_INERTIAL, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::INERTIAL, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_GRAV:
return false;
else
msg_print(_("重力のブレスを吐いた。", "You breathe gravity."));
- fire_breath(player_ptr, GF_GRAVITY, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::GRAVITY, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_SHAR:
return false;
else
msg_print(_("破片のブレスを吐いた。", "You breathe shards."));
- fire_breath(player_ptr, GF_SHARDS, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::SHARDS, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_PLAS:
else
msg_print(_("プラズマのブレスを吐いた。", "You breathe plasma."));
- fire_breath(player_ptr, GF_PLASMA, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::PLASMA, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_FORC:
else
msg_print(_("フォースのブレスを吐いた。", "You breathe force."));
- fire_breath(player_ptr, GF_FORCE, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::FORCE, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BR_MANA:
else
msg_print(_("魔力のブレスを吐いた。", "You breathe mana."));
- fire_breath(player_ptr, GF_MANA, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::MANA, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BA_NUKE:
else
msg_print(_("放射能球を放った。", "You cast a ball of radiation."));
- fire_ball(player_ptr, GF_NUKE, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::NUKE, dir, damage, 2);
break;
case RF_ABILITY::BR_NUKE:
else
msg_print(_("放射性廃棄物のブレスを吐いた。", "You breathe toxic waste."));
- fire_breath(player_ptr, GF_NUKE, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::NUKE, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BA_CHAO:
else
msg_print(_("純ログルスを放った。", "You invoke a raw Logrus."));
- fire_ball(player_ptr, GF_CHAOS, dir, damage, 4);
+ fire_ball(player_ptr, AttributeType::CHAOS, dir, damage, 4);
break;
case RF_ABILITY::BR_DISI:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("分解のブレスを吐いた。", "You breathe disintegration."));
- fire_breath(player_ptr, GF_DISINTEGRATE, dir, damage, (plev > 35 ? 3 : 2));
+ fire_breath(player_ptr, AttributeType::DISINTEGRATE, dir, damage, (plev > 35 ? 3 : 2));
break;
case RF_ABILITY::BA_ACID:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("アシッド・ボールの呪文を唱えた。", "You cast an acid ball."));
- fire_ball(player_ptr, GF_ACID, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::ACID, dir, damage, 2);
break;
case RF_ABILITY::BA_ELEC:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("サンダー・ボールの呪文を唱えた。", "You cast a lightning ball."));
- fire_ball(player_ptr, GF_ELEC, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, damage, 2);
break;
case RF_ABILITY::BA_FIRE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("ファイア・ボールの呪文を唱えた。", "You cast a fire ball."));
- fire_ball(player_ptr, GF_FIRE, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, damage, 2);
break;
case RF_ABILITY::BA_COLD:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("アイス・ボールの呪文を唱えた。", "You cast a frost ball."));
- fire_ball(player_ptr, GF_COLD, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::COLD, dir, damage, 2);
break;
case RF_ABILITY::BA_POIS:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("悪臭雲の呪文を唱えた。", "You cast a stinking cloud."));
- fire_ball(player_ptr, GF_POIS, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::POIS, dir, damage, 2);
break;
case RF_ABILITY::BA_NETH:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("地獄球の呪文を唱えた。", "You cast a nether ball."));
- fire_ball(player_ptr, GF_NETHER, dir, damage, 2);
+ fire_ball(player_ptr, AttributeType::NETHER, dir, damage, 2);
break;
case RF_ABILITY::BA_WATE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("流れるような身振りをした。", "You gesture fluidly."));
- fire_ball(player_ptr, GF_WATER, dir, damage, 4);
+ fire_ball(player_ptr, AttributeType::WATER, dir, damage, 4);
break;
case RF_ABILITY::BA_MANA:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("魔力の嵐の呪文を念じた。", "You invoke a mana storm."));
- fire_ball(player_ptr, GF_MANA, dir, damage, 4);
+ fire_ball(player_ptr, AttributeType::MANA, dir, damage, 4);
break;
case RF_ABILITY::BA_DARK:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("暗黒の嵐の呪文を念じた。", "You invoke a darkness storm."));
- fire_ball(player_ptr, GF_DARK, dir, damage, 4);
+ fire_ball(player_ptr, AttributeType::DARK, dir, damage, 4);
break;
case RF_ABILITY::DRAIN_MANA:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_DRAIN_MANA, dir, randint1(plev * 3) + plev, 0);
+ fire_ball_hide(player_ptr, AttributeType::DRAIN_MANA, dir, randint1(plev * 3) + plev, 0);
break;
case RF_ABILITY::MIND_BLAST:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_MIND_BLAST, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::MIND_BLAST, dir, damage, 0);
break;
case RF_ABILITY::BRAIN_SMASH:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_BRAIN_SMASH, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::BRAIN_SMASH, dir, damage, 0);
break;
case RF_ABILITY::CAUSE_1:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_CAUSE_1, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_1, dir, damage, 0);
break;
case RF_ABILITY::CAUSE_2:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_CAUSE_2, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_2, dir, damage, 0);
break;
case RF_ABILITY::CAUSE_3:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_CAUSE_3, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_3, dir, damage, 0);
break;
case RF_ABILITY::CAUSE_4:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_CAUSE_4, dir, damage, 0);
+ fire_ball_hide(player_ptr, AttributeType::CAUSE_4, dir, damage, 0);
break;
case RF_ABILITY::BO_ACID:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("アシッド・ボルトの呪文を唱えた。", "You cast an acid bolt."));
- fire_bolt(player_ptr, GF_ACID, dir, damage);
+ fire_bolt(player_ptr, AttributeType::ACID, dir, damage);
break;
case RF_ABILITY::BO_ELEC:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("サンダー・ボルトの呪文を唱えた。", "You cast a lightning bolt."));
- fire_bolt(player_ptr, GF_ELEC, dir, damage);
+ fire_bolt(player_ptr, AttributeType::ELEC, dir, damage);
break;
case RF_ABILITY::BO_FIRE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("ファイア・ボルトの呪文を唱えた。", "You cast a fire bolt."));
- fire_bolt(player_ptr, GF_FIRE, dir, damage);
+ fire_bolt(player_ptr, AttributeType::FIRE, dir, damage);
break;
case RF_ABILITY::BO_COLD:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("アイス・ボルトの呪文を唱えた。", "You cast a frost bolt."));
- fire_bolt(player_ptr, GF_COLD, dir, damage);
+ fire_bolt(player_ptr, AttributeType::COLD, dir, damage);
break;
case RF_ABILITY::BA_LITE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("スターバーストの呪文を念じた。", "You invoke a starburst."));
- fire_ball(player_ptr, GF_LITE, dir, damage, 4);
+ fire_ball(player_ptr, AttributeType::LITE, dir, damage, 4);
break;
case RF_ABILITY::BO_NETH:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("地獄の矢の呪文を唱えた。", "You cast a nether bolt."));
- fire_bolt(player_ptr, GF_NETHER, dir, damage);
+ fire_bolt(player_ptr, AttributeType::NETHER, dir, damage);
break;
case RF_ABILITY::BO_WATE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("ウォーター・ボルトの呪文を唱えた。", "You cast a water bolt."));
- fire_bolt(player_ptr, GF_WATER, dir, damage);
+ fire_bolt(player_ptr, AttributeType::WATER, dir, damage);
break;
case RF_ABILITY::BO_MANA:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("魔力の矢の呪文を唱えた。", "You cast a mana bolt."));
- fire_bolt(player_ptr, GF_MANA, dir, damage);
+ fire_bolt(player_ptr, AttributeType::MANA, dir, damage);
break;
case RF_ABILITY::BO_PLAS:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("プラズマ・ボルトの呪文を唱えた。", "You cast a plasma bolt."));
- fire_bolt(player_ptr, GF_PLASMA, dir, damage);
+ fire_bolt(player_ptr, AttributeType::PLASMA, dir, damage);
break;
case RF_ABILITY::BO_ICEE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("極寒の矢の呪文を唱えた。", "You cast a ice bolt."));
- fire_bolt(player_ptr, GF_ICE, dir, damage);
+ fire_bolt(player_ptr, AttributeType::ICE, dir, damage);
break;
case RF_ABILITY::MISSILE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("マジック・ミサイルの呪文を唱えた。", "You cast a magic missile."));
- fire_bolt(player_ptr, GF_MISSILE, dir, damage);
+ fire_bolt(player_ptr, AttributeType::MISSILE, dir, damage);
break;
case RF_ABILITY::SCARE:
if (!get_aim_dir(player_ptr, &dir))
else
msg_print(_("<破滅の手>を放った！", "You invoke the Hand of Doom!"));
- fire_ball_hide(player_ptr, GF_HAND_DOOM, dir, 200, 0);
+ fire_ball_hide(player_ptr, AttributeType::HAND_DOOM, dir, 200, 0);
break;
}
case RF_ABILITY::HEAL: {
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_beam(player_ptr, GF_AWAY_ALL, dir, plev);
+ (void)fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, plev);
break;
case RF_ABILITY::TELE_LEVEL:
return false;
else
msg_print(_("光の剣を放った。", "You throw a psycho-spear."));
- (void)fire_beam(player_ptr, GF_PSY_SPEAR, dir, damage);
+ (void)fire_beam(player_ptr, AttributeType::PSY_SPEAR, dir, damage);
break;
case RF_ABILITY::DARKNESS:
#include "player/player-status-table.h"
#include "player/player-status.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
#include "system/floor-type-definition.h"
}
msg_format(_("%sの力が制御できない氾流となって解放された！", "Your mind unleashes its power in an uncontrollable storm!"), cm_ptr->mind_explanation);
- project(player_ptr, PROJECT_WHO_UNCTRL_POWER, 2 + cm_ptr->plev / 10, player_ptr->y, player_ptr->x, cm_ptr->plev * 2, GF_MANA,
+ project(player_ptr, PROJECT_WHO_UNCTRL_POWER, 2 + cm_ptr->plev / 10, player_ptr->y, player_ptr->x, cm_ptr->plev * 2, AttributeType::MANA,
PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM);
player_ptr->csp = std::max(0, player_ptr->csp - cm_ptr->plev * std::max(1, cm_ptr->plev / 10));
}
}
msg_format(_("%sの力が制御できない氾流となって解放された！", "Your mind unleashes its power in an uncontrollable storm!"), cm_ptr->mind_explanation);
- project(player_ptr, PROJECT_WHO_UNCTRL_POWER, 2 + cm_ptr->plev / 10, player_ptr->y, player_ptr->x, cm_ptr->plev * 2, GF_MANA,
+ project(player_ptr, PROJECT_WHO_UNCTRL_POWER, 2 + cm_ptr->plev / 10, player_ptr->y, player_ptr->x, cm_ptr->plev * 2, AttributeType::MANA,
PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM);
player_ptr->csp = std::max(0, player_ptr->csp - cm_ptr->plev * std::max(1, cm_ptr->plev / 10));
}
#include "spell-kind/spells-specific-bolt.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/action-setter.h"
#include "status/buff-setter.h"
}
case SV_ROD_ACID_BOLT: {
- fire_bolt_or_beam(player_ptr, 10, GF_ACID, dir, damroll(6 + lev / 7, 8));
+ fire_bolt_or_beam(player_ptr, 10, AttributeType::ACID, dir, damroll(6 + lev / 7, 8));
ident = true;
break;
}
case SV_ROD_ELEC_BOLT: {
- fire_bolt_or_beam(player_ptr, 10, GF_ELEC, dir, damroll(4 + lev / 9, 8));
+ fire_bolt_or_beam(player_ptr, 10, AttributeType::ELEC, dir, damroll(4 + lev / 9, 8));
ident = true;
break;
}
case SV_ROD_FIRE_BOLT: {
- fire_bolt_or_beam(player_ptr, 10, GF_FIRE, dir, damroll(7 + lev / 6, 8));
+ fire_bolt_or_beam(player_ptr, 10, AttributeType::FIRE, dir, damroll(7 + lev / 6, 8));
ident = true;
break;
}
case SV_ROD_COLD_BOLT: {
- fire_bolt_or_beam(player_ptr, 10, GF_COLD, dir, damroll(5 + lev / 8, 8));
+ fire_bolt_or_beam(player_ptr, 10, AttributeType::COLD, dir, damroll(5 + lev / 8, 8));
ident = true;
break;
}
case SV_ROD_ACID_BALL: {
- fire_ball(player_ptr, GF_ACID, dir, 60 + lev, rad);
+ fire_ball(player_ptr, AttributeType::ACID, dir, 60 + lev, rad);
ident = true;
break;
}
case SV_ROD_ELEC_BALL: {
- fire_ball(player_ptr, GF_ELEC, dir, 40 + lev, rad);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, 40 + lev, rad);
ident = true;
break;
}
case SV_ROD_FIRE_BALL: {
- fire_ball(player_ptr, GF_FIRE, dir, 70 + lev, rad);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, 70 + lev, rad);
ident = true;
break;
}
case SV_ROD_COLD_BALL: {
- fire_ball(player_ptr, GF_COLD, dir, 50 + lev, rad);
+ fire_ball(player_ptr, AttributeType::COLD, dir, 50 + lev, rad);
ident = true;
break;
}
#include "spell-kind/spells-neighbor.h"
#include "spell-kind/spells-specific-bolt.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/action-setter.h"
#include "status/experience.h"
}
case SV_WAND_STINKING_CLOUD: {
- fire_ball(player_ptr, GF_POIS, dir, 12 + lev / 4, rad);
+ fire_ball(player_ptr, AttributeType::POIS, dir, 12 + lev / 4, rad);
ident = true;
break;
}
case SV_WAND_MAGIC_MISSILE: {
- fire_bolt_or_beam(player_ptr, 20, GF_MISSILE, dir, damroll(2 + lev / 10, 6));
+ fire_bolt_or_beam(player_ptr, 20, AttributeType::MISSILE, dir, damroll(2 + lev / 10, 6));
ident = true;
break;
}
case SV_WAND_ACID_BOLT: {
- fire_bolt_or_beam(player_ptr, 20, GF_ACID, dir, damroll(6 + lev / 7, 8));
+ fire_bolt_or_beam(player_ptr, 20, AttributeType::ACID, dir, damroll(6 + lev / 7, 8));
ident = true;
break;
}
}
case SV_WAND_FIRE_BOLT: {
- fire_bolt_or_beam(player_ptr, 20, GF_FIRE, dir, damroll(7 + lev / 6, 8));
+ fire_bolt_or_beam(player_ptr, 20, AttributeType::FIRE, dir, damroll(7 + lev / 6, 8));
ident = true;
break;
}
case SV_WAND_COLD_BOLT: {
- fire_bolt_or_beam(player_ptr, 20, GF_COLD, dir, damroll(5 + lev / 8, 8));
+ fire_bolt_or_beam(player_ptr, 20, AttributeType::COLD, dir, damroll(5 + lev / 8, 8));
ident = true;
break;
}
case SV_WAND_ACID_BALL: {
- fire_ball(player_ptr, GF_ACID, dir, 60 + 3 * lev / 4, rad);
+ fire_ball(player_ptr, AttributeType::ACID, dir, 60 + 3 * lev / 4, rad);
ident = true;
break;
}
case SV_WAND_ELEC_BALL: {
- fire_ball(player_ptr, GF_ELEC, dir, 40 + 3 * lev / 4, rad);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, 40 + 3 * lev / 4, rad);
ident = true;
break;
}
case SV_WAND_FIRE_BALL: {
- fire_ball(player_ptr, GF_FIRE, dir, 70 + 3 * lev / 4, rad);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, 70 + 3 * lev / 4, rad);
ident = true;
break;
}
case SV_WAND_COLD_BALL: {
- fire_ball(player_ptr, GF_COLD, dir, 50 + 3 * lev / 4, rad);
+ fire_ball(player_ptr, AttributeType::COLD, dir, 50 + 3 * lev / 4, rad);
ident = true;
break;
}
}
case SV_WAND_DRAGON_FIRE: {
- fire_breath(player_ptr, GF_FIRE, dir, (powerful ? 300 : 200), 3);
+ fire_breath(player_ptr, AttributeType::FIRE, dir, (powerful ? 300 : 200), 3);
ident = true;
break;
}
case SV_WAND_DRAGON_COLD: {
- fire_breath(player_ptr, GF_COLD, dir, (powerful ? 270 : 180), 3);
+ fire_breath(player_ptr, AttributeType::COLD, dir, (powerful ? 270 : 180), 3);
ident = true;
break;
}
case SV_WAND_DRAGON_BREATH: {
HIT_POINT dam;
- EFFECT_ID typ;
+ AttributeType typ;
switch (randint1(5)) {
case 1:
dam = 240;
- typ = GF_ACID;
+ typ = AttributeType::ACID;
break;
case 2:
dam = 210;
- typ = GF_ELEC;
+ typ = AttributeType::ELEC;
break;
case 3:
dam = 240;
- typ = GF_FIRE;
+ typ = AttributeType::FIRE;
break;
case 4:
dam = 210;
- typ = GF_COLD;
+ typ = AttributeType::COLD;
break;
default:
dam = 180;
- typ = GF_POIS;
+ typ = AttributeType::POIS;
break;
}
}
case SV_WAND_DISINTEGRATE: {
- fire_ball(player_ptr, GF_DISINTEGRATE, dir, 200 + randint1(lev * 2), rad);
+ fire_ball(player_ptr, AttributeType::DISINTEGRATE, dir, 200 + randint1(lev * 2), rad);
ident = true;
break;
}
case SV_WAND_ROCKETS: {
msg_print(_("ロケットを発射した！", "You launch a rocket!"));
- fire_rocket(player_ptr, GF_ROCKET, dir, 250 + lev * 3, rad);
+ fire_rocket(player_ptr, AttributeType::ROCKET, dir, 250 + lev * 3, rad);
ident = true;
break;
}
case SV_WAND_STRIKING: {
- fire_bolt(player_ptr, GF_METEOR, dir, damroll(15 + lev / 3, 13));
+ fire_bolt(player_ptr, AttributeType::METEOR, dir, damroll(15 + lev / 3, 13));
ident = true;
break;
}
case SV_WAND_GENOCIDE: {
- fire_ball_hide(player_ptr, GF_GENOCIDE, dir, magic ? lev + 50 : 250, 0);
+ fire_ball_hide(player_ptr, AttributeType::GENOCIDE, dir, magic ? lev + 50 : 250, 0);
ident = true;
break;
}
#include "realm/realm-hex-numbers.h"
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-type-definition.h"
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sは突然熱くなった！", "%^s is suddenly very hot!"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_FIRE);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::FIRE);
if (mdp.mon_take_hit(_("は灰の山になった。", " turns into a pile of ash."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sは電撃をくらった！", "%^s gets zapped!"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_ELEC);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::ELEC);
if (mdp.mon_take_hit(_("は燃え殻の山になった。", " turns into a pile of cinders."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sは冷気をくらった！", "%^s is very cold!"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_COLD);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::COLD);
if (mdp.mon_take_hit(_("は凍りついた。", " was frozen."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sは鏡の破片をくらった！", "%^s gets sliced!"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_SHARDS);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::SHARDS);
if (mdp.mon_take_hit(_("はズタズタになった。", " is torn to pieces."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sは聖なるオーラで傷ついた！", "%^s is injured by holy power!"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_HOLY_FIRE);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::HOLY_FIRE);
if (mdp.mon_take_hit(_("は倒れた。", " is destroyed."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
HIT_POINT dam = damroll(2, 6);
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("%^sが鋭い闘気のオーラで傷ついた！", "%^s is injured by the Force"), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_MANA);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::MANA);
if (mdp.mon_take_hit(_("は倒れた。", " is destroyed."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
msg_format(_("影のオーラが%^sに反撃した！", "Enveloping shadows attack %^s."), monap_ptr->m_name);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, GF_DARK);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, dam, &monap_ptr->fear, AttributeType::DARK);
if (mdp.mon_take_hit(_("は倒れた。", " is destroyed."))) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
}
BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
- EFFECT_ID typ[4][2] = { { INVEN_HEAD, GF_OLD_CONF }, { INVEN_SUB_HAND, GF_OLD_SLEEP }, { INVEN_ARMS, GF_TURN_ALL }, { INVEN_FEET, GF_OLD_SLOW } };
+ EFFECT_ID typ[4][2] = { { INVEN_HEAD, (EFFECT_ID)AttributeType::OLD_CONF }, { INVEN_SUB_HAND, (EFFECT_ID)AttributeType::OLD_SLEEP },
+ { INVEN_ARMS, (EFFECT_ID)AttributeType::TURN_ALL }, { INVEN_FEET, (EFFECT_ID)AttributeType::OLD_SLOW } };
/* Some cursed armours gives an extra effect */
for (int j = 0; j < 4; j++) {
o_armed_ptr = &player_ptr->inventory_list[typ[j][0]];
if ((o_armed_ptr->k_idx) && o_armed_ptr->is_cursed() && o_armed_ptr->is_armour())
- project(player_ptr, 0, 0, monap_ptr->m_ptr->fy, monap_ptr->m_ptr->fx, (player_ptr->lev * 2), typ[j][1], flg);
+ project(player_ptr, 0, 0, monap_ptr->m_ptr->fy, monap_ptr->m_ptr->fx, (player_ptr->lev * 2), (AttributeType)typ[j][1], flg);
}
}
#include "player/player-personality-types.h"
#include "player/player-skill.h"
#include "player/player-status-table.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "sv-definition/sv-bow-types.h"
#include "system/artifact-type-definition.h"
#include "system/floor-type-definition.h"
* @param arrow_ptr 矢弾のオブジェクト構造体参照ポインタ
* @return スナイパーの射撃属性、弓矢の属性を考慮する。デフォルトはGF_PLAYER_SHOOT。
*/
-EffectFlags shot_effect_type(player_type *player_ptr, object_type *bow_ptr, object_type *arrow_ptr, SPELL_IDX snipe_type)
+AttributeFlags shot_attribute(player_type *player_ptr, object_type *bow_ptr, object_type *arrow_ptr, SPELL_IDX snipe_type)
{
- EffectFlags effect_flags{};
- effect_flags.set(GF_PLAYER_SHOOT);
+ AttributeFlags attribute_flags{};
+ attribute_flags.set(AttributeType::PLAYER_SHOOT);
TrFlags flags{};
auto arrow_flags = object_flags(arrow_ptr);
static const struct snipe_convert_table_t {
SPELL_IDX snipe_type;
- spells_type effect_type;
+ AttributeType attribute;
} snipe_convert_table[] = {
- { SP_LITE, GF_LITE },
- { SP_FIRE, GF_FIRE },
- { SP_COLD, GF_COLD },
- { SP_ELEC, GF_ELEC },
- { SP_KILL_WALL, GF_KILL_WALL },
- { SP_EVILNESS, GF_HELL_FIRE },
- { SP_HOLYNESS, GF_HOLY_FIRE },
- { SP_FINAL, GF_MANA },
+ { SP_LITE, AttributeType::LITE },
+ { SP_FIRE, AttributeType::FIRE },
+ { SP_COLD, AttributeType::COLD },
+ { SP_ELEC, AttributeType::ELEC },
+ { SP_KILL_WALL, AttributeType::KILL_WALL },
+ { SP_EVILNESS, AttributeType::HELL_FIRE },
+ { SP_HOLYNESS, AttributeType::HOLY_FIRE },
+ { SP_FINAL, AttributeType::MANA },
};
static const struct brand_convert_table_t {
tr_type brand_type;
- spells_type effect_type;
+ AttributeType attribute;
} brand_convert_table[] = {
- { TR_BRAND_ACID, GF_ACID },
- { TR_BRAND_FIRE, GF_FIRE },
- { TR_BRAND_ELEC, GF_ELEC },
- { TR_BRAND_COLD, GF_COLD },
- { TR_BRAND_POIS, GF_POIS },
- { TR_SLAY_GOOD, GF_HELL_FIRE },
- { TR_KILL_GOOD, GF_HELL_FIRE },
- { TR_SLAY_EVIL, GF_HOLY_FIRE },
- { TR_KILL_EVIL, GF_HOLY_FIRE },
+ { TR_BRAND_ACID, AttributeType::ACID },
+ { TR_BRAND_FIRE, AttributeType::FIRE },
+ { TR_BRAND_ELEC, AttributeType::ELEC },
+ { TR_BRAND_COLD, AttributeType::COLD },
+ { TR_BRAND_POIS, AttributeType::POIS },
+ { TR_SLAY_GOOD, AttributeType::HELL_FIRE },
+ { TR_KILL_GOOD, AttributeType::HELL_FIRE },
+ { TR_SLAY_EVIL, AttributeType::HOLY_FIRE },
+ { TR_KILL_EVIL, AttributeType::HOLY_FIRE },
};
for (size_t i = 0; i < sizeof(snipe_convert_table) / sizeof(snipe_convert_table[0]); ++i) {
const struct snipe_convert_table_t *p = &snipe_convert_table[i];
if (snipe_type == p->snipe_type)
- effect_flags.set(p->effect_type);
+ attribute_flags.set(p->attribute);
}
for (size_t i = 0; i < sizeof(brand_convert_table) / sizeof(brand_convert_table[0]); ++i) {
const struct brand_convert_table_t *p = &brand_convert_table[i];
if (flags.has(p->brand_type))
- effect_flags.set(p->effect_type);
+ attribute_flags.set(p->attribute);
}
if ((flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (player_ptr->msp / 30))) {
- effect_flags.set(GF_MANA);
+ attribute_flags.set(AttributeType::MANA);
}
- return effect_flags;
+ return attribute_flags;
}
/*!
object_type *q_ptr;
object_type *o_ptr;
- EffectFlags effect_flags{};
- effect_flags.set(GF_PLAYER_SHOOT);
+ AttributeFlags attribute_flags{};
+ attribute_flags.set(AttributeType::PLAYER_SHOOT);
bool hit_body = false;
/* Sniper */
if (snipe_type == SP_KILL_TRAP) {
- project(player_ptr, 0, 0, ny, nx, 0, GF_KILL_TRAP, (PROJECT_JUMP | PROJECT_HIDE | PROJECT_GRID | PROJECT_ITEM));
+ project(player_ptr, 0, 0, ny, nx, 0, AttributeType::KILL_TRAP, (PROJECT_JUMP | PROJECT_HIDE | PROJECT_GRID | PROJECT_ITEM));
}
/* Sniper */
}
} else {
- effect_flags = shot_effect_type(player_ptr, j_ptr, q_ptr, snipe_type);
+ attribute_flags = shot_attribute(player_ptr, j_ptr, q_ptr, snipe_type);
/* Apply special damage */
tdam = calc_shot_damage_with_slay(player_ptr, j_ptr, q_ptr, tdam, m_ptr, snipe_type);
tdam = critical_shot(player_ptr, q_ptr->weight, q_ptr->to_h, j_ptr->to_h, tdam);
uint16_t flg = (PROJECT_STOP | PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID);
sound(SOUND_EXPLODE); /* No explode sound - use breath fire instead */
- project(player_ptr, 0, ((sniper_concent + 1) / 2 + 1), ny, nx, base_dam, GF_MISSILE, flg);
+ project(player_ptr, 0, ((sniper_concent + 1) / 2 + 1), ny, nx, base_dam, AttributeType::MISSILE, flg);
break;
}
}
/* Hit the monster, check for death */
- MonsterDamageProcessor mdp(player_ptr, c_mon_ptr->m_idx, tdam, &fear, effect_flags);
+ MonsterDamageProcessor mdp(player_ptr, c_mon_ptr->m_idx, tdam, &fear, attribute_flags);
if (mdp.mon_take_hit(extract_note_dies(real_r_idx(m_ptr)))) {
/* Dead monster */
}
#include "realm/realm-hex-numbers.h"
#include "specific-object/torch.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
#include "system/object-type-definition.h"
return (tdam * mult / 10);
}
-EffectFlags melee_effect_type(player_type *player_ptr, object_type *o_ptr, combat_options mode)
+AttributeFlags melee_attribute(player_type *player_ptr, object_type *o_ptr, combat_options mode)
{
- EffectFlags effect_flags{};
- effect_flags.set(GF_PLAYER_MELEE);
+ AttributeFlags attribute_flags{};
+ attribute_flags.set(AttributeType::PLAYER_MELEE);
if (player_ptr->pclass == PlayerClassType::SAMURAI) {
static const struct samurai_convert_table_t {
combat_options hissatsu_type;
- spells_type effect_type;
+ AttributeType attribute;
} samurai_convert_table[] = {
- { HISSATSU_FIRE, GF_FIRE },
- { HISSATSU_COLD, GF_COLD },
- { HISSATSU_ELEC, GF_ELEC },
- { HISSATSU_POISON, GF_POIS },
- { HISSATSU_HAGAN, GF_KILL_WALL },
+ { HISSATSU_FIRE, AttributeType::FIRE },
+ { HISSATSU_COLD, AttributeType::COLD },
+ { HISSATSU_ELEC, AttributeType::ELEC },
+ { HISSATSU_POISON, AttributeType::POIS },
+ { HISSATSU_HAGAN, AttributeType::KILL_WALL },
};
for (size_t i = 0; i < sizeof(samurai_convert_table) / sizeof(samurai_convert_table[0]); ++i) {
const struct samurai_convert_table_t *p = &samurai_convert_table[i];
if (mode == p->hissatsu_type)
- effect_flags.set(p->effect_type);
+ attribute_flags.set(p->attribute);
}
}
static const struct brand_convert_table_t {
tr_type brand_type;
- spells_type effect_type;
+ AttributeType attribute;
} brand_convert_table[] = {
- { TR_BRAND_ACID, GF_ACID },
- { TR_BRAND_FIRE, GF_FIRE },
- { TR_BRAND_ELEC, GF_ELEC },
- { TR_BRAND_COLD, GF_COLD },
- { TR_BRAND_POIS, GF_POIS },
- { TR_SLAY_GOOD, GF_HELL_FIRE },
- { TR_KILL_GOOD, GF_HELL_FIRE },
- { TR_SLAY_EVIL, GF_HOLY_FIRE },
- { TR_KILL_EVIL, GF_HOLY_FIRE },
+ { TR_BRAND_ACID, AttributeType::ACID },
+ { TR_BRAND_FIRE, AttributeType::FIRE },
+ { TR_BRAND_ELEC, AttributeType::ELEC },
+ { TR_BRAND_COLD, AttributeType::COLD },
+ { TR_BRAND_POIS, AttributeType::POIS },
+ { TR_SLAY_GOOD, AttributeType::HELL_FIRE },
+ { TR_KILL_GOOD, AttributeType::HELL_FIRE },
+ { TR_SLAY_EVIL, AttributeType::HOLY_FIRE },
+ { TR_KILL_EVIL, AttributeType::HOLY_FIRE },
};
for (size_t i = 0; i < sizeof(brand_convert_table) / sizeof(brand_convert_table[0]); ++i) {
const struct brand_convert_table_t *p = &brand_convert_table[i];
if (flgs.has(p->brand_type))
- effect_flags.set(p->effect_type);
+ attribute_flags.set(p->attribute);
}
if ((flgs.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
- effect_flags.set(GF_MANA);
+ attribute_flags.set(AttributeType::MANA);
}
- return effect_flags;
+ return attribute_flags;
}
#include "combat/combat-options-type.h"
#include "object-enchant/tr-flags.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
struct monster_type;
struct object_type;
MULTIPLY mult_slaying(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
MULTIPLY mult_brand(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
HIT_POINT calc_attack_damage_with_slay(player_type *player_ptr, object_type *o_ptr, HIT_POINT tdam, monster_type *m_ptr, combat_options mode, bool thrown);
-EffectFlags melee_effect_type(player_type *player_ptr, object_type *o_ptr, combat_options mode);
+AttributeFlags melee_attribute(player_type *player_ptr, object_type *o_ptr, combat_options mode);
--- /dev/null
+#pragma once
+#include "util/flag-group.h"
+
+enum class AttributeType : EFFECT_ID
+{
+ NONE = 0,
+ ELEC = 1, /*!< 魔法効果: 電撃*/
+ POIS = 2, /*!< 魔法効果: 毒*/
+ ACID = 3, /*!< 魔法効果: 酸*/
+ COLD = 4, /*!< 魔法効果: 冷気*/
+ FIRE = 5, /*!< 魔法効果: 火炎*/
+ PSY_SPEAR = 9, /*!< 魔法効果: 光の剣*/
+ MISSILE = 10, /*!< 魔法効果: 弱魔力*/
+ ARROW = 11, /*!< 魔法効果: 射撃*/
+ PLASMA = 12, /*!< 魔法効果: プラズマ*/
+ WATER = 14, /*!< 魔法効果: 水流*/
+ LITE = 15, /*!< 魔法効果: 閃光*/
+ DARK = 16, /*!< 魔法効果: 暗黒*/
+ LITE_WEAK = 17, /*!< 魔法効果: 弱光*/
+ DARK_WEAK = 18, /*!< 魔法効果: 弱暗*/
+ SHARDS = 20, /*!< 魔法効果: 破片*/
+ SOUND = 21, /*!< 魔法効果: 轟音*/
+ CONFUSION = 22, /*!< 魔法効果: 混乱*/
+ FORCE = 23, /*!< 魔法効果: フォース*/
+ INERTIAL = 24, /*!< 魔法効果: 遅鈍*/
+ MANA = 26, /*!< 魔法効果: 純粋魔力*/
+ METEOR = 27, /*!< 魔法効果: 隕石*/
+ ICE = 28, /*!< 魔法効果: 極寒*/
+ CHAOS = 30, /*!< 魔法効果: カオス*/
+ NETHER = 31, /*!< 魔法効果: 地獄*/
+ DISENCHANT = 32, /*!< 魔法効果: 劣化*/
+ NEXUS = 33, /*!< 魔法効果: 因果混乱*/
+ TIME = 34, /*!< 魔法効果: 時間逆転*/
+ GRAVITY = 35, /*!< 魔法効果: 重力*/
+ KILL_WALL = 40, /*!< 魔法効果: 岩石溶解*/
+ KILL_DOOR = 41, /*!< 魔法効果: ドア破壊*/
+ KILL_TRAP = 42, /*!< 魔法効果: トラップ破壊*/
+ MAKE_WALL = 45, /*!< 魔法効果: 壁生成 (現在未使用)*/
+ MAKE_DOOR = 46, /*!< 魔法効果: ドア生成*/
+ MAKE_TRAP = 47, /*!< 魔法効果: トラップ生成*/
+ MAKE_TREE = 48, /*!< 魔法効果: 森林生成*/
+ OLD_CLONE = 51, /*!< 魔法効果: クローン・モンスター*/
+ OLD_POLY = 52, /*!< 魔法効果: チェンジ・モンスター*/
+ OLD_HEAL = 53, /*!< 魔法効果: 回復モンスター*/
+ OLD_SPEED = 54, /*!< 魔法効果: スピード・モンスター*/
+ OLD_SLOW = 55, /*!< 魔法効果: スロウ・モンスター*/
+ OLD_CONF = 56, /*!< 魔法効果: パニック・モンスター*/
+ OLD_SLEEP = 57, /*!< 魔法効果: スリープ・モンスター*/
+ HYPODYNAMIA = 58, /*!< 魔法効果: 衰弱*/
+ AWAY_UNDEAD = 61, /*!< 魔法効果: アンデッド・アウェイ*/
+ AWAY_EVIL = 62, /*!< 魔法効果: 邪悪飛ばし*/
+ AWAY_ALL = 63, /*!< 魔法効果: テレポート・アウェイ*/
+ TURN_UNDEAD = 64, /*!< 魔法効果: アンデッド恐慌*/
+ TURN_EVIL = 65, /*!< 魔法効果: 邪悪恐慌*/
+ TURN_ALL = 66, /*!< 魔法効果: モンスター恐慌*/
+ DISP_UNDEAD = 67, /*!< 魔法効果: アンデッド退散*/
+ DISP_EVIL = 68, /*!< 魔法効果: 邪悪退散*/
+ DISP_ALL = 69, /*!< 魔法効果: モンスター退散*/
+ DISP_DEMON = 70, /*!< 魔法効果: 悪魔退散*/
+ DISP_LIVING = 71, /*!< 魔法効果: 生命退散*/
+ ROCKET = 72, /*!< 魔法効果: ロケット*/
+ NUKE = 73, /*!< 魔法効果: 放射性廃棄物*/
+ MAKE_RUNE_PROTECTION = 74, /*!< 魔法効果: 守りのルーン生成*/
+ STASIS = 75, /*!< 魔法効果: モンスター拘束*/
+ STONE_WALL = 76, /*!< 魔法効果: 壁生成*/
+ DEATH_RAY = 77, /*!< 魔法効果: 死の光線*/
+ STUN = 78, /*!< 魔法効果: 朦朧*/
+ HOLY_FIRE = 79, /*!< 魔法効果: 聖光*/
+ HELL_FIRE = 80, /*!< 魔法効果: 地獄の劫火*/
+ DISINTEGRATE = 81, /*!< 魔法効果: 分解*/
+ CHARM = 82, /*!< 魔法効果: モンスター魅了*/
+ CONTROL_UNDEAD = 83, /*!< 魔法効果: アンデッド支配*/
+ CONTROL_ANIMAL = 84, /*!< 魔法効果: 動物支配*/
+ PSI = 85, /*!< 魔法効果: サイキック攻撃*/
+ PSI_DRAIN = 86, /*!< 魔法効果: 精神吸収*/
+ TELEKINESIS = 87, /*!< 魔法効果: テレキシネス*/
+ JAM_DOOR = 88, /*!< 魔法効果: 施錠*/
+ DOMINATION = 89, /*!< 魔法効果: 精神支配*/
+ DISP_GOOD = 90, /*!< 魔法効果: 善良退散*/
+ DRAIN_MANA = 91, /*!< 魔法効果: 魔力吸収*/
+ MIND_BLAST = 92, /*!< 魔法効果: 精神攻撃*/
+ BRAIN_SMASH = 93, /*!< 魔法効果: 脳攻撃*/
+ CAUSE_1 = 94, /*!< 魔法効果: 軽傷の呪い*/
+ CAUSE_2 = 95, /*!< 魔法効果: 重傷の呪い*/
+ CAUSE_3 = 96, /*!< 魔法効果: 致命傷の呪い*/
+ CAUSE_4 = 97, /*!< 魔法効果: 秘孔を突く*/
+ HAND_DOOM = 98, /*!< 魔法効果: 破滅の手*/
+ CAPTURE = 99, /*!< 魔法効果: 捕縛*/
+ ANIM_DEAD = 100, /*!< 魔法効果: 死者復活*/
+ CHARM_LIVING = 101, /*!< 魔法効果: 生命魅了*/
+ IDENTIFY = 102, /*!< 魔法効果: 鑑定*/
+ ATTACK = 103, /*!< 魔法効果: 白兵*/
+ ENGETSU = 104, /*!< 魔法効果: 円月*/
+ GENOCIDE = 105, /*!< 魔法効果: 抹殺*/
+ PHOTO = 106, /*!< 魔法効果: 撮影*/
+ CONTROL_DEMON = 107, /*!< 魔法効果: 悪魔支配*/
+ LAVA_FLOW = 108, /*!< 魔法効果: 溶岩噴出*/
+ BLOOD_CURSE = 109, /*!< 魔法効果: 血の呪い*/
+ SEEKER = 110, /*!< 魔法効果: シーカーレイ*/
+ SUPER_RAY = 111, /*!< 魔法効果: スーパーレイ*/
+ STAR_HEAL = 112, /*!< 魔法効果: 星の癒し*/
+ WATER_FLOW = 113, /*!< 魔法効果: 流水*/
+ CRUSADE = 114, /*!< 魔法効果: 聖戦*/
+ STASIS_EVIL = 115, /*!< 魔法効果: 邪悪拘束*/
+ WOUNDS = 116, /*!< 魔法効果: 創傷*/
+ E_GENOCIDE = 117, /*!< 魔法効果: 元素抹殺 */
+ VOID_MAGIC = 118, /*!< 魔法効果: 虚無 */
+ ABYSS = 119, /*!< 魔法効果: 深淵 */
+ HUNGRY = 120, /*!< 魔法効果: 空腹>*/
+ PLAYER_SHOOT = 121, /*!< 属性取得用: プレイヤーの射撃/投擲>*/
+ PLAYER_MELEE = 122, /*!< 属性取得用: プレイヤーの近接攻撃>*/
+ MAX /*!< 欠番を無視した最大サイズ (直上の値+1) */
+};
+
+
+/*! 属性フラグATTRIBUTEの集合を表すクラス */
+using AttributeFlags = FlagGroup<AttributeType, AttributeType::MAX>;
#include "core/player-update-types.h"
#include "dungeon/dungeon-flag-types.h"
#include "dungeon/dungeon.h"
+#include "effect/attribute-types.h"
#include "effect/effect-characteristics.h"
#include "effect/effect-processor.h" // 暫定、後で消す.
#include "floor/cave.h"
#include "monster/monster-update.h"
#include "player/special-defense-types.h"
#include "room/door-definition.h"
-#include "spell/spell-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/player-type-definition.h"
* Perhaps we should affect doors?
* </pre>
*/
-bool affect_feature(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ)
+bool affect_feature(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ)
{
floor_type *floor_ptr = player_ptr->current_floor_ptr;
grid_type *g_ptr = &floor_ptr->grid_array[y][x];
if (f_ptr->flags.has(FF::TREE)) {
concptr message;
switch (typ) {
- case GF_POIS:
- case GF_NUKE:
- case GF_DEATH_RAY:
+ case AttributeType::POIS:
+ case AttributeType::NUKE:
+ case AttributeType::DEATH_RAY:
message = _("枯れた", "was blasted.");
break;
- case GF_TIME:
+ case AttributeType::TIME:
message = _("縮んだ", "shrank.");
break;
- case GF_ACID:
+ case AttributeType::ACID:
message = _("溶けた", "melted.");
break;
- case GF_COLD:
- case GF_ICE:
+ case AttributeType::COLD:
+ case AttributeType::ICE:
message = _("凍り、砕け散った", "was frozen and smashed.");
break;
- case GF_FIRE:
- case GF_ELEC:
- case GF_PLASMA:
+ case AttributeType::FIRE:
+ case AttributeType::ELEC:
+ case AttributeType::PLASMA:
message = _("燃えた", "burns up!");
break;
- case GF_METEOR:
- case GF_CHAOS:
- case GF_MANA:
- case GF_SEEKER:
- case GF_SUPER_RAY:
- case GF_SHARDS:
- case GF_ROCKET:
- case GF_SOUND:
- case GF_DISENCHANT:
- case GF_FORCE:
- case GF_GRAVITY:
+ case AttributeType::METEOR:
+ case AttributeType::CHAOS:
+ case AttributeType::MANA:
+ case AttributeType::SEEKER:
+ case AttributeType::SUPER_RAY:
+ case AttributeType::SHARDS:
+ case AttributeType::ROCKET:
+ case AttributeType::SOUND:
+ case AttributeType::DISENCHANT:
+ case AttributeType::FORCE:
+ case AttributeType::GRAVITY:
message = _("粉砕された", "was crushed.");
break;
- case GF_VOID:
+ case AttributeType::VOID_MAGIC:
message = _("消滅した", "vanished.");
break;
default:
/* Analyze the type */
switch (typ) {
/* Ignore most effects */
- case GF_CAPTURE:
- case GF_HAND_DOOM:
- case GF_CAUSE_1:
- case GF_CAUSE_2:
- case GF_CAUSE_3:
- case GF_CAUSE_4:
- case GF_MIND_BLAST:
- case GF_BRAIN_SMASH:
- case GF_DRAIN_MANA:
- case GF_PSY_SPEAR:
- case GF_FORCE:
- case GF_HOLY_FIRE:
- case GF_HELL_FIRE:
- case GF_PSI:
- case GF_PSI_DRAIN:
- case GF_TELEKINESIS:
- case GF_DOMINATION:
- case GF_IDENTIFY:
- case GF_ATTACK:
- case GF_ACID:
- case GF_ELEC:
- case GF_COLD:
- case GF_ICE:
- case GF_FIRE:
- case GF_PLASMA:
- case GF_METEOR:
- case GF_CHAOS:
- case GF_MANA:
- case GF_SEEKER:
- case GF_SUPER_RAY: {
+ case AttributeType::CAPTURE:
+ case AttributeType::HAND_DOOM:
+ case AttributeType::CAUSE_1:
+ case AttributeType::CAUSE_2:
+ case AttributeType::CAUSE_3:
+ case AttributeType::CAUSE_4:
+ case AttributeType::MIND_BLAST:
+ case AttributeType::BRAIN_SMASH:
+ case AttributeType::DRAIN_MANA:
+ case AttributeType::PSY_SPEAR:
+ case AttributeType::FORCE:
+ case AttributeType::HOLY_FIRE:
+ case AttributeType::HELL_FIRE:
+ case AttributeType::PSI:
+ case AttributeType::PSI_DRAIN:
+ case AttributeType::TELEKINESIS:
+ case AttributeType::DOMINATION:
+ case AttributeType::IDENTIFY:
+ case AttributeType::ATTACK:
+ case AttributeType::ACID:
+ case AttributeType::ELEC:
+ case AttributeType::COLD:
+ case AttributeType::ICE:
+ case AttributeType::FIRE:
+ case AttributeType::PLASMA:
+ case AttributeType::METEOR:
+ case AttributeType::CHAOS:
+ case AttributeType::MANA:
+ case AttributeType::SEEKER:
+ case AttributeType::SUPER_RAY: {
break;
}
- case GF_KILL_TRAP: {
+ case AttributeType::KILL_TRAP: {
if (is_hidden_door(player_ptr, g_ptr)) {
disclose_grid(player_ptr, y, x);
if (known) {
obvious = true;
break;
}
- case GF_KILL_DOOR: {
+ case AttributeType::KILL_DOOR: {
if (is_trap(player_ptr, g_ptr->feat) || f_ptr->flags.has(FF::DOOR)) {
if (known) {
msg_print(_("まばゆい閃光が走った！", "There is a bright flash of light!"));
obvious = true;
break;
}
- case GF_JAM_DOOR: {
+ case AttributeType::JAM_DOOR: {
if (f_ptr->flags.has_not(FF::SPIKE))
break;
obvious = true;
break;
}
- case GF_KILL_WALL: {
+ case AttributeType::KILL_WALL: {
if (f_ptr->flags.has_not(FF::HURT_ROCK))
break;
player_ptr->update |= (PU_FLOW);
break;
}
- case GF_MAKE_DOOR: {
+ case AttributeType::MAKE_DOOR: {
if (!cave_naked_bold(player_ptr, y, x))
break;
if (player_bold(player_ptr, y, x))
obvious = true;
break;
}
- case GF_MAKE_TRAP: {
+ case AttributeType::MAKE_TRAP: {
place_trap(player_ptr, y, x);
break;
}
- case GF_MAKE_TREE: {
+ case AttributeType::MAKE_TREE: {
if (!cave_naked_bold(player_ptr, y, x))
break;
if (player_bold(player_ptr, y, x))
obvious = true;
break;
}
- case GF_MAKE_RUNE_PROTECTION: {
+ case AttributeType::MAKE_RUNE_PROTECTION: {
if (!cave_naked_bold(player_ptr, y, x))
break;
g_ptr->info |= CAVE_OBJECT;
lite_spot(player_ptr, y, x);
break;
}
- case GF_STONE_WALL: {
+ case AttributeType::STONE_WALL: {
if (!cave_naked_bold(player_ptr, y, x))
break;
if (player_bold(player_ptr, y, x))
cave_set_feat(player_ptr, y, x, feat_granite);
break;
}
- case GF_LAVA_FLOW: {
+ case AttributeType::LAVA_FLOW: {
if (f_ptr->flags.has(FF::PERMANENT))
break;
if (dam == 1) {
break;
}
- case GF_WATER_FLOW: {
+ case AttributeType::WATER_FLOW: {
if (f_ptr->flags.has(FF::PERMANENT))
break;
if (dam == 1) {
break;
}
- case GF_LITE_WEAK:
- case GF_LITE: {
+ case AttributeType::LITE_WEAK:
+ case AttributeType::LITE: {
if (d_info[player_ptr->dungeon_idx].flags.has(DF::DARKNESS))
break;
break;
}
- case GF_DARK_WEAK:
- case GF_DARK:
- case GF_ABYSS: {
+ case AttributeType::DARK_WEAK:
+ case AttributeType::DARK:
+ case AttributeType::ABYSS: {
bool do_dark = !player_ptr->phase_out && !g_ptr->is_mirror();
if (!do_dark)
break;
break;
}
- case GF_SHARDS:
- case GF_ROCKET: {
+ case AttributeType::SHARDS:
+ case AttributeType::ROCKET: {
if (g_ptr->is_mirror()) {
msg_print(_("鏡が割れた！", "The mirror was shattered!"));
sound(SOUND_GLASS);
remove_mirror(player_ptr, y, x);
- project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, GF_SHARDS,
+ project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, AttributeType::SHARDS,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI));
}
player_ptr->update |= (PU_FLOW);
break;
}
- case GF_SOUND: {
+ case AttributeType::SOUND: {
if (g_ptr->is_mirror() && player_ptr->lev < 40) {
msg_print(_("鏡が割れた！", "The mirror was shattered!"));
sound(SOUND_GLASS);
remove_mirror(player_ptr, y, x);
- project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, GF_SHARDS,
+ project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, AttributeType::SHARDS,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI));
}
player_ptr->update |= (PU_FLOW);
break;
}
- case GF_DISINTEGRATE: {
+ case AttributeType::DISINTEGRATE: {
if (g_ptr->is_mirror() || g_ptr->is_rune_protection() || g_ptr->is_rune_explosion())
remove_mirror(player_ptr, y, x);
player_ptr->update |= (PU_FLOW);
break;
}
+ default:
+ break;
}
lite_spot(player_ptr, y, x);
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct player_type;
-bool affect_feature(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ);
+bool affect_feature(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ);
#include "effect/effect-item.h"
#include "autopick/autopick.h"
+#include "effect/attribute-types.h"
#include "flavor/flavor-describer.h"
#include "flavor/object-flavor-types.h"
#include "floor/cave.h"
#include "object/object-mark-types.h"
#include "perception/object-perception.h"
#include "spell-kind/spells-perception.h"
-#include "spell/spell-types.h"
#include "sv-definition/sv-other-types.h"
#include "sv-definition/sv-scroll-types.h"
#include "system/floor-type-definition.h"
* @param typ 効果属性 / Type of damage to apply to monsters (and objects)
* @return 何か一つでも効力があればTRUEを返す / TRUE if any "effects" of the projection were observed, else FALSE
*/
-bool affect_item(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ)
+bool affect_item(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ)
{
grid_type *g_ptr = &player_ptr->current_floor_ptr->grid_array[y][x];
auto flags = object_flags(o_ptr);
bool is_artifact = o_ptr->is_artifact();
switch (typ) {
- case GF_ACID: {
+ case AttributeType::ACID: {
if (BreakerAcid().hates(o_ptr)) {
do_kill = true;
note_kill = _("融けてしまった！", (plural ? " melt!" : " melts!"));
break;
}
- case GF_ELEC: {
+ case AttributeType::ELEC: {
if (BreakerElec().hates(o_ptr)) {
do_kill = true;
note_kill = _("壊れてしまった！", (plural ? " are destroyed!" : " is destroyed!"));
break;
}
- case GF_FIRE: {
+ case AttributeType::FIRE: {
if (BreakerFire().hates(o_ptr)) {
do_kill = true;
note_kill = _("燃えてしまった！", (plural ? " burn up!" : " burns up!"));
break;
}
- case GF_COLD: {
+ case AttributeType::COLD: {
if (BreakerCold().hates(o_ptr)) {
note_kill = _("砕け散ってしまった！", (plural ? " shatter!" : " shatters!"));
do_kill = true;
break;
}
- case GF_PLASMA: {
+ case AttributeType::PLASMA: {
if (BreakerFire().hates(o_ptr)) {
do_kill = true;
note_kill = _("燃えてしまった！", (plural ? " burn up!" : " burns up!"));
break;
}
- case GF_METEOR: {
+ case AttributeType::METEOR: {
if (BreakerFire().hates(o_ptr)) {
do_kill = true;
note_kill = _("燃えてしまった！", (plural ? " burn up!" : " burns up!"));
break;
}
- case GF_ICE:
- case GF_SHARDS:
- case GF_FORCE:
- case GF_SOUND: {
+ case AttributeType::ICE:
+ case AttributeType::SHARDS:
+ case AttributeType::FORCE:
+ case AttributeType::SOUND: {
if (BreakerCold().hates(o_ptr)) {
note_kill = _("砕け散ってしまった！", (plural ? " shatter!" : " shatters!"));
do_kill = true;
break;
}
- case GF_MANA:
- case GF_SEEKER:
- case GF_SUPER_RAY: {
+ case AttributeType::MANA:
+ case AttributeType::SEEKER:
+ case AttributeType::SUPER_RAY: {
do_kill = true;
note_kill = _("壊れてしまった！", (plural ? " are destroyed!" : " is destroyed!"));
break;
}
- case GF_DISINTEGRATE: {
+ case AttributeType::DISINTEGRATE: {
do_kill = true;
note_kill = _("蒸発してしまった！", (plural ? " evaporate!" : " evaporates!"));
break;
}
- case GF_CHAOS: {
+ case AttributeType::CHAOS: {
do_kill = true;
note_kill = _("壊れてしまった！", (plural ? " are destroyed!" : " is destroyed!"));
if (flags.has(TR_RES_CHAOS))
ignore = true;
break;
}
- case GF_HOLY_FIRE:
- case GF_HELL_FIRE: {
+ case AttributeType::HOLY_FIRE:
+ case AttributeType::HELL_FIRE: {
if (o_ptr->is_cursed()) {
do_kill = true;
note_kill = _("壊れてしまった！", (plural ? " are destroyed!" : " is destroyed!"));
break;
}
- case GF_VOID: {
+ case AttributeType::VOID_MAGIC: {
do_kill = true;
note_kill = _("消滅してしまった！", (plural ? " vanish!" : " vanishes!"));
break;
}
- case GF_IDENTIFY: {
+ case AttributeType::IDENTIFY: {
identify_item(player_ptr, o_ptr);
autopick_alter_item(player_ptr, (-this_o_idx), false);
break;
}
- case GF_KILL_TRAP:
- case GF_KILL_DOOR: {
+ case AttributeType::KILL_TRAP:
+ case AttributeType::KILL_DOOR: {
if (o_ptr->tval != ItemKindType::CHEST)
break;
if (o_ptr->pval <= 0)
break;
}
- case GF_ANIM_DEAD: {
+ case AttributeType::ANIM_DEAD: {
if (o_ptr->tval != ItemKindType::CORPSE)
break;
is_item_affected = true;
break;
}
+ default:
+ break;
}
if (!do_kill)
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct player_type;
-bool affect_item(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ);
+bool affect_item(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ);
}
/*!
- * @brief モンスターボールで捕らえる効果(GF_CAPTURE)
+ * @brief モンスターボールで捕らえる効果(CAPTURE)
* @param player_ptr プレイヤー情報への参照ポインタ
* @param em_ptr 効果情報への参照ポインタ
* @return 効果発動結果
}
/*!
- * @brief モンスターへのPsi攻撃(GF_PSI)の効果を発動する
+ * @brief モンスターへのPsi攻撃(PSI)の効果を発動する
* @param player_ptr プレイヤーへの参照ポインタ
* @param em_ptr モンスター効果への参照ポインタ
* @return PROICESS_CONTINUE
}
/*!
- * @brief モンスターのPsi攻撃(GF_PSI_DRAIN)に対する耐性を発動する
+ * @brief モンスターのPsi攻撃(PSI_DRAIN)に対する耐性を発動する
* @param player_ptr プレイヤーへの参照ポインタ
* @param em_ptr モンスター効果への参照ポインタ
* @details
}
/*!
- * @brief モンスターへのPsi攻撃(GF_PSI_DRAIN)のダメージをMPに変換する
+ * @brief モンスターへのPsi攻撃(PSI_DRAIN)のダメージをMPに変換する
* @param player_ptr プレイヤーへの参照ポインタ
* @param em_ptr モンスター効果への参照ポインタ
*/
}
/*!
- * @brief モンスターへのPsi攻撃(GF_PSI_DRAIN)の効果を発動する
+ * @brief モンスターへのPsi攻撃(PSI_DRAIN)の効果を発動する
* @param player_ptr プレイヤーへの参照ポインタ
* @param em_ptr モンスター効果への参照ポインタ
* @return PROICESS_CONTINUE
}
/*!
- * @brief モンスターへのテレキネシス(GF_TELEKINESIS)の効果を発動する
+ * @brief モンスターへのテレキネシス(TELEKINESIS)の効果を発動する
* @param player_ptr プレイヤーへの参照ポインタ
* @param em_ptr モンスター効果への参照ポインタ
* @return PROICESS_CONTINUE
#include "monster/monster-status.h"
#include "player/player-damage.h"
#include "spell-kind/spells-genocide.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
*/
process_result switch_effects_monster(player_type *player_ptr, effect_monster_type *em_ptr)
{
- switch (em_ptr->effect_type) {
- case GF_PSY_SPEAR:
- case GF_MISSILE:
- case GF_ARROW:
- case GF_MANA:
- case GF_METEOR:
- case GF_BLOOD_CURSE:
- case GF_SEEKER:
- case GF_SUPER_RAY:
+ switch (em_ptr->attribute) {
+ case AttributeType::PSY_SPEAR:
+ case AttributeType::MISSILE:
+ case AttributeType::ARROW:
+ case AttributeType::MANA:
+ case AttributeType::METEOR:
+ case AttributeType::BLOOD_CURSE:
+ case AttributeType::SEEKER:
+ case AttributeType::SUPER_RAY:
return effect_monster_nothing(em_ptr);
- case GF_ACID:
+ case AttributeType::ACID:
return effect_monster_acid(player_ptr, em_ptr);
- case GF_ELEC:
+ case AttributeType::ELEC:
return effect_monster_elec(player_ptr, em_ptr);
- case GF_FIRE:
+ case AttributeType::FIRE:
return effect_monster_fire(player_ptr, em_ptr);
- case GF_COLD:
+ case AttributeType::COLD:
return effect_monster_cold(player_ptr, em_ptr);
- case GF_POIS:
+ case AttributeType::POIS:
return effect_monster_pois(player_ptr, em_ptr);
- case GF_NUKE:
+ case AttributeType::NUKE:
return effect_monster_nuke(player_ptr, em_ptr);
- case GF_HELL_FIRE:
+ case AttributeType::HELL_FIRE:
return effect_monster_hell_fire(player_ptr, em_ptr);
- case GF_HOLY_FIRE:
+ case AttributeType::HOLY_FIRE:
return effect_monster_holy_fire(player_ptr, em_ptr);
- case GF_PLASMA:
+ case AttributeType::PLASMA:
return effect_monster_plasma(player_ptr, em_ptr);
- case GF_NETHER:
+ case AttributeType::NETHER:
return effect_monster_nether(player_ptr, em_ptr);
- case GF_WATER:
+ case AttributeType::WATER:
return effect_monster_water(player_ptr, em_ptr);
- case GF_CHAOS:
+ case AttributeType::CHAOS:
return effect_monster_chaos(player_ptr, em_ptr);
- case GF_SHARDS:
+ case AttributeType::SHARDS:
return effect_monster_shards(player_ptr, em_ptr);
- case GF_ROCKET:
+ case AttributeType::ROCKET:
return effect_monster_rocket(player_ptr, em_ptr);
- case GF_SOUND:
+ case AttributeType::SOUND:
return effect_monster_sound(player_ptr, em_ptr);
- case GF_CONFUSION:
+ case AttributeType::CONFUSION:
return effect_monster_confusion(player_ptr, em_ptr);
- case GF_DISENCHANT:
+ case AttributeType::DISENCHANT:
return effect_monster_disenchant(player_ptr, em_ptr);
- case GF_NEXUS:
+ case AttributeType::NEXUS:
return effect_monster_nexus(player_ptr, em_ptr);
- case GF_FORCE:
+ case AttributeType::FORCE:
return effect_monster_force(player_ptr, em_ptr);
- case GF_INERTIAL:
+ case AttributeType::INERTIAL:
return effect_monster_inertial(player_ptr, em_ptr);
- case GF_TIME:
+ case AttributeType::TIME:
return effect_monster_time(player_ptr, em_ptr);
- case GF_GRAVITY:
+ case AttributeType::GRAVITY:
return effect_monster_gravity(player_ptr, em_ptr);
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
return effect_monster_disintegration(player_ptr, em_ptr);
- case GF_PSI:
+ case AttributeType::PSI:
return effect_monster_psi(player_ptr, em_ptr);
- case GF_PSI_DRAIN:
+ case AttributeType::PSI_DRAIN:
return effect_monster_psi_drain(player_ptr, em_ptr);
- case GF_TELEKINESIS:
+ case AttributeType::TELEKINESIS:
return effect_monster_telekinesis(player_ptr, em_ptr);
- case GF_DOMINATION:
+ case AttributeType::DOMINATION:
return effect_monster_domination(player_ptr, em_ptr);
- case GF_ICE:
+ case AttributeType::ICE:
return effect_monster_icee_bolt(player_ptr, em_ptr);
- case GF_HYPODYNAMIA:
+ case AttributeType::HYPODYNAMIA:
return effect_monster_hypodynamia(player_ptr, em_ptr);
- case GF_DEATH_RAY:
+ case AttributeType::DEATH_RAY:
return effect_monster_death_ray(player_ptr, em_ptr);
- case GF_OLD_POLY:
+ case AttributeType::OLD_POLY:
return effect_monster_old_poly(em_ptr);
- case GF_OLD_CLONE:
+ case AttributeType::OLD_CLONE:
return effect_monster_old_clone(player_ptr, em_ptr);
- case GF_STAR_HEAL:
+ case AttributeType::STAR_HEAL:
return effect_monster_star_heal(player_ptr, em_ptr);
- case GF_OLD_HEAL:
+ case AttributeType::OLD_HEAL:
return effect_monster_old_heal(player_ptr, em_ptr);
- case GF_OLD_SPEED:
+ case AttributeType::OLD_SPEED:
return effect_monster_old_speed(player_ptr, em_ptr);
- case GF_OLD_SLOW:
+ case AttributeType::OLD_SLOW:
return effect_monster_old_slow(player_ptr, em_ptr);
- case GF_OLD_SLEEP:
+ case AttributeType::OLD_SLEEP:
return effect_monster_old_sleep(player_ptr, em_ptr);
- case GF_STASIS_EVIL:
+ case AttributeType::STASIS_EVIL:
return effect_monster_stasis(em_ptr, true);
- case GF_STASIS:
+ case AttributeType::STASIS:
return effect_monster_stasis(em_ptr, false);
- case GF_CHARM:
+ case AttributeType::CHARM:
return effect_monster_charm(player_ptr, em_ptr);
- case GF_CONTROL_UNDEAD:
+ case AttributeType::CONTROL_UNDEAD:
return effect_monster_control_undead(player_ptr, em_ptr);
- case GF_CONTROL_DEMON:
+ case AttributeType::CONTROL_DEMON:
return effect_monster_control_demon(player_ptr, em_ptr);
- case GF_CONTROL_ANIMAL:
+ case AttributeType::CONTROL_ANIMAL:
return effect_monster_control_animal(player_ptr, em_ptr);
- case GF_CHARM_LIVING:
+ case AttributeType::CHARM_LIVING:
return effect_monster_charm_living(player_ptr, em_ptr);
- case GF_OLD_CONF:
+ case AttributeType::OLD_CONF:
return effect_monster_old_conf(player_ptr, em_ptr);
- case GF_STUN:
+ case AttributeType::STUN:
return effect_monster_stun(em_ptr);
- case GF_LITE_WEAK:
+ case AttributeType::LITE_WEAK:
return effect_monster_lite_weak(player_ptr, em_ptr);
- case GF_LITE:
+ case AttributeType::LITE:
return effect_monster_lite(player_ptr, em_ptr);
- case GF_DARK:
+ case AttributeType::DARK:
return effect_monster_dark(player_ptr, em_ptr);
- case GF_KILL_WALL:
+ case AttributeType::KILL_WALL:
return effect_monster_kill_wall(player_ptr, em_ptr);
- case GF_AWAY_UNDEAD:
+ case AttributeType::AWAY_UNDEAD:
return effect_monster_away_undead(player_ptr, em_ptr);
- case GF_AWAY_EVIL:
+ case AttributeType::AWAY_EVIL:
return effect_monster_away_evil(player_ptr, em_ptr);
- case GF_AWAY_ALL:
+ case AttributeType::AWAY_ALL:
return effect_monster_away_all(player_ptr, em_ptr);
- case GF_TURN_UNDEAD:
+ case AttributeType::TURN_UNDEAD:
return effect_monster_turn_undead(player_ptr, em_ptr);
- case GF_TURN_EVIL:
+ case AttributeType::TURN_EVIL:
return effect_monster_turn_evil(player_ptr, em_ptr);
- case GF_TURN_ALL:
+ case AttributeType::TURN_ALL:
return effect_monster_turn_all(em_ptr);
- case GF_DISP_UNDEAD:
+ case AttributeType::DISP_UNDEAD:
return effect_monster_disp_undead(player_ptr, em_ptr);
- case GF_DISP_EVIL:
+ case AttributeType::DISP_EVIL:
return effect_monster_disp_evil(player_ptr, em_ptr);
- case GF_DISP_GOOD:
+ case AttributeType::DISP_GOOD:
return effect_monster_disp_good(player_ptr, em_ptr);
- case GF_DISP_LIVING:
+ case AttributeType::DISP_LIVING:
return effect_monster_disp_living(em_ptr);
- case GF_DISP_DEMON:
+ case AttributeType::DISP_DEMON:
return effect_monster_disp_demon(player_ptr, em_ptr);
- case GF_DISP_ALL:
+ case AttributeType::DISP_ALL:
return effect_monster_disp_all(em_ptr);
- case GF_DRAIN_MANA:
+ case AttributeType::DRAIN_MANA:
return effect_monster_drain_mana(player_ptr, em_ptr);
- case GF_MIND_BLAST:
+ case AttributeType::MIND_BLAST:
return effect_monster_mind_blast(player_ptr, em_ptr);
- case GF_BRAIN_SMASH:
+ case AttributeType::BRAIN_SMASH:
return effect_monster_brain_smash(player_ptr, em_ptr);
- case GF_CAUSE_1:
+ case AttributeType::CAUSE_1:
return effect_monster_curse_1(em_ptr);
- case GF_CAUSE_2:
+ case AttributeType::CAUSE_2:
return effect_monster_curse_2(em_ptr);
- case GF_CAUSE_3:
+ case AttributeType::CAUSE_3:
return effect_monster_curse_3(em_ptr);
- case GF_CAUSE_4:
+ case AttributeType::CAUSE_4:
return effect_monster_curse_4(em_ptr);
- case GF_HAND_DOOM:
+ case AttributeType::HAND_DOOM:
return effect_monster_hand_doom(em_ptr);
- case GF_CAPTURE:
+ case AttributeType::CAPTURE:
return effect_monster_capture(player_ptr, em_ptr);
- case GF_ATTACK:
+ case AttributeType::ATTACK:
return (process_result)do_cmd_attack(player_ptr, em_ptr->y, em_ptr->x, i2enum<combat_options>(em_ptr->dam));
- case GF_ENGETSU:
+ case AttributeType::ENGETSU:
return effect_monster_engetsu(player_ptr, em_ptr);
- case GF_GENOCIDE:
+ case AttributeType::GENOCIDE:
return effect_monster_genocide(player_ptr, em_ptr);
- case GF_PHOTO:
+ case AttributeType::PHOTO:
return effect_monster_photo(player_ptr, em_ptr);
- case GF_CRUSADE:
+ case AttributeType::CRUSADE:
return effect_monster_crusade(player_ptr, em_ptr);
- case GF_WOUNDS:
+ case AttributeType::WOUNDS:
return effect_monster_wounds(em_ptr);
- case GF_E_GENOCIDE:
+ case AttributeType::E_GENOCIDE:
return effect_monster_elemental_genocide(player_ptr, em_ptr);
- case GF_VOID:
+ case AttributeType::VOID_MAGIC:
return effect_monster_void(player_ptr, em_ptr);
- case GF_ABYSS:
+ case AttributeType::ABYSS:
return effect_monster_abyss(player_ptr, em_ptr);
default: {
em_ptr->skipped = true;
* @param y 目標y座標 / Target y location (or location to travel "towards")
* @param x 目標x座標 / Target x location (or location to travel "towards")
* @param dam 基本威力 / Base damage roll to apply to affected monsters (or player)
- * @param effect_type 効果属性 / Type of damage to apply to monsters (and objects)
+ * @param attribute 効果属性 / Type of damage to apply to monsters (and objects)
* @param flag 効果フラグ
* @param see_s_msg TRUEならばメッセージを表示する
*/
-static void substitute_effect_monster(effect_monster_type *em_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID effect_type, BIT_FLAGS flag, bool see_s_msg)
+static void substitute_effect_monster(effect_monster_type *em_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType attribute, BIT_FLAGS flag, bool see_s_msg)
{
em_ptr->who = who;
em_ptr->r = r;
em_ptr->y = y;
em_ptr->x = x;
em_ptr->dam = dam;
- em_ptr->effect_type = effect_type;
+ em_ptr->attribute = attribute;
em_ptr->flag = flag;
em_ptr->see_s_msg = see_s_msg;
}
* @param y 目標y座標 / Target y location (or location to travel "towards")
* @param x 目標x座標 / Target x location (or location to travel "towards")
* @param dam 基本威力 / Base damage roll to apply to affected monsters (or player)
- * @param effect_type 効果属性 / Type of damage to apply to monsters (and objects)
+ * @param attribute 効果属性 / Type of damage to apply to monsters (and objects)
* @param flag 効果フラグ
* @param see_s_msg TRUEならばメッセージを表示する
*/
-effect_monster_type *initialize_effect_monster(player_type *player_ptr, effect_monster_type *em_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID effect_type, BIT_FLAGS flag, bool see_s_msg)
+effect_monster_type *initialize_effect_monster(player_type *player_ptr, effect_monster_type *em_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType attribute, BIT_FLAGS flag, bool see_s_msg)
{
- substitute_effect_monster(em_ptr, who, r, y, x, dam, effect_type, flag, see_s_msg);
+ substitute_effect_monster(em_ptr, who, r, y, x, dam, attribute, flag, see_s_msg);
floor_type *floor_ptr = player_ptr->current_floor_ptr;
em_ptr->g_ptr = &floor_ptr->grid_array[em_ptr->y][em_ptr->x];
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
struct grid_type;;
struct monster_type;
POSITION y;
POSITION x;
HIT_POINT dam;
- EFFECT_ID effect_type;
+ AttributeType attribute;
BIT_FLAGS flag;
bool see_s_msg;
} effect_monster_type;
struct player_type;
effect_monster_type *initialize_effect_monster(player_type *player_ptr, effect_monster_type *em_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x,
- HIT_POINT dam, EFFECT_ID effect_type, BIT_FLAGS flag, bool see_s_msg);
+ HIT_POINT dam, AttributeType attribute, BIT_FLAGS flag, bool see_s_msg);
#include "spell-kind/blood-curse.h"
#include "spell-kind/spells-polymorph.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spells-effect-util.h"
#include "sv-definition/sv-other-types.h"
#include "system/floor-type-definition.h"
if (em_ptr->who || em_ptr->g_ptr->m_idx != player_ptr->riding)
return PROCESS_TRUE;
- switch (em_ptr->effect_type) {
- case GF_OLD_HEAL:
- case GF_OLD_SPEED:
- case GF_STAR_HEAL:
+ switch (em_ptr->attribute) {
+ case AttributeType::OLD_HEAL:
+ case AttributeType::OLD_SPEED:
+ case AttributeType::STAR_HEAL:
return PROCESS_TRUE;
- case GF_OLD_SLOW:
- case GF_OLD_SLEEP:
- case GF_OLD_CLONE:
- case GF_OLD_CONF:
- case GF_OLD_POLY:
- case GF_GENOCIDE:
- case GF_E_GENOCIDE:
+ case AttributeType::OLD_SLOW:
+ case AttributeType::OLD_SLEEP:
+ case AttributeType::OLD_CLONE:
+ case AttributeType::OLD_CONF:
+ case AttributeType::OLD_POLY:
+ case AttributeType::GENOCIDE:
+ case AttributeType::E_GENOCIDE:
return PROCESS_CONTINUE;
default:
break;
return result;
}
- if (none_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL) || em_ptr->effect_type == GF_OLD_CLONE || em_ptr->effect_type == GF_STAR_HEAL
- || em_ptr->effect_type == GF_OLD_HEAL || em_ptr->effect_type == GF_OLD_SPEED || em_ptr->effect_type == GF_CAPTURE || em_ptr->effect_type == GF_PHOTO)
+ if (none_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL) || em_ptr->attribute == AttributeType::OLD_CLONE
+ || em_ptr->attribute == AttributeType::STAR_HEAL || em_ptr->attribute == AttributeType::OLD_HEAL || em_ptr->attribute == AttributeType::OLD_SPEED
+ || em_ptr->attribute == AttributeType::CAPTURE || em_ptr->attribute == AttributeType::PHOTO)
return switch_effects_monster(player_ptr, em_ptr);
- if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL) && (em_ptr->effect_type == GF_ARROW))
+ if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL) && (em_ptr->attribute == AttributeType::ARROW))
return switch_effects_monster(player_ptr, em_ptr);
em_ptr->note = _("には完全な耐性がある！", " is immune.");
if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
em_ptr->r_ptr->r_flagsr |= (RFR_RES_ALL);
- if (em_ptr->effect_type == GF_LITE_WEAK || em_ptr->effect_type == GF_KILL_WALL)
+ if (em_ptr->attribute == AttributeType::LITE_WEAK || em_ptr->attribute == AttributeType::KILL_WALL)
em_ptr->skipped = true;
return PROCESS_CONTINUE;
if (em_ptr->who > 0)
monster_gain_exp(player_ptr, em_ptr->who, em_ptr->m_ptr->r_idx);
- monster_death(player_ptr, em_ptr->g_ptr->m_idx, false, em_ptr->effect_type);
+ monster_death(player_ptr, em_ptr->g_ptr->m_idx, false, em_ptr->attribute);
delete_monster_idx(player_ptr, em_ptr->g_ptr->m_idx);
if (sad)
msg_print(_("少し悲しい気分がした。", "You feel sad for a moment."));
static bool deal_effect_damage_from_player(player_type *player_ptr, effect_monster_type *em_ptr)
{
bool fear = false;
- MonsterDamageProcessor mdp(player_ptr, em_ptr->g_ptr->m_idx, em_ptr->dam, &fear, em_ptr->effect_type);
+ MonsterDamageProcessor mdp(player_ptr, em_ptr->g_ptr->m_idx, em_ptr->dam, &fear, em_ptr->attribute);
if (mdp.mon_take_hit(em_ptr->note_dies))
return true;
*/
static void deal_effect_damage_to_monster(player_type *player_ptr, effect_monster_type *em_ptr)
{
- if (em_ptr->effect_type == GF_DRAIN_MANA)
+ if (em_ptr->attribute == AttributeType::DRAIN_MANA)
return;
// モンスターによる効果
if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags1 & RF1_QUESTOR) || (player_ptr->riding && (em_ptr->g_ptr->m_idx == player_ptr->riding)))
em_ptr->do_polymorph = false;
- if (((em_ptr->r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) || (em_ptr->r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out && (em_ptr->who > 0)
- && (em_ptr->dam > em_ptr->m_ptr->hp))
+ if (((em_ptr->r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) || (em_ptr->r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out && (em_ptr->who > 0) && (em_ptr->dam > em_ptr->m_ptr->hp))
em_ptr->dam = em_ptr->m_ptr->hp;
}
static void effect_damage_gives_bad_status(player_type *player_ptr, effect_monster_type *em_ptr)
{
int tmp_damage = em_ptr->dam;
- em_ptr->dam = mon_damage_mod(player_ptr, em_ptr->m_ptr, em_ptr->dam, (bool)(em_ptr->effect_type == GF_PSY_SPEAR));
+ em_ptr->dam = mon_damage_mod(player_ptr, em_ptr->m_ptr, em_ptr->dam, (bool)(em_ptr->attribute == AttributeType::PSY_SPEAR));
if ((tmp_damage > 0) && (em_ptr->dam == 0) && em_ptr->seen)
em_ptr->note = _("はダメージを受けていない。", " is unharmed.");
affected_monster_prevents_bad_status(player_ptr, em_ptr);
effect_damage_gives_bad_status(player_ptr, em_ptr);
deal_effect_damage_to_monster(player_ptr, em_ptr);
- if ((em_ptr->effect_type == GF_BLOOD_CURSE) && one_in_(4))
+ if ((em_ptr->attribute == AttributeType::BLOOD_CURSE) && one_in_(4))
blood_curse_to_enemy(player_ptr, em_ptr->who);
}
* @param y 目標y座標 / Target y location (or location to travel "towards")
* @param x 目標x座標 / Target x location (or location to travel "towards")
* @param dam 基本威力 / Base damage roll to apply to affected monsters (or player)
- * @param effect_type 効果属性 / Type of damage to apply to monsters (and objects)
+ * @param attribute 効果属性 / Type of damage to apply to monsters (and objects)
* @param flag 効果フラグ
* @param see_s_msg TRUEならばメッセージを表示する
* @return 何か一つでも効力があればTRUEを返す / TRUE if any "effects" of the projection were observed, else FALSE
* 3.ペット及び撮影による事後効果
*/
bool affect_monster(
- player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID effect_type, BIT_FLAGS flag, bool see_s_msg)
+ player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType attribute, BIT_FLAGS flag, bool see_s_msg)
{
effect_monster_type tmp_effect;
- effect_monster_type *em_ptr = initialize_effect_monster(player_ptr, &tmp_effect, who, r, y, x, dam, effect_type, flag, see_s_msg);
+ effect_monster_type *em_ptr = initialize_effect_monster(player_ptr, &tmp_effect, who, r, y, x, dam, attribute, flag, see_s_msg);
make_description_of_affecred_monster(player_ptr, em_ptr);
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
struct player_type;
-bool affect_monster(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ, BIT_FLAGS flag, bool see_s_msg);
+bool affect_monster(player_type *player_ptr, MONSTER_IDX who, POSITION r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ, BIT_FLAGS flag, bool see_s_msg);
#include "effect/effect-player-spirit.h"
#include "effect/effect-player-util.h"
#include "player/player-damage.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
/*!
*/
void switch_effects_player(player_type *player_ptr, effect_player_type *ep_ptr)
{
- switch (ep_ptr->effect_type) {
- case GF_ACID:
+ switch (ep_ptr->attribute) {
+ case AttributeType::ACID:
effect_player_elements(player_ptr, ep_ptr, _("酸で攻撃された！", "You are hit by acid!"), acid_dam);
return;
- case GF_FIRE:
+ case AttributeType::FIRE:
effect_player_elements(player_ptr, ep_ptr, _("火炎で攻撃された！", "You are hit by fire!"), fire_dam);
return;
- case GF_COLD:
+ case AttributeType::COLD:
effect_player_elements(player_ptr, ep_ptr, _("冷気で攻撃された！", "You are hit by cold!"), cold_dam);
return;
- case GF_ELEC:
+ case AttributeType::ELEC:
effect_player_elements(player_ptr, ep_ptr, _("電撃で攻撃された！", "You are hit by lightning!"), elec_dam);
return;
- case GF_POIS:
+ case AttributeType::POIS:
effect_player_poison(player_ptr, ep_ptr);
return;
- case GF_NUKE:
+ case AttributeType::NUKE:
effect_player_nuke(player_ptr, ep_ptr);
return;
- case GF_MISSILE:
+ case AttributeType::MISSILE:
effect_player_missile(player_ptr, ep_ptr);
return;
- case GF_HOLY_FIRE:
+ case AttributeType::HOLY_FIRE:
effect_player_holy_fire(player_ptr, ep_ptr);
return;
- case GF_HELL_FIRE:
+ case AttributeType::HELL_FIRE:
effect_player_hell_fire(player_ptr, ep_ptr);
return;
- case GF_ARROW:
+ case AttributeType::ARROW:
effect_player_arrow(player_ptr, ep_ptr);
return;
- case GF_PLASMA:
+ case AttributeType::PLASMA:
effect_player_plasma(player_ptr, ep_ptr);
return;
- case GF_NETHER:
+ case AttributeType::NETHER:
effect_player_nether(player_ptr, ep_ptr);
return;
- case GF_WATER:
+ case AttributeType::WATER:
effect_player_water(player_ptr, ep_ptr);
return;
- case GF_CHAOS:
+ case AttributeType::CHAOS:
effect_player_chaos(player_ptr, ep_ptr);
return;
- case GF_SHARDS:
+ case AttributeType::SHARDS:
effect_player_shards(player_ptr, ep_ptr);
return;
- case GF_SOUND:
+ case AttributeType::SOUND:
effect_player_sound(player_ptr, ep_ptr);
return;
- case GF_CONFUSION:
+ case AttributeType::CONFUSION:
effect_player_confusion(player_ptr, ep_ptr);
return;
- case GF_DISENCHANT:
+ case AttributeType::DISENCHANT:
effect_player_disenchant(player_ptr, ep_ptr);
return;
- case GF_NEXUS:
+ case AttributeType::NEXUS:
effect_player_nexus(player_ptr, ep_ptr);
return;
- case GF_FORCE:
+ case AttributeType::FORCE:
effect_player_force(player_ptr, ep_ptr);
return;
- case GF_ROCKET:
+ case AttributeType::ROCKET:
effect_player_rocket(player_ptr, ep_ptr);
return;
- case GF_INERTIAL:
+ case AttributeType::INERTIAL:
effect_player_inertial(player_ptr, ep_ptr);
return;
- case GF_LITE:
+ case AttributeType::LITE:
effect_player_lite(player_ptr, ep_ptr);
return;
- case GF_DARK:
+ case AttributeType::DARK:
effect_player_dark(player_ptr, ep_ptr);
return;
- case GF_TIME:
+ case AttributeType::TIME:
effect_player_time(player_ptr, ep_ptr);
return;
- case GF_GRAVITY:
+ case AttributeType::GRAVITY:
effect_player_gravity(player_ptr, ep_ptr);
return;
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
effect_player_disintegration(player_ptr, ep_ptr);
return;
- case GF_OLD_HEAL:
+ case AttributeType::OLD_HEAL:
effect_player_old_heal(player_ptr, ep_ptr);
return;
- case GF_OLD_SPEED:
+ case AttributeType::OLD_SPEED:
effect_player_old_speed(player_ptr, ep_ptr);
return;
- case GF_OLD_SLOW:
+ case AttributeType::OLD_SLOW:
effect_player_old_slow(player_ptr);
return;
- case GF_OLD_SLEEP:
+ case AttributeType::OLD_SLEEP:
effect_player_old_sleep(player_ptr, ep_ptr);
return;
- case GF_MANA:
- case GF_SEEKER:
- case GF_SUPER_RAY:
+ case AttributeType::MANA:
+ case AttributeType::SEEKER:
+ case AttributeType::SUPER_RAY:
effect_player_mana(player_ptr, ep_ptr);
return;
- case GF_PSY_SPEAR:
+ case AttributeType::PSY_SPEAR:
effect_player_psy_spear(player_ptr, ep_ptr);
return;
- case GF_METEOR:
+ case AttributeType::METEOR:
effect_player_meteor(player_ptr, ep_ptr);
return;
- case GF_ICE:
+ case AttributeType::ICE:
effect_player_icee(player_ptr, ep_ptr);
return;
- case GF_DEATH_RAY:
+ case AttributeType::DEATH_RAY:
effect_player_death_ray(player_ptr, ep_ptr);
return;
- case GF_DRAIN_MANA:
+ case AttributeType::DRAIN_MANA:
effect_player_drain_mana(player_ptr, ep_ptr);
return;
- case GF_MIND_BLAST:
+ case AttributeType::MIND_BLAST:
effect_player_mind_blast(player_ptr, ep_ptr);
return;
- case GF_BRAIN_SMASH:
+ case AttributeType::BRAIN_SMASH:
effect_player_brain_smash(player_ptr, ep_ptr);
return;
- case GF_CAUSE_1:
+ case AttributeType::CAUSE_1:
effect_player_curse_1(player_ptr, ep_ptr);
return;
- case GF_CAUSE_2:
+ case AttributeType::CAUSE_2:
effect_player_curse_2(player_ptr, ep_ptr);
return;
- case GF_CAUSE_3:
+ case AttributeType::CAUSE_3:
effect_player_curse_3(player_ptr, ep_ptr);
return;
- case GF_CAUSE_4:
+ case AttributeType::CAUSE_4:
effect_player_curse_4(player_ptr, ep_ptr);
return;
- case GF_HAND_DOOM:
+ case AttributeType::HAND_DOOM:
effect_player_hand_doom(player_ptr, ep_ptr);
return;
default: {
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct monster_type;
typedef struct effect_player_type {
MONSTER_IDX who;
HIT_POINT dam;
- EFFECT_ID effect_type;
+ AttributeType attribute;
BIT_FLAGS flag;
} effect_player_type;
#include "realm/realm-hex-numbers.h"
#include "spell-realm/spells-crusade.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-util.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
* @param ep_ptr 初期化前の構造体
* @param who 魔法を唱えたモンスター (0ならプレイヤー自身)
* @param dam 基本威力
- * @param effect_type 効果属性
+ * @param attribute 効果属性
* @param flag 効果フラグ
* @param monspell 効果元のモンスター魔法ID
* @return 初期化後の構造体ポインタ
*/
-static effect_player_type *initialize_effect_player(effect_player_type *ep_ptr, MONSTER_IDX who, HIT_POINT dam, EFFECT_ID effect_type, BIT_FLAGS flag)
+static effect_player_type *initialize_effect_player(effect_player_type *ep_ptr, MONSTER_IDX who, HIT_POINT dam, AttributeType attribute, BIT_FLAGS flag)
{
ep_ptr->rlev = 0;
ep_ptr->m_ptr = nullptr;
ep_ptr->get_damage = 0;
ep_ptr->who = who;
ep_ptr->dam = dam;
- ep_ptr->effect_type = effect_type;
+ ep_ptr->attribute = attribute;
ep_ptr->flag = flag;
return ep_ptr;
}
t_x = player_ptr->x - 1 + randint1(3);
}
- (*project)(player_ptr, 0, 0, t_y, t_x, ep_ptr->dam, ep_ptr->effect_type, (PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE));
+ (*project)(player_ptr, 0, 0, t_y, t_x, ep_ptr->dam, ep_ptr->attribute, (PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE));
disturb(player_ptr, true, true);
return true;
}
* @param y 目標Y座標 / Target y location (or location to travel "towards")
* @param x 目標X座標 / Target x location (or location to travel "towards")
* @param dam 基本威力 / Base damage roll to apply to affected monsters (or player)
- * @param effect_type 効果属性 / Type of damage to apply to monsters (and objects)
+ * @param attribute 効果属性 / Type of damage to apply to monsters (and objects)
* @param flag 効果フラグ
* @param monspell 効果元のモンスター魔法ID
* @return 何か一つでも効力があればTRUEを返す / TRUE if any "effects" of the projection were observed, else FALSE
*/
-bool affect_player(MONSTER_IDX who, player_type *player_ptr, concptr who_name, int r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID effect_type,
+bool affect_player(MONSTER_IDX who, player_type *player_ptr, concptr who_name, int r, POSITION y, POSITION x, HIT_POINT dam, AttributeType attribute,
BIT_FLAGS flag, project_func project)
{
effect_player_type tmp_effect;
- auto *ep_ptr = initialize_effect_player(&tmp_effect, who, dam, effect_type, flag);
+ auto *ep_ptr = initialize_effect_player(&tmp_effect, who, dam, attribute, flag);
auto check_result = check_continue_player_effect(player_ptr, ep_ptr, y, x, project);
if (check_result != PROCESS_CONTINUE) {
return check_result == PROCESS_TRUE;
GAME_TEXT m_name_self[MAX_MONSTER_NAME];
monster_desc(player_ptr, m_name_self, ep_ptr->m_ptr, MD_PRON_VISIBLE | MD_POSSESSIVE | MD_OBJECTIVE);
msg_format(_("攻撃が%s自身を傷つけた！", "The attack of %s has wounded %s!"), ep_ptr->m_name, m_name_self);
- (*project)(player_ptr, 0, 0, ep_ptr->m_ptr->fy, ep_ptr->m_ptr->fx, ep_ptr->get_damage, GF_MISSILE, PROJECT_KILL);
+ (*project)(player_ptr, 0, 0, ep_ptr->m_ptr->fy, ep_ptr->m_ptr->fx, ep_ptr->get_damage, AttributeType::MISSILE, PROJECT_KILL);
if (player_ptr->tim_eyeeye) {
set_tim_eyeeye(player_ptr, player_ptr->tim_eyeeye - 5, true);
}
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct ProjectResult;
struct player_type;
using project_func = ProjectResult (*)(
- player_type *player_ptr, MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ, BIT_FLAGS flag);
+ player_type *player_ptr, MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ, BIT_FLAGS flag);
-bool affect_player(MONSTER_IDX who, player_type *player_ptr, concptr who_name, int r, POSITION y, POSITION x, HIT_POINT dam, EFFECT_ID typ, BIT_FLAGS flag,
+bool affect_player(MONSTER_IDX who, player_type *player_ptr, concptr who_name, int r, POSITION y, POSITION x, HIT_POINT dam, AttributeType typ, BIT_FLAGS flag,
project_func project);
#include "effect/effect-processor.h"
#include "core/stuff-handler.h"
+#include "effect/attribute-types.h"
#include "effect/effect-characteristics.h"
#include "effect/effect-feature.h"
#include "effect/effect-item.h"
#include "pet/pet-fall-off.h"
#include "player/player-status.h"
#include "spell/range-calc.h"
-#include "spell/spell-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
* @todo 似たような処理が山ほど並んでいる、何とかならないものか
* @todo 引数にそのまま再代入していてカオスすぎる。直すのは簡単ではない
*/
-ProjectResult project(player_type *player_ptr, const MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, const HIT_POINT dam, const EFFECT_ID typ,
- BIT_FLAGS flag)
+ProjectResult project(player_type *player_ptr, const MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, const HIT_POINT dam,
+ const AttributeType typ, BIT_FLAGS flag)
{
int dist;
POSITION y1;
}
switch (typ) {
- case GF_LITE:
- case GF_LITE_WEAK:
+ case AttributeType::LITE:
+ case AttributeType::LITE_WEAK:
if (breath || (flag & PROJECT_BEAM))
flag |= (PROJECT_LOS);
break;
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
flag |= (PROJECT_GRID);
if (breath || (flag & PROJECT_BEAM))
flag |= (PROJECT_DISI);
break;
+ default:
+ break;
}
/* Calculate the projection path */
path_n = projection_path(player_ptr, path_g, (project_length ? project_length : get_max_range(player_ptr)), y1, x1, y2, x2, flag);
handle_stuff(player_ptr);
- if (typ == GF_SEEKER) {
+ if (typ == AttributeType::SEEKER) {
int j;
int last_i = 0;
project_m_n = 0;
}
}
- if (affect_item(player_ptr, 0, 0, y, x, dam, GF_SEEKER))
+ if (affect_item(player_ptr, 0, 0, y, x, dam, AttributeType::SEEKER))
res.notice = true;
if (!player_ptr->current_floor_ptr->grid_array[y][x].is_mirror())
continue;
for (j = last_i; j <= i; j++) {
y = get_grid_y(path_g[j]);
x = get_grid_x(path_g[j]);
- if (affect_monster(player_ptr, 0, 0, y, x, dam, GF_SEEKER, flag, true))
+ if (affect_monster(player_ptr, 0, 0, y, x, dam, AttributeType::SEEKER, flag, true))
res.notice = true;
if (!who && (project_m_n == 1) && !jump && (player_ptr->current_floor_ptr->grid_array[project_m_y][project_m_x].m_idx > 0)) {
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->current_floor_ptr->grid_array[project_m_y][project_m_x].m_idx];
}
}
- (void)affect_feature(player_ptr, 0, 0, y, x, dam, GF_SEEKER);
+ (void)affect_feature(player_ptr, 0, 0, y, x, dam, AttributeType::SEEKER);
}
last_i = i;
POSITION py, px;
py = get_grid_y(path_g[i]);
px = get_grid_x(path_g[i]);
- if (affect_monster(player_ptr, 0, 0, py, px, dam, GF_SEEKER, flag, true))
+ if (affect_monster(player_ptr, 0, 0, py, px, dam, AttributeType::SEEKER, flag, true))
res.notice = true;
if (!who && (project_m_n == 1) && !jump) {
if (player_ptr->current_floor_ptr->grid_array[project_m_y][project_m_x].m_idx > 0) {
}
}
- (void)affect_feature(player_ptr, 0, 0, py, px, dam, GF_SEEKER);
+ (void)affect_feature(player_ptr, 0, 0, py, px, dam, AttributeType::SEEKER);
}
return res;
- } else if (typ == GF_SUPER_RAY) {
+ } else if (typ == AttributeType::SUPER_RAY) {
int j;
int second_step = 0;
project_m_n = 0;
}
}
- if (affect_item(player_ptr, 0, 0, y, x, dam, GF_SUPER_RAY))
+ if (affect_item(player_ptr, 0, 0, y, x, dam, AttributeType::SUPER_RAY))
res.notice = true;
if (!cave_has_flag_bold(player_ptr->current_floor_ptr, y, x, FF::PROJECT)) {
if (second_step)
for (j = 0; j <= i; j++) {
y = get_grid_y(path_g[j]);
x = get_grid_x(path_g[j]);
- (void)affect_feature(player_ptr, 0, 0, y, x, dam, GF_SUPER_RAY);
+ (void)affect_feature(player_ptr, 0, 0, y, x, dam, AttributeType::SUPER_RAY);
}
path_n = i;
second_step = i + 1;
path_n += projection_path(
player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y - 1, x - 1, flag);
- path_n
- += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y - 1, x, flag);
+ path_n += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y - 1, x, flag);
path_n += projection_path(
player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y - 1, x + 1, flag);
- path_n
- += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y, x - 1, flag);
- path_n
- += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y, x + 1, flag);
+ path_n += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y, x - 1, flag);
+ path_n += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y, x + 1, flag);
path_n += projection_path(
player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y + 1, x - 1, flag);
- path_n
- += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y + 1, x, flag);
+ path_n += projection_path(player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y + 1, x, flag);
path_n += projection_path(
player_ptr, &(path_g[path_n + 1]), (project_length ? project_length : get_max_range(player_ptr)), y, x, y + 1, x + 1, flag);
}
for (int i = 0; i < path_n; i++) {
POSITION py = get_grid_y(path_g[i]);
POSITION px = get_grid_x(path_g[i]);
- (void)affect_monster(player_ptr, 0, 0, py, px, dam, GF_SUPER_RAY, flag, true);
+ (void)affect_monster(player_ptr, 0, 0, py, px, dam, AttributeType::SUPER_RAY, flag, true);
if (!who && (project_m_n == 1) && !jump) {
if (player_ptr->current_floor_ptr->grid_array[project_m_y][project_m_x].m_idx > 0) {
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->current_floor_ptr->grid_array[project_m_y][project_m_x].m_idx];
}
}
- (void)affect_feature(player_ptr, 0, 0, py, px, dam, GF_SUPER_RAY);
+ (void)affect_feature(player_ptr, 0, 0, py, px, dam, AttributeType::SUPER_RAY);
}
return res;
continue;
switch (typ) {
- case GF_LITE:
- case GF_LITE_WEAK:
+ case AttributeType::LITE:
+ case AttributeType::LITE_WEAK:
if (!los(player_ptr, by, bx, y, x))
continue;
break;
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
if (!in_disintegration_range(player_ptr->current_floor_ptr, by, bx, y, x))
continue;
break;
if (grids <= 1) {
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->current_floor_ptr->grid_array[y][x].m_idx];
monster_race *ref_ptr = &r_info[m_ptr->r_idx];
- if ((flag & PROJECT_REFLECTABLE) && player_ptr->current_floor_ptr->grid_array[y][x].m_idx && (ref_ptr->flags2 & RF2_REFLECTING)
- && ((player_ptr->current_floor_ptr->grid_array[y][x].m_idx != player_ptr->riding) || !(flag & PROJECT_PLAYER)) && (!who || dist_hack > 1)
- && !one_in_(10)) {
+ if ((flag & PROJECT_REFLECTABLE) && player_ptr->current_floor_ptr->grid_array[y][x].m_idx && (ref_ptr->flags2 & RF2_REFLECTING) && ((player_ptr->current_floor_ptr->grid_array[y][x].m_idx != player_ptr->riding) || !(flag & PROJECT_PLAYER)) && (!who || dist_hack > 1) && !one_in_(10)) {
POSITION t_y, t_x;
int max_attempts = 10;
do {
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
//! project() の結果。
struct ProjectResult {
struct effect_player_type;
struct player_type;
ProjectResult project(
- player_type *player_ptr, const MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, const HIT_POINT dam, const EFFECT_ID typ,
+ player_type *player_ptr, const MONSTER_IDX who, POSITION rad, POSITION y, POSITION x, const HIT_POINT dam, const AttributeType typ,
BIT_FLAGS flag);
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
enum dap_type : int;
struct player_type;
#include "player/player-status-flags.h"
#include "player/player-status.h"
#include "room/rooms-builder.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
feature_type *old_f_ptr = &f_info[oldfeat];
if (old_f_ptr->flags.has(FF::GLASS) && w_ptr->character_dungeon) {
- project(player_ptr, PROJECT_WHO_GLASS_SHARDS, 1, y, x, std::min(floor_ptr->dun_level, 100) / 4, GF_SHARDS,
+ project(player_ptr, PROJECT_WHO_GLASS_SHARDS, 1, y, x, std::min(floor_ptr->dun_level, 100) / 4, AttributeType::SHARDS,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_HIDE | PROJECT_JUMP | PROJECT_NO_HANGEKI));
}
}
#include "spell-kind/spells-random.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/summon-types.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
case TRAP_TRAPS: {
msg_print(_("まばゆい閃光が走った！", "There is a bright flash of light!"));
/* Make some new traps */
- project(player_ptr, 0, 1, y, x, 0, GF_MAKE_TRAP, PROJECT_HIDE | PROJECT_JUMP | PROJECT_GRID);
+ project(player_ptr, 0, 1, y, x, 0, AttributeType::MAKE_TRAP, PROJECT_HIDE | PROJECT_JUMP | PROJECT_GRID);
break;
}
case TRAP_OPEN: {
msg_print(_("大音響と共にまわりの壁が崩れた！", "Suddenly, surrounding walls are opened!"));
- (void)project(player_ptr, 0, 3, y, x, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
- (void)project(player_ptr, 0, 3, y, x - 4, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
- (void)project(player_ptr, 0, 3, y, x + 4, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
+ (void)project(player_ptr, 0, 3, y, x, 0, AttributeType::DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
+ (void)project(player_ptr, 0, 3, y, x - 4, 0, AttributeType::DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
+ (void)project(player_ptr, 0, 3, y, x + 4, 0, AttributeType::DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE);
aggravate_monsters(player_ptr, 0);
break;
msg_print(_("突然壁から水が溢れ出した！ピラニアがいる！", "Suddenly, the room is filled with water with piranhas!"));
/* Water fills room */
- fire_ball_hide(player_ptr, GF_WATER_FLOW, 0, 1, 10);
+ fire_ball_hide(player_ptr, AttributeType::WATER_FLOW, 0, 1, 10);
/* Summon Piranhas */
num = 1 + player_ptr->current_floor_ptr->dun_level / 20;
*/
#include "gf-descriptions.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
-const named_num gf_desc[MAX_NAMED_NUM] =
-{
- {"GF_ELEC", GF_ELEC },
- {"GF_POIS", GF_POIS },
- {"GF_ACID", GF_ACID },
- {"GF_COLD", GF_COLD },
- {"GF_FIRE", GF_FIRE },
- {"GF_PSY_SPEAR", GF_PSY_SPEAR },
- {"GF_MISSILE", GF_MISSILE },
- {"GF_ARROW", GF_ARROW },
- {"GF_PLASMA", GF_PLASMA },
- {"GF_WATER", GF_WATER },
- {"GF_LITE", GF_LITE },
- {"GF_DARK", GF_DARK },
- {"GF_LITE_WEAK", GF_LITE_WEAK },
- {"GF_DARK_WEAK", GF_DARK_WEAK },
- {"GF_SHARDS", GF_SHARDS },
- {"GF_SOUND", GF_SOUND },
- {"GF_CONFUSION", GF_CONFUSION },
- {"GF_FORCE", GF_FORCE },
- {"GF_INERTIA", GF_INERTIAL },
- {"GF_MANA", GF_MANA },
- {"GF_METEOR", GF_METEOR },
- {"GF_ICE", GF_ICE },
- {"GF_CHAOS", GF_CHAOS },
- {"GF_NETHER", GF_NETHER },
- {"GF_DISENCHANT", GF_DISENCHANT },
- {"GF_NEXUS", GF_NEXUS },
- {"GF_TIME", GF_TIME },
- {"GF_GRAVITY", GF_GRAVITY },
- {"GF_KILL_WALL", GF_KILL_WALL },
- {"GF_KILL_DOOR", GF_KILL_DOOR },
- {"GF_KILL_TRAP", GF_KILL_TRAP },
- {"GF_MAKE_WALL", GF_MAKE_WALL },
- {"GF_MAKE_DOOR", GF_MAKE_DOOR },
- {"GF_MAKE_TRAP", GF_MAKE_TRAP },
- {"GF_MAKE_TREE", GF_MAKE_TREE },
- {"GF_OLD_CLONE", GF_OLD_CLONE },
- {"GF_OLD_POLY", GF_OLD_POLY },
- {"GF_OLD_HEAL", GF_OLD_HEAL },
- {"GF_OLD_SPEED", GF_OLD_SPEED },
- {"GF_OLD_SLOW", GF_OLD_SLOW },
- {"GF_OLD_CONF", GF_OLD_CONF },
- {"GF_OLD_SLEEP", GF_OLD_SLEEP },
- {"GF_HYPODYNAMIA", GF_HYPODYNAMIA },
- {"GF_AWAY_UNDEAD", GF_AWAY_UNDEAD },
- {"GF_AWAY_EVIL", GF_AWAY_EVIL },
- {"GF_AWAY_ALL", GF_AWAY_ALL },
- {"GF_TURN_UNDEAD", GF_TURN_UNDEAD },
- {"GF_TURN_EVIL", GF_TURN_EVIL },
- {"GF_TURN_ALL", GF_TURN_ALL },
- {"GF_DISP_UNDEAD", GF_DISP_UNDEAD },
- {"GF_DISP_EVIL", GF_DISP_EVIL },
- {"GF_DISP_ALL", GF_DISP_ALL },
- {"GF_DISP_DEMON", GF_DISP_DEMON },
- {"GF_DISP_LIVING", GF_DISP_LIVING },
- {"GF_ROCKET", GF_ROCKET },
- {"GF_NUKE", GF_NUKE },
- {"GF_MAKE_RUNE_PROTECTION", GF_MAKE_RUNE_PROTECTION},
- {"GF_STASIS", GF_STASIS },
- {"GF_STONE_WALL", GF_STONE_WALL },
- {"GF_DEATH_RAY", GF_DEATH_RAY },
- {"GF_STUN", GF_STUN },
- {"GF_HOLY_FIRE", GF_HOLY_FIRE },
- {"GF_HELL_FIRE", GF_HELL_FIRE },
- {"GF_DISINTEGRATE", GF_DISINTEGRATE },
- {"GF_CHARM", GF_CHARM },
- {"GF_CONTROL_UNDEAD", GF_CONTROL_UNDEAD },
- {"GF_CONTROL_ANIMAL", GF_CONTROL_ANIMAL },
- {"GF_PSI", GF_PSI },
- {"GF_PSI_DRAIN", GF_PSI_DRAIN },
- {"GF_TELEKINESIS", GF_TELEKINESIS },
- {"GF_JAM_DOOR", GF_JAM_DOOR },
- {"GF_DOMINATION", GF_DOMINATION },
- {"GF_DISP_GOOD", GF_DISP_GOOD },
- {"GF_DRAIN_MANA", GF_DRAIN_MANA },
- {"GF_MIND_BLAST", GF_MIND_BLAST },
- {"GF_BRAIN_SMASH", GF_BRAIN_SMASH },
- {"GF_CAUSE_1", GF_CAUSE_1 },
- {"GF_CAUSE_2", GF_CAUSE_2 },
- {"GF_CAUSE_3", GF_CAUSE_3 },
- {"GF_CAUSE_4", GF_CAUSE_4 },
- {"GF_HAND_DOOM", GF_HAND_DOOM },
- {"GF_CAPTURE", GF_CAPTURE },
- {"GF_ANIM_DEAD", GF_ANIM_DEAD },
- {"GF_CHARM_LIVING", GF_CHARM_LIVING },
- {"GF_IDENTIFY", GF_IDENTIFY },
- {"GF_ATTACK", GF_ATTACK },
- {"GF_ENGETSU", GF_ENGETSU },
- {"GF_GENOCIDE", GF_GENOCIDE },
- {"GF_PHOTO", GF_PHOTO },
- {"GF_CONTROL_DEMON", GF_CONTROL_DEMON },
- {"GF_LAVA_FLOW", GF_LAVA_FLOW },
- {"GF_BLOOD_CURSE", GF_BLOOD_CURSE },
- {"GF_SEEKER", GF_SEEKER },
- {"GF_SUPER_RAY", GF_SUPER_RAY },
- {"GF_STAR_HEAL", GF_STAR_HEAL },
- {"GF_WATER_FLOW", GF_WATER_FLOW },
- {"GF_CRUSADE", GF_CRUSADE },
- {"GF_STASIS_EVIL", GF_STASIS_EVIL },
- {"GF_WOUNDS", GF_WOUNDS },
- {"GF_E_GENOCIDE", GF_E_GENOCIDE },
- {"GF_VOID", GF_VOID },
- {"GF_ABYSS", GF_ABYSS },
- {"GF_HUNGRY", GF_HUNGRY },
+//clang-format off
+const named_num gf_desc[MAX_NAMED_NUM] = {
+ { "GF_ELEC", AttributeType::ELEC },
+ { "GF_POIS", AttributeType::POIS },
+ { "GF_ACID", AttributeType::ACID },
+ { "GF_COLD", AttributeType::COLD },
+ { "GF_FIRE", AttributeType::FIRE },
+ { "GF_PSY_SPEAR", AttributeType::PSY_SPEAR },
+ { "GF_MISSILE", AttributeType::MISSILE },
+ { "GF_ARROW", AttributeType::ARROW },
+ { "GF_PLASMA", AttributeType::PLASMA },
+ { "GF_WATER", AttributeType::WATER },
+ { "GF_LITE", AttributeType::LITE },
+ { "GF_DARK", AttributeType::DARK },
+ { "GF_LITE_WEAK", AttributeType::LITE_WEAK },
+ { "GF_DARK_WEAK", AttributeType::DARK_WEAK },
+ { "GF_SHARDS", AttributeType::SHARDS },
+ { "GF_SOUND", AttributeType::SOUND },
+ { "GF_CONFUSION", AttributeType::CONFUSION },
+ { "GF_FORCE", AttributeType::FORCE },
+ { "GF_INERTIA", AttributeType::INERTIAL },
+ { "GF_MANA", AttributeType::MANA },
+ { "GF_METEOR", AttributeType::METEOR },
+ { "GF_ICE", AttributeType::ICE },
+ { "GF_CHAOS", AttributeType::CHAOS },
+ { "GF_NETHER", AttributeType::NETHER },
+ { "GF_DISENCHANT", AttributeType::DISENCHANT },
+ { "GF_NEXUS", AttributeType::NEXUS },
+ { "GF_TIME", AttributeType::TIME },
+ { "GF_GRAVITY", AttributeType::GRAVITY },
+ { "GF_KILL_WALL", AttributeType::KILL_WALL },
+ { "GF_KILL_DOOR", AttributeType::KILL_DOOR },
+ { "GF_KILL_TRAP", AttributeType::KILL_TRAP },
+ { "GF_MAKE_WALL", AttributeType::MAKE_WALL },
+ { "GF_MAKE_DOOR", AttributeType::MAKE_DOOR },
+ { "GF_MAKE_TRAP", AttributeType::MAKE_TRAP },
+ { "GF_MAKE_TREE", AttributeType::MAKE_TREE },
+ { "GF_OLD_CLONE", AttributeType::OLD_CLONE },
+ { "GF_OLD_POLY", AttributeType::OLD_POLY },
+ { "GF_OLD_HEAL", AttributeType::OLD_HEAL },
+ { "GF_OLD_SPEED", AttributeType::OLD_SPEED },
+ { "GF_OLD_SLOW", AttributeType::OLD_SLOW },
+ { "GF_OLD_CONF", AttributeType::OLD_CONF },
+ { "GF_OLD_SLEEP", AttributeType::OLD_SLEEP },
+ { "GF_HYPODYNAMIA", AttributeType::HYPODYNAMIA },
+ { "GF_AWAY_UNDEAD", AttributeType::AWAY_UNDEAD },
+ { "GF_AWAY_EVIL", AttributeType::AWAY_EVIL },
+ { "GF_AWAY_ALL", AttributeType::AWAY_ALL },
+ { "GF_TURN_UNDEAD", AttributeType::TURN_UNDEAD },
+ { "GF_TURN_EVIL", AttributeType::TURN_EVIL },
+ { "GF_TURN_ALL", AttributeType::TURN_ALL },
+ { "GF_DISP_UNDEAD", AttributeType::DISP_UNDEAD },
+ { "GF_DISP_EVIL", AttributeType::DISP_EVIL },
+ { "GF_DISP_ALL", AttributeType::DISP_ALL },
+ { "GF_DISP_DEMON", AttributeType::DISP_DEMON },
+ { "GF_DISP_LIVING", AttributeType::DISP_LIVING },
+ { "GF_ROCKET", AttributeType::ROCKET },
+ { "GF_NUKE", AttributeType::NUKE },
+ { "GF_MAKE_RUNE_PROTECTION", AttributeType::MAKE_RUNE_PROTECTION },
+ { "GF_STASIS", AttributeType::STASIS },
+ { "GF_STONE_WALL", AttributeType::STONE_WALL },
+ { "GF_DEATH_RAY", AttributeType::DEATH_RAY },
+ { "GF_STUN", AttributeType::STUN },
+ { "GF_HOLY_FIRE", AttributeType::HOLY_FIRE },
+ { "GF_HELL_FIRE", AttributeType::HELL_FIRE },
+ { "GF_DISINTEGRATE", AttributeType::DISINTEGRATE },
+ { "GF_CHARM", AttributeType::CHARM },
+ { "GF_CONTROL_UNDEAD", AttributeType::CONTROL_UNDEAD },
+ { "GF_CONTROL_ANIMAL", AttributeType::CONTROL_ANIMAL },
+ { "GF_PSI", AttributeType::PSI },
+ { "GF_PSI_DRAIN", AttributeType::PSI_DRAIN },
+ { "GF_TELEKINESIS", AttributeType::TELEKINESIS },
+ { "GF_JAM_DOOR", AttributeType::JAM_DOOR },
+ { "GF_DOMINATION", AttributeType::DOMINATION },
+ { "GF_DISP_GOOD", AttributeType::DISP_GOOD },
+ { "GF_DRAIN_MANA", AttributeType::DRAIN_MANA },
+ { "GF_MIND_BLAST", AttributeType::MIND_BLAST },
+ { "GF_BRAIN_SMASH", AttributeType::BRAIN_SMASH },
+ { "GF_CAUSE_1", AttributeType::CAUSE_1 },
+ { "GF_CAUSE_2", AttributeType::CAUSE_2 },
+ { "GF_CAUSE_3", AttributeType::CAUSE_3 },
+ { "GF_CAUSE_4", AttributeType::CAUSE_4 },
+ { "GF_HAND_DOOM", AttributeType::HAND_DOOM },
+ { "GF_CAPTURE", AttributeType::CAPTURE },
+ { "GF_ANIM_DEAD", AttributeType::ANIM_DEAD },
+ { "GF_CHARM_LIVING", AttributeType::CHARM_LIVING },
+ { "GF_IDENTIFY", AttributeType::IDENTIFY },
+ { "GF_ATTACK", AttributeType::ATTACK },
+ { "GF_ENGETSU", AttributeType::ENGETSU },
+ { "GF_GENOCIDE", AttributeType::GENOCIDE },
+ { "GF_PHOTO", AttributeType::PHOTO },
+ { "GF_CONTROL_DEMON", AttributeType::CONTROL_DEMON },
+ { "GF_LAVA_FLOW", AttributeType::LAVA_FLOW },
+ { "GF_BLOOD_CURSE", AttributeType::BLOOD_CURSE },
+ { "GF_SEEKER", AttributeType::SEEKER },
+ { "GF_SUPER_RAY", AttributeType::SUPER_RAY },
+ { "GF_STAR_HEAL", AttributeType::STAR_HEAL },
+ { "GF_WATER_FLOW", AttributeType::WATER_FLOW },
+ { "GF_CRUSADE", AttributeType::CRUSADE },
+ { "GF_STASIS_EVIL", AttributeType::STASIS_EVIL },
+ { "GF_WOUNDS", AttributeType::WOUNDS },
+ { "GF_E_GENOCIDE", AttributeType::E_GENOCIDE },
+ { "GF_VOID", AttributeType::VOID_MAGIC },
+ { "GF_ABYSS", AttributeType::ABYSS },
+ { "GF_HUNGRY", AttributeType::HUNGRY },
};
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
#define MAX_NAMED_NUM 103
typedef struct named_num
{
concptr name; /* The name of this thing */
- int num; /* A number associated with it */
+ AttributeType num; /* A number associated with it */
} named_num;
extern const named_num gf_desc[MAX_NAMED_NUM];
if (!streq(gf_desc[i].name, buf + 2))
continue;
- gf_color[gf_desc[i].num] = (TERM_COLOR)quark_add(t);
+ gf_color[(int)gf_desc[i].num] = (TERM_COLOR)quark_add(t);
return 0;
}
#include "player-info/class-info.h"
#include "player-info/race-types.h"
#include "player/player-personality-types.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
*(mam_pp_ptr->dead) = true;
print_monster_dead_by_monster(player_ptr, mam_pp_ptr);
monster_gain_exp(player_ptr, mam_pp_ptr->who, mam_pp_ptr->m_ptr->r_idx);
- monster_death(player_ptr, mam_pp_ptr->m_idx, false, GF_NONE);
+ monster_death(player_ptr, mam_pp_ptr->m_idx, false, AttributeType::NONE);
delete_monster_idx(player_ptr, mam_pp_ptr->m_idx);
*(mam_pp_ptr->fear) = false;
return true;
#include "mspell/mspell-util.h"
#include "pet/pet-util.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
return;
POSITION rad = (ms_ptr->r_ptr->flags2 & RF2_POWERFUL) ? 3 : 2;
- if (!breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx, ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, 0, true)) {
+ if (!breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx, ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, AttributeType::NONE, true)) {
ms_ptr->ability_flags.reset(RF_ABILITY_BREATH_MASK);
return;
}
- if (ms_ptr->ability_flags.has(RF_ABILITY::BR_LITE)
- && !breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx, ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, GF_LITE, true)) {
+ if (ms_ptr->ability_flags.has(RF_ABILITY::BR_LITE) && !breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx,
+ ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, AttributeType::LITE, true)) {
ms_ptr->ability_flags.reset(RF_ABILITY::BR_LITE);
return;
}
- if (ms_ptr->ability_flags.has(RF_ABILITY::BR_DISI)
- && !breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx, ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, GF_DISINTEGRATE, true)) {
+ if (ms_ptr->ability_flags.has(RF_ABILITY::BR_DISI) && !breath_direct(player_ptr, ms_ptr->m_ptr->fy, ms_ptr->m_ptr->fx,
+ ms_ptr->t_ptr->fy, ms_ptr->t_ptr->fx, rad, AttributeType::DISINTEGRATE, true)) {
ms_ptr->ability_flags.reset(RF_ABILITY::BR_DISI);
}
}
case RaceBlowEffectType::NONE:
case RaceBlowEffectType::DR_MANA:
mam_ptr->damage = 0;
- mam_ptr->pt = GF_NONE;
+ mam_ptr->pt = AttributeType::NONE;
break;
case RaceBlowEffectType::SUPERHURT:
if ((randint1(mam_ptr->rlev * 2 + 250) > (mam_ptr->ac + 200)) || one_in_(13)) {
break;
case RaceBlowEffectType::POISON:
case RaceBlowEffectType::DISEASE:
- mam_ptr->pt = GF_POIS;
+ mam_ptr->pt = AttributeType::POIS;
break;
case RaceBlowEffectType::UN_BONUS:
case RaceBlowEffectType::UN_POWER:
- mam_ptr->pt = GF_DISENCHANT;
+ mam_ptr->pt = AttributeType::DISENCHANT;
break;
case RaceBlowEffectType::EAT_ITEM:
case RaceBlowEffectType::EAT_GOLD:
case RaceBlowEffectType::LOSE_ALL:
break;
case RaceBlowEffectType::ACID:
- mam_ptr->pt = GF_ACID;
+ mam_ptr->pt = AttributeType::ACID;
break;
case RaceBlowEffectType::ELEC:
- mam_ptr->pt = GF_ELEC;
+ mam_ptr->pt = AttributeType::ELEC;
break;
case RaceBlowEffectType::FIRE:
- mam_ptr->pt = GF_FIRE;
+ mam_ptr->pt = AttributeType::FIRE;
break;
case RaceBlowEffectType::COLD:
- mam_ptr->pt = GF_COLD;
+ mam_ptr->pt = AttributeType::COLD;
break;
case RaceBlowEffectType::CONFUSE:
- mam_ptr->pt = GF_CONFUSION;
+ mam_ptr->pt = AttributeType::CONFUSION;
break;
case RaceBlowEffectType::TERRIFY:
- mam_ptr->effect_type = BLOW_EFFECT_TYPE_FEAR;
+ mam_ptr->attribute = BLOW_EFFECT_TYPE_FEAR;
break;
case RaceBlowEffectType::PARALYZE:
- mam_ptr->effect_type = BLOW_EFFECT_TYPE_SLEEP;
+ mam_ptr->attribute = BLOW_EFFECT_TYPE_SLEEP;
break;
case RaceBlowEffectType::SHATTER:
mam_ptr->damage -= (mam_ptr->damage * ((mam_ptr->ac < 150) ? mam_ptr->ac : 150) / 250);
case RaceBlowEffectType::EXP_20:
case RaceBlowEffectType::EXP_40:
case RaceBlowEffectType::EXP_80:
- mam_ptr->pt = GF_NETHER;
+ mam_ptr->pt = AttributeType::NETHER;
break;
case RaceBlowEffectType::TIME:
- mam_ptr->pt = GF_TIME;
+ mam_ptr->pt = AttributeType::TIME;
break;
case RaceBlowEffectType::DR_LIFE:
- mam_ptr->pt = GF_HYPODYNAMIA;
- mam_ptr->effect_type = BLOW_EFFECT_TYPE_HEAL;
+ mam_ptr->pt = AttributeType::HYPODYNAMIA;
+ mam_ptr->attribute = BLOW_EFFECT_TYPE_HEAL;
break;
case RaceBlowEffectType::INERTIA:
- mam_ptr->pt = GF_INERTIAL;
+ mam_ptr->pt = AttributeType::INERTIAL;
break;
case RaceBlowEffectType::STUN:
- mam_ptr->pt = GF_SOUND;
+ mam_ptr->pt = AttributeType::SOUND;
break;
case RaceBlowEffectType::HUNGRY:
- mam_ptr->pt = GF_HUNGRY;
+ mam_ptr->pt = AttributeType::HUNGRY;
break;
case RaceBlowEffectType::FLAVOR:
// フレーバー打撃には何の効果もない。
- mam_ptr->pt = GF_NONE;
+ mam_ptr->pt = AttributeType::NONE;
break;
default:
- mam_ptr->pt = GF_NONE;
+ mam_ptr->pt = AttributeType::NONE;
break;
}
}
mam_type *initialize_mam_type(player_type *player_ptr, mam_type *mam_ptr, MONRACE_IDX m_idx, MONRACE_IDX t_idx)
{
- mam_ptr->effect_type = 0;
+ mam_ptr->attribute = 0;
mam_ptr->m_idx = m_idx;
mam_ptr->t_idx = t_idx;
mam_ptr->m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
#include "monster-attack/monster-attack-effect.h"
#include "monster-attack/monster-attack-types.h"
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
/* monster-attack-monster type*/
struct monster_type;
typedef struct mam_type {
- int effect_type;
+ int attribute;
MONRACE_IDX m_idx;
MONRACE_IDX t_idx;
monster_type *m_ptr;
bool explode;
bool touched;
concptr act;
- spells_type pt;
+ AttributeType pt;
RaceBlowEffectType effect;
ARMOUR_CLASS ac;
DEPTH rlev;
#include "monster/monster-status.h"
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
static void process_blow_effect(player_type *player_ptr, mam_type *mam_ptr)
{
monster_race *r_ptr = &r_info[mam_ptr->m_ptr->r_idx];
- switch (mam_ptr->effect_type) {
+ switch (mam_ptr->attribute) {
case BLOW_EFFECT_TYPE_FEAR:
- project(player_ptr, mam_ptr->m_idx, 0, mam_ptr->t_ptr->fy, mam_ptr->t_ptr->fx, mam_ptr->damage, GF_TURN_ALL,
- PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
+ project(player_ptr, mam_ptr->m_idx, 0, mam_ptr->t_ptr->fy, mam_ptr->t_ptr->fx, mam_ptr->damage,
+ AttributeType::TURN_ALL, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
break;
case BLOW_EFFECT_TYPE_SLEEP:
- project(player_ptr, mam_ptr->m_idx, 0, mam_ptr->t_ptr->fy, mam_ptr->t_ptr->fx, r_ptr->level, GF_OLD_SLEEP, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
+ project(player_ptr, mam_ptr->m_idx, 0, mam_ptr->t_ptr->fy, mam_ptr->t_ptr->fx, r_ptr->level,
+ AttributeType::OLD_SLEEP, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
break;
case BLOW_EFFECT_TYPE_HEAL:
heal_monster_by_melee(player_ptr, mam_ptr);
if (mam_ptr->m_ptr->ml && is_original_ap_and_seen(player_ptr, mam_ptr->t_ptr))
tr_ptr->aura_flags.set(MonsterAuraType::FIRE);
- project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), GF_FIRE,
+ project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), AttributeType::FIRE,
PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
}
if (mam_ptr->m_ptr->ml && is_original_ap_and_seen(player_ptr, mam_ptr->t_ptr))
tr_ptr->aura_flags.set(MonsterAuraType::COLD);
- project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), GF_COLD,
+ project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), AttributeType::COLD,
PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
}
if (mam_ptr->m_ptr->ml && is_original_ap_and_seen(player_ptr, mam_ptr->t_ptr))
tr_ptr->aura_flags.set(MonsterAuraType::ELEC);
- project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), GF_ELEC,
+ project(player_ptr, mam_ptr->t_idx, 0, mam_ptr->m_ptr->fy, mam_ptr->m_ptr->fx, damroll(1 + ((tr_ptr->level) / 26), 1 + ((tr_ptr->level) / 17)), AttributeType::ELEC,
PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED);
}
static void process_monster_attack_effect(player_type *player_ptr, mam_type *mam_ptr)
{
- if (mam_ptr->pt == GF_NONE)
+ if (mam_ptr->pt == AttributeType::NONE)
return;
if (!mam_ptr->explode)
describe_silly_melee(mam_ptr);
mam_ptr->obvious = true;
mam_ptr->damage = damroll(mam_ptr->d_dice, mam_ptr->d_side);
- mam_ptr->effect_type = BLOW_EFFECT_TYPE_NONE;
- mam_ptr->pt = GF_MISSILE;
+ mam_ptr->attribute = BLOW_EFFECT_TYPE_NONE;
+ mam_ptr->pt = AttributeType::MISSILE;
decide_monster_attack_effect(player_ptr, mam_ptr);
process_monster_attack_effect(player_ptr, mam_ptr);
}
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
#include "system/floor-type-definition.h"
*/
struct element_type {
std::string_view title; //!< 領域名
- std::array<spells_type, 3> type; //!< 属性タイプリスト
+ std::array<AttributeType, 3> type; //!< 属性タイプリスト
std::array<std::string_view, 3> name; //!< 属性名リスト
- std::unordered_map<spells_type, spells_type> extra; //!< 追加属性タイプ
+ std::unordered_map<AttributeType, AttributeType> extra; //!< 追加属性タイプ
};
/*!
{
ElementRealm::FIRE, {
_("炎", "Fire"),
- { GF_FIRE, GF_HELL_FIRE, GF_PLASMA },
+ { AttributeType::FIRE, AttributeType::HELL_FIRE, AttributeType::PLASMA },
{ _("火炎", "Fire"), _("業火", "Hell Fire"), _("プラズマ", "Plasma") },
{ },
}
{
ElementRealm::ICE, {
_("氷", "Ice"),
- { GF_COLD, GF_INERTIAL, GF_TIME },
+ { AttributeType::COLD, AttributeType::INERTIAL, AttributeType::TIME },
{ _("冷気", "Ice"), _("遅鈍", "Inertia"), _("時間逆転", "Time Stream") },
- { { GF_COLD, GF_ICE} },
+ { { AttributeType::COLD, AttributeType::ICE} },
}
},
{
ElementRealm::SKY, {
_("空", "Sky"),
- { GF_ELEC, GF_LITE, GF_MANA },
+ { AttributeType::ELEC, AttributeType::LITE, AttributeType::MANA },
{ _("電撃", "Lightning"), _("光", "Light"), _("魔力", "Mana") },
{ },
}
{
ElementRealm::SEA, {
_("海", "Sea"),
- { GF_ACID, GF_WATER, GF_DISINTEGRATE },
+ { AttributeType::ACID, AttributeType::WATER, AttributeType::DISINTEGRATE },
{ _("酸", "Acid"), _("水", "Water"), _("分解", "Disintegration") },
{ },
}
{
ElementRealm::DARKNESS, {
_("闇", "Darkness"),
- { GF_DARK, GF_NETHER, GF_VOID },
+ { AttributeType::DARK, AttributeType::NETHER, AttributeType::VOID_MAGIC },
{ _("暗黒", "Darkness"), _("地獄", "Nether"), _("虚無", "void") },
- { { GF_DARK, GF_ABYSS } },
+ { { AttributeType::DARK, AttributeType::ABYSS } },
}
},
{
ElementRealm::CHAOS, {
_("混沌", "Chaos"),
- { GF_CONFUSION, GF_CHAOS, GF_NEXUS },
+ { AttributeType::CONFUSION, AttributeType::CHAOS, AttributeType::NEXUS },
{ _("混乱", "Confusion"), _("カオス", "Chaos"), _("因果混乱", "Nexus") },
{ },
}
{
ElementRealm::EARTH, {
_("地", "Earth"),
- { GF_SHARDS, GF_FORCE, GF_METEOR },
+ { AttributeType::SHARDS, AttributeType::FORCE, AttributeType::METEOR },
{ _("破片", "Shards"), _("フォース", "Force"), _("隕石", "Meteor") },
{ },
}
{
ElementRealm::DEATH, {
_("瘴気", "Death"),
- { GF_POIS, GF_HYPODYNAMIA, GF_DISENCHANT },
+ { AttributeType::POIS, AttributeType::HYPODYNAMIA, AttributeType::DISENCHANT },
{ _("毒", "Poison"), _("吸血", "Drain Life"), _("劣化", "Disenchantment") },
{ },
}
* @param realm_idx 領域番号
* @return 領域で使用できる属性リスト
*/
-static std::array<spells_type, 3> get_element_types(int realm_idx)
+static std::array<AttributeType, 3> get_element_types(int realm_idx)
{
auto realm = i2enum<ElementRealm>(realm_idx);
return element_types.at(realm).type;
* @param n 属性の何番目か
* @return 属性タイプ
*/
-spells_type get_element_type(int realm_idx, int n)
+AttributeType get_element_type(int realm_idx, int n)
{
return get_element_types(realm_idx)[n];
}
* @param n 属性の何番目か
* @return 属性タイプ
*/
-static spells_type get_element_spells_type(player_type *player_ptr, int n)
+static AttributeType get_element_spells_type(player_type *player_ptr, int n)
{
auto realm = element_types.at(i2enum<ElementRealm>(player_ptr->element));
auto t = realm.type.at(n);
{
auto spell = i2enum<ElementSpells>(spell_idx);
auto power = element_powers.at(spell);
- spells_type typ;
+ AttributeType typ;
DIRECTION dir;
PLAYER_LEVEL plev = player_ptr->lev;
HIT_POINT dam;
dam = damroll(8 + ((plev - 5) / 4), 8);
typ = get_element_spells_type(player_ptr, power.elem);
if (fire_bolt_or_beam(player_ptr, plev, typ, dir, dam)) {
- if (typ == GF_HYPODYNAMIA) {
+ if (typ == AttributeType::HYPODYNAMIA) {
(void)hp_player(player_ptr, dam / 2);
}
}
dam = std::min(150, player_ptr->chp / 2);
typ = get_element_spells_type(player_ptr, power.elem);
if (fire_breath(player_ptr, typ, dir, dam, 3)) {
- if (typ == GF_HYPODYNAMIA) {
+ if (typ == AttributeType::HYPODYNAMIA) {
(void)hp_player(player_ptr, dam / 2);
}
}
case ElementSpells::ANNIHILATE:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball_hide(player_ptr, GF_E_GENOCIDE, dir, plev + 50, 0);
+ fire_ball_hide(player_ptr, AttributeType::E_GENOCIDE, dir, plev + 50, 0);
break;
case ElementSpells::BOLT_3RD:
if (!get_aim_dir(player_ptr, &dir))
dam = 75 + plev * 3 / 2;
typ = get_element_spells_type(player_ptr, power.elem);
if (fire_ball(player_ptr, typ, dir, dam, 3)) {
- if (typ == GF_HYPODYNAMIA) {
+ if (typ == AttributeType::HYPODYNAMIA) {
(void)hp_player(player_ptr, dam / 2);
}
}
dam = 115 + plev * 5 / 2;
typ = get_element_spells_type(player_ptr, power.elem);
if (fire_ball(player_ptr, typ, dir, dam, 4)) {
- if (typ == GF_HYPODYNAMIA) {
+ if (typ == AttributeType::HYPODYNAMIA) {
(void)hp_player(player_ptr, dam / 2);
}
}
* @param type 魔法攻撃属性
* @return 効果があるならTRUE、なければFALSE
*/
-bool is_elemental_genocide_effective(monster_race *r_ptr, spells_type type)
+bool is_elemental_genocide_effective(monster_race *r_ptr, AttributeType type)
{
switch (type) {
- case GF_FIRE:
+ case AttributeType::FIRE:
if (any_bits(r_ptr->flagsr, RFR_IM_FIRE))
return false;
break;
- case GF_COLD:
+ case AttributeType::COLD:
if (any_bits(r_ptr->flagsr, RFR_IM_COLD))
return false;
break;
- case GF_ELEC:
+ case AttributeType::ELEC:
if (any_bits(r_ptr->flagsr, RFR_IM_ELEC))
return false;
break;
- case GF_ACID:
+ case AttributeType::ACID:
if (any_bits(r_ptr->flagsr, RFR_IM_ACID))
return false;
break;
- case GF_DARK:
+ case AttributeType::DARK:
if (any_bits(r_ptr->flagsr, RFR_RES_DARK) || any_bits(r_ptr->r_flags3, RF3_HURT_LITE))
return false;
break;
- case GF_CONFUSION:
+ case AttributeType::CONFUSION:
if (any_bits(r_ptr->flags3, RF3_NO_CONF))
return false;
break;
- case GF_SHARDS:
+ case AttributeType::SHARDS:
if (any_bits(r_ptr->flagsr, RFR_RES_SHAR))
return false;
break;
- case GF_POIS:
+ case AttributeType::POIS:
if (any_bits(r_ptr->flagsr, RFR_IM_POIS))
return false;
break;
case ElementRealm::EARTH:
rpi = rpi_type(_("地震", "Earthquake"));
rpi.info = format("%s%d", KWD_SPHERE, 10);
- rpi.text
- = _("周囲のダンジョンを揺らし、壁と床をランダムに入れ変える。", "Shakes dungeon structure, and results in random swapping of floors and walls.");
+ rpi.text = _("周囲のダンジョンを揺らし、壁と床をランダムに入れ変える。", "Shakes dungeon structure, and results in random swapping of floors and walls.");
rpi.min_level = 25;
rpi.cost = 15;
rpi.stat = A_WIS;
(void)lite_area(player_ptr, damroll(2, plev / 2), plev / 10);
break;
case ElementRealm::ICE:
- (void)project(player_ptr, 0, 5, player_ptr->y, player_ptr->x, 1, GF_COLD, PROJECT_ITEM);
- (void)project_all_los(player_ptr, GF_OLD_SLEEP, 20 + plev * 3 / 2);
+ (void)project(player_ptr, 0, 5, player_ptr->y, player_ptr->x, 1, AttributeType::COLD, PROJECT_ITEM);
+ (void)project_all_los(player_ptr, AttributeType::OLD_SLEEP, 20 + plev * 3 / 2);
break;
case ElementRealm::SKY:
(void)recharge(player_ptr, 120);
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
enum class ElementRealm {
FIRE = 1,
struct rc_type;
concptr get_element_title(int realm_idx);
-spells_type get_element_type(int realm_idx, int n);
+AttributeType get_element_type(int realm_idx, int n);
concptr get_element_name(int realm_idx, int n);
void do_cmd_element(player_type *player_ptr);
void do_cmd_element_browse(player_type *player_ptr);
#include "player/player-damage.h"
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-lite.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/summon-types.h"
#include "status/temporary-resistance.h"
#include "system/floor-type-definition.h"
POSITION x = player_ptr->x + ddx[dir];
PLAYER_LEVEL plev = player_ptr->lev;
HIT_POINT dam = damroll(8 + ((plev - 5) / 4) + boost / 12, 8);
- fire_beam(player_ptr, GF_MISSILE, dir, dam);
+ fire_beam(player_ptr, AttributeType::MISSILE, dir, dam);
if (!player_ptr->current_floor_ptr->grid_array[y][x].m_idx)
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_MISSILE, dir, damroll(3 + ((plev - 1) / 5) + boost / 12, 4), 0);
+ fire_ball(player_ptr, AttributeType::MISSILE, dir, damroll(3 + ((plev - 1) / 5) + boost / 12, 4), 0);
break;
case FLASH_LIGHT:
(void)lite_area(player_ptr, damroll(2, (plev / 2)), (plev / 10) + 1);
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_MISSILE, dir, damroll(5 + ((plev - 1) / 5) + boost / 10, 5));
+ fire_beam(player_ptr, AttributeType::MISSILE, dir, damroll(5 + ((plev - 1) / 5) + boost / 10, 5));
break;
case MAGIC_RESISTANCE:
set_resist_magic(player_ptr, randint1(20) + 20 + boost / 5, false);
player_ptr->update |= (PU_BONUS);
if (randint1(get_current_ki(player_ptr)) > (plev * 4 + 120)) {
msg_print(_("気が暴走した！", "The Force exploded!"));
- fire_ball(player_ptr, GF_MANA, 0, get_current_ki(player_ptr) / 2, 10);
+ fire_ball(player_ptr, AttributeType::MANA, 0, get_current_ki(player_ptr) / 2, 10);
auto data = PlayerClass(player_ptr).get_specific_data<force_trainer_data_type>();
take_hit(player_ptr, DAMAGE_LOSELIFE, data->ki / 2, _("気の暴走", "Explosion of the Force"));
} else
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_MISSILE, dir, damroll(10, 6) + plev * 3 / 2 + boost * 3 / 5, (plev < 30) ? 2 : 3);
+ fire_ball(player_ptr, AttributeType::MISSILE, dir, damroll(10, 6) + plev * 3 / 2 + boost * 3 / 5, (plev < 30) ? 2 : 3);
break;
case DISPEL_MAGIC: {
if (!target_set(player_ptr, TARGET_KILL))
break;
}
case EXPLODING_FLAME:
- fire_ball(player_ptr, GF_FIRE, 0, 200 + (2 * plev) + boost * 2, 10);
+ fire_ball(player_ptr, AttributeType::FIRE, 0, 200 + (2 * plev) + boost * 2, 10);
break;
case SUPER_KAMEHAMEHA:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_MANA, dir, damroll(10 + (plev / 2) + boost * 3 / 10, 15));
+ fire_beam(player_ptr, AttributeType::MANA, dir, damroll(10 + (plev / 2) + boost * 3 / 10, 15));
break;
case LIGHT_SPEED:
set_lightspeed(player_ptr, randint1(16) + 16 + boost / 20, false);
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/bad-status-setter.h"
#include "status/buff-setter.h"
return false;
if (randint1(100) < plev * 2)
- fire_beam(player_ptr, GF_PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)));
+ fire_beam(player_ptr, AttributeType::PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)));
else
- fire_ball(player_ptr, GF_PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)), 0);
+ fire_ball(player_ptr, AttributeType::PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)), 0);
break;
case MINOR_DISPLACEMENT:
teleport_player(player_ptr, 10, TELEPORT_SPONTANEOUS);
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_DOMINATION, dir, plev, 0);
+ fire_ball(player_ptr, AttributeType::DOMINATION, dir, plev, 0);
} else {
charm_monsters(player_ptr, plev * 2);
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_TELEKINESIS, dir, damroll(8 + ((plev - 5) / 4), 8), (plev > 20 ? (plev - 20) / 8 + 1 : 0));
+ fire_ball(player_ptr, AttributeType::TELEKINESIS, dir, damroll(8 + ((plev - 5) / 4), 8), (plev > 20 ? (plev - 20) / 8 + 1 : 0));
break;
case CHARACTER_ARMOR:
set_shield(player_ptr, (TIME_EFFECT)plev, false);
case MIND_WAVE:
msg_print(_("精神を捻じ曲げる波動を発生させた！", "Mind-warping forces emanate from your brain!"));
if (plev < 25)
- project(player_ptr, 0, 2 + plev / 10, player_ptr->y, player_ptr->x, (plev * 3), GF_PSI, PROJECT_KILL);
+ project(player_ptr, 0, 2 + plev / 10, player_ptr->y, player_ptr->x, (plev * 3), AttributeType::PSI, PROJECT_KILL);
else
(void)mindblast_monsters(player_ptr, randint1(plev * ((plev - 5) / 10 + 1)));
return false;
dam = damroll(plev / 2, 6);
- if (fire_ball(player_ptr, GF_PSI_DRAIN, dir, dam, 0))
+ if (fire_ball(player_ptr, AttributeType::PSI_DRAIN, dir, dam, 0))
player_ptr->energy_need += randint1(150);
break;
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_PSY_SPEAR, dir, randint1(plev * 3) + plev * 3);
+ fire_beam(player_ptr, AttributeType::PSY_SPEAR, dir, randint1(plev * 3) + plev * 3);
break;
case THE_WORLD:
time_walk(player_ptr);
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/body-improvement.h"
#include "status/buff-setter.h"
#include "status/sight-setter.h"
if (!explode)
continue;
- project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, GF_SHARDS,
+ project(player_ptr, 0, 2, y, x, player_ptr->lev / 2 + 5, AttributeType::SHARDS,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI));
}
}
&& centersign * ((point_x[2] - x) * (point_y[0] - y) - (point_y[2] - y) * (point_x[0] - x)) >= 0) {
if (player_has_los_bold(player_ptr, y, x) && projectable(player_ptr, player_ptr->y, player_ptr->x, y, x)) {
if (!(player_ptr->blind) && panel_contains(y, x)) {
- uint16_t p = bolt_pict(y, x, y, x, GF_MANA);
+ uint16_t p = bolt_pict(y, x, y, x, AttributeType::MANA);
print_rel(player_ptr, PICT_C(p), PICT_A(p), y, x);
move_cursor_relative(y, x);
term_fresh();
&& centersign * ((point_x[1] - x) * (point_y[2] - y) - (point_y[1] - y) * (point_x[2] - x)) >= 0
&& centersign * ((point_x[2] - x) * (point_y[0] - y) - (point_y[2] - y) * (point_x[0] - x)) >= 0) {
if (player_has_los_bold(player_ptr, y, x) && projectable(player_ptr, player_ptr->y, player_ptr->x, y, x)) {
- (void)affect_feature(player_ptr, 0, 0, y, x, dam, GF_MANA);
+ (void)affect_feature(player_ptr, 0, 0, y, x, dam, AttributeType::MANA);
}
}
}
&& centersign * ((point_x[1] - x) * (point_y[2] - y) - (point_y[1] - y) * (point_x[2] - x)) >= 0
&& centersign * ((point_x[2] - x) * (point_y[0] - y) - (point_y[2] - y) * (point_x[0] - x)) >= 0) {
if (player_has_los_bold(player_ptr, y, x) && projectable(player_ptr, player_ptr->y, player_ptr->x, y, x)) {
- (void)affect_item(player_ptr, 0, 0, y, x, dam, GF_MANA);
+ (void)affect_item(player_ptr, 0, 0, y, x, dam, AttributeType::MANA);
}
}
}
&& centersign * ((point_x[1] - x) * (point_y[2] - y) - (point_y[1] - y) * (point_x[2] - x)) >= 0
&& centersign * ((point_x[2] - x) * (point_y[0] - y) - (point_y[2] - y) * (point_x[0] - x)) >= 0) {
if (player_has_los_bold(player_ptr, y, x) && projectable(player_ptr, player_ptr->y, player_ptr->x, y, x)) {
- (void)affect_monster(player_ptr, 0, 0, y, x, dam, GF_MANA, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP), true);
+ (void)affect_monster(player_ptr, 0, 0, y, x, dam, AttributeType::MANA, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP), true);
}
}
}
if (!player_ptr->current_floor_ptr->grid_array[y][x].is_mirror())
continue;
- if (!affect_monster(player_ptr, 0, 0, y, x, dam, GF_GENOCIDE, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP), true))
+ if (!affect_monster(player_ptr, 0, 0, y, x, dam, AttributeType::GENOCIDE, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP), true))
continue;
if (!player_ptr->current_floor_ptr->grid_array[y][x].m_idx) {
return false;
if (plev > 9 && g_ptr->is_mirror())
- fire_beam(player_ptr, GF_LITE, dir, damroll(3 + ((plev - 1) / 5), 4));
+ fire_beam(player_ptr, AttributeType::LITE, dir, damroll(3 + ((plev - 1) / 5), 4));
else
- fire_bolt(player_ptr, GF_LITE, dir, damroll(3 + ((plev - 1) / 5), 4));
+ fire_bolt(player_ptr, AttributeType::LITE, dir, damroll(3 + ((plev - 1) / 5), 4));
break;
case WRAPPED_MIRROR:
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_beam(player_ptr, GF_AWAY_ALL, dir, plev);
+ (void)fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, plev);
break;
case MIRROR_CRASHING:
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_SHARDS, dir, damroll(8 + ((plev - 5) / 4), 8), (plev > 20 ? (plev - 20) / 8 + 1 : 0));
+ fire_ball(player_ptr, AttributeType::SHARDS, dir, damroll(8 + ((plev - 5) / 4), 8), (plev > 20 ? (plev - 20) / 8 + 1 : 0));
break;
case SLEEPING_MIRROR:
for (x = 0; x < player_ptr->current_floor_ptr->width; x++)
for (y = 0; y < player_ptr->current_floor_ptr->height; y++)
if (player_ptr->current_floor_ptr->grid_array[y][x].is_mirror())
- project(player_ptr, 0, 2, y, x, (HIT_POINT)plev, GF_OLD_SLEEP,
+ project(player_ptr, 0, 2, y, x, (HIT_POINT)plev, AttributeType::OLD_SLEEP,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI));
break;
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_SEEKER, dir, damroll(11 + (plev - 5) / 4, 8));
+ fire_beam(player_ptr, AttributeType::SEEKER, dir, damroll(11 + (plev - 5) / 4, 8));
break;
case SEALING_MIRROR:
seal_of_mirror(player_ptr, plev * 4 + 100);
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, GF_SUPER_RAY, dir, 150 + randint1(2 * plev));
+ fire_beam(player_ptr, AttributeType::SUPER_RAY, dir, 150 + randint1(2 * plev));
break;
case ILLUSION_LIGHT:
tmp = g_ptr->is_mirror() ? 4 : 3;
#include "spell-kind/spells-lite.h"
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/action-setter.h"
#include "status/body-improvement.h"
set_tim_levitation(player_ptr, randint1(20) + 20, false);
break;
case HIDE_FLAMES:
- fire_ball(player_ptr, GF_FIRE, 0, 50 + plev, plev / 10 + 2);
+ fire_ball(player_ptr, AttributeType::FIRE, 0, 50 + plev, plev / 10 + 2);
teleport_player(player_ptr, 30, TELEPORT_SPONTANEOUS);
set_oppose_fire(player_ptr, (TIME_EFFECT)plev, false);
break;
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_ball(player_ptr, GF_OLD_CONF, dir, plev * 3, 3);
+ fire_ball(player_ptr, AttributeType::OLD_CONF, dir, plev * 3, 3);
break;
case SWAP_POSITION:
project_length = -1;
set_oppose_acid(player_ptr, (TIME_EFFECT)plev, false);
break;
case HIDE_MIST:
- fire_ball(player_ptr, GF_POIS, 0, 75 + plev * 2 / 3, plev / 5 + 2);
- fire_ball(player_ptr, GF_HYPODYNAMIA, 0, 75 + plev * 2 / 3, plev / 5 + 2);
- fire_ball(player_ptr, GF_CONFUSION, 0, 75 + plev * 2 / 3, plev / 5 + 2);
+ fire_ball(player_ptr, AttributeType::POIS, 0, 75 + plev * 2 / 3, plev / 5 + 2);
+ fire_ball(player_ptr, AttributeType::HYPODYNAMIA, 0, 75 + plev * 2 / 3, plev / 5 + 2);
+ fire_ball(player_ptr, AttributeType::CONFUSION, 0, 75 + plev * 2 / 3, plev / 5 + 2);
teleport_player(player_ptr, 30, TELEPORT_SPONTANEOUS);
break;
case PURGATORY_FLAME: {
int num = damroll(3, 9);
for (int k = 0; k < num; k++) {
- EFFECT_ID typ = one_in_(2) ? GF_FIRE : one_in_(3) ? GF_NETHER : GF_PLASMA;
+ AttributeType typ = one_in_(2) ? AttributeType::FIRE : one_in_(3) ? AttributeType::NETHER : AttributeType::PLASMA;
int attempts = 1000;
while (attempts--) {
scatter(player_ptr, &y, &x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
return;
}
- const auto effect_flags = Smith::get_effect_tr_flags(effect);
+ const auto attribute_flags = Smith::get_effect_tr_flags(effect);
auto add_essence_count = 1;
- if (effect_flags.has_any_of(TR_PVAL_FLAG_MASK)) {
+ if (attribute_flags.has_any_of(TR_PVAL_FLAG_MASK)) {
if (o_ptr->pval < 0) {
msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
return;
- } else if (effect_flags.has(TR_BLOWS)) {
+ } else if (attribute_flags.has(TR_BLOWS)) {
if ((o_ptr->pval > 1) && !get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) {
return;
}
}
sound(SOUND_EXPLODE);
- MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, monap_ptr->m_ptr->hp + 1, &monap_ptr->fear, GF_NONE);
+ MonsterDamageProcessor mdp(player_ptr, monap_ptr->m_idx, monap_ptr->m_ptr->hp + 1, &monap_ptr->fear, AttributeType::NONE);
if (mdp.mon_take_hit(nullptr)) {
monap_ptr->blinked = false;
monap_ptr->alive = false;
#include "monster-attack/monster-attack-types.h"
#include "monster-attack/monster-attack-effect.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
/*!
* @brief モンスターの打撃効力テーブル /
const mbe_info_type mbe_info[static_cast<int>(RaceBlowEffectType::MAX)] = {
{
0,
- 0,
+ AttributeType::NONE,
}, /* None */
{
60,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* HURT */
{
5,
- GF_POIS,
+ AttributeType::POIS,
}, /* POISON */
{
20,
- GF_DISENCHANT,
+ AttributeType::DISENCHANT,
}, /* UN_BONUS */
{
15,
- GF_MISSILE,
+ AttributeType::MISSILE,
},
/* UN_POWER */ /* ToDo: Apply the correct effects */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EAT_GOLD */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EAT_ITEM */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EAT_FOOD */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EAT_LITE */
{
0,
- GF_ACID,
+ AttributeType::ACID,
}, /* ACID */
{
10,
- GF_ELEC,
+ AttributeType::ELEC,
}, /* ELEC */
{
10,
- GF_FIRE,
+ AttributeType::FIRE,
}, /* FIRE */
{
10,
- GF_COLD,
+ AttributeType::COLD,
}, /* COLD */
{
2,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* BLIND */
{
10,
- GF_CONFUSION,
+ AttributeType::CONFUSION,
}, /* CONFUSE */
{
10,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* TERRIFY */
{
2,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* PARALYZE */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_STR */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_INT */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_WIS */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_DEX */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_CON */
{
0,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_CHR */
{
2,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* LOSE_ALL */
{
60,
- GF_ROCKET,
+ AttributeType::ROCKET,
}, /* SHATTER */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EXP_10 */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EXP_20 */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EXP_40 */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EXP_80 */
{
5,
- GF_POIS,
+ AttributeType::POIS,
}, /* DISEASE */
{
5,
- GF_TIME,
+ AttributeType::TIME,
}, /* TIME */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* EXP_VAMP */
{
5,
- GF_MANA,
+ AttributeType::MANA,
}, /* DR_MANA */
{
60,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* SUPERHURT */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* INERTIA */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* STUN */
{
5,
- GF_MISSILE,
+ AttributeType::MISSILE,
}, /* HUNGRY */
{
0,
- GF_NONE,
+ AttributeType::NONE,
}, /* FLAVOR */
};
#include "monster-attack/monster-attack-effect.h"
#include "system/angband.h"
+#include "effect/attribute-types.h"
/*!
* @note モンスターの打撃方法 / New monster blow methods
typedef struct mbe_info_type {
int power; /* The attack "power" */
- int explode_type; /* Explosion effect */
+ AttributeType explode_type; /* Explosion effect */
} mbe_info_type;
extern const mbe_info_type mbe_info[static_cast<int>(RaceBlowEffectType::MAX)];
continue;
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
- EFFECT_ID typ = mbe_info[enum2i(md_ptr->r_ptr->blow[i].effect)].explode_type;
+ AttributeType typ = mbe_info[enum2i(md_ptr->r_ptr->blow[i].effect)].explode_type;
DICE_NUMBER d_dice = md_ptr->r_ptr->blow[i].d_dice;
DICE_SID d_side = md_ptr->r_ptr->blow[i].d_side;
HIT_POINT damage = damroll(d_dice, d_side);
* Handle the "death" of a monster.
* @param m_idx 死亡したモンスターのID
* @param drop_item TRUEならばモンスターのドロップ処理を行う
- * @param effect_type ラストアタックの属性 (単一属性)
+ * @param type ラストアタックの属性 (単一属性)
*/
-void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, EFFECT_ID effect_type)
+void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, AttributeType type)
{
- EffectFlags flags;
+ AttributeFlags flags;
flags.clear();
- flags.set((spells_type)effect_type);
+ flags.set(type);
monster_death(player_ptr, m_idx, drop_item, flags);
}
* Handle the "death" of a monster.
* @param m_idx 死亡したモンスターのID
* @param drop_item TRUEならばモンスターのドロップ処理を行う
- * @param effect_flags ラストアタックの属性 (複数属性)
+ * @param attribute_flags ラストアタックの属性 (複数属性)
* @details
* <pre>
* Disperse treasures centered at the monster location based on the
* it drops all of its objects, which may disappear in crowded rooms.
* </pre>
*/
-void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, EffectFlags effect_flags)
+void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, AttributeFlags attribute_flags)
{
monster_death_type tmp_md;
monster_death_type *md_ptr = initialize_monster_death_type(player_ptr, &tmp_md, m_idx, drop_item);
drop_corpse(player_ptr, md_ptr);
monster_drop_carried_objects(player_ptr, md_ptr->m_ptr);
decide_drop_quality(md_ptr);
- switch_special_death(player_ptr, md_ptr, effect_flags);
+ switch_special_death(player_ptr, md_ptr, attribute_flags);
drop_artifact(player_ptr, md_ptr);
int drop_numbers = decide_drop_numbers(player_ptr, md_ptr, drop_item);
coin_type = md_ptr->force_coin;
#include "system/angband.h"
#include "monster-floor/monster-death-util.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
struct player_type;
-void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, EffectFlags effect_flags);
-void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, EFFECT_ID effect_type);
+void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, AttributeFlags attribute_flags);
+void monster_death(player_type *player_ptr, MONSTER_IDX m_idx, bool drop_item, AttributeType type);
bool drop_single_artifact(player_type *player_ptr, monster_death_type *md_ptr, ARTIFACT_IDX a_idx);
concptr extract_note_dies(MONRACE_IDX r_idx);
#include "monster/monster-update.h"
#include "pet/pet-util.h"
#include "player/player-status-flags.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
if (g_ptr->info & CAVE_MARK) {
msg_print(_("ルーンが爆発した！", "The rune explodes!"));
BIT_FLAGS project_flags = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI;
- project(player_ptr, 0, 2, ny, nx, 2 * (player_ptr->lev + damroll(7, 7)), GF_MANA, project_flags);
+ project(player_ptr, 0, 2, ny, nx, 2 * (player_ptr->lev + damroll(7, 7)), AttributeType::MANA, project_flags);
}
} else {
msg_print(_("爆発のルーンは解除された。", "An explosive rune was disarmed."));
#include "monster/monster-util.h"
#include "object/warning.h"
#include "player/player-status.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
if (randint1(BREAK_RUNE_EXPLOSION) > r_ptr->level) {
if (any_bits(g_ptr->info, CAVE_MARK)) {
msg_print(_("ルーンが爆発した！", "The rune explodes!"));
- project(player_ptr, 0, 2, y, x, 2 * (player_ptr->lev + damroll(7, 7)), GF_MANA,
+ project(player_ptr, 0, 2, y, x, 2 * (player_ptr->lev + damroll(7, 7)), AttributeType::MANA,
(PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI));
}
} else {
#include "monster/smart-learn-types.h"
#include "mspell/assign-monster-spell.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell-kind/spells-teleport.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
msg_format(_("%sは消え去った！", "%^s disappears!"), m_name);
}
- monster_death(player_ptr, m_idx, false, GF_NONE);
+ monster_death(player_ptr, m_idx, false, AttributeType::NONE);
delete_monster_idx(player_ptr, m_idx);
if (is_pet(m_ptr) && !(m_ptr->ml))
msg_print(_("少しの間悲しい気分になった。", "You feel sad for a moment."));
#include "object-enchant/apply-magic.h"
#include "object-enchant/item-apply-magic.h"
#include "object/object-kind-hook.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/summon-types.h"
#include "sv-definition/sv-other-types.h"
#include "sv-definition/sv-protector-types.h"
msg_format(_("%sは辺りにログルスの残り香を撒き散らした！", "%^s sprinkled the remaining incense from Logrus!"), m_name);
}
- (void)project(player_ptr, md_ptr->m_idx, 6, md_ptr->md_y, md_ptr->md_x, 100, GF_CHAOS, PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
+ (void)project(player_ptr, md_ptr->m_idx, 6, md_ptr->md_y, md_ptr->md_x, 100, AttributeType::CHAOS, PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
}
static void on_dead_sacred_treasures(player_type *player_ptr, monster_death_type *md_ptr)
msg_format(_("%sは手榴弾を抱えて自爆した！", "%^s blew himself up with grenades!"), m_name);
}
- (void)project(player_ptr, md_ptr->m_idx, 3, md_ptr->md_y, md_ptr->md_x, damroll(20, 10), GF_FIRE, PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
+ (void)project(player_ptr, md_ptr->m_idx, 3, md_ptr->md_y, md_ptr->md_x, damroll(20, 10), AttributeType::FIRE, PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
}
static void on_dead_aqua_illusion(player_type *player_ptr, monster_death_type *md_ptr)
}
}
-static void on_dead_swordfish(player_type *player_ptr, monster_death_type *md_ptr, EffectFlags effect_flags)
+static void on_dead_swordfish(player_type *player_ptr, monster_death_type *md_ptr, AttributeFlags attribute_flags)
{
- if (effect_flags.has_not(GF_COLD) || !md_ptr->drop_chosen_item || (randint1(100) >= 10))
+ if (attribute_flags.has_not(AttributeType::COLD) || !md_ptr->drop_chosen_item || (randint1(100) >= 10))
return;
drop_single_artifact(player_ptr, md_ptr, ART_FROZEN_SWORDFISH);
}
-void switch_special_death(player_type *player_ptr, monster_death_type *md_ptr, EffectFlags effect_flags)
+void switch_special_death(player_type *player_ptr, monster_death_type *md_ptr, AttributeFlags attribute_flags)
{
switch (md_ptr->m_ptr->r_idx) {
case MON_PINK_HORROR:
on_dead_chest_mimic(player_ptr, md_ptr);
break;
case MON_SWORDFISH:
- on_dead_swordfish(player_ptr, md_ptr, effect_flags);
+ on_dead_swordfish(player_ptr, md_ptr, attribute_flags);
break;
default:
on_dead_mimics(player_ptr, md_ptr);
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
typedef struct monster_death_type monster_death_type;
struct player_type;
-void switch_special_death(player_type *player_ptr, monster_death_type *md_ptr, EffectFlags effect_flags);
+void switch_special_death(player_type *player_ptr, monster_death_type *md_ptr, AttributeFlags attribute_flags);
RF3_XX10 = 0x00000400, /*!< 予約領域。元冷気オーラ */
RF3_NONLIVING = 0x00000800, /*!< モンスター特性: 無生物 / TY: Non-Living (?) */
RF3_HURT_LITE = 0x00001000, /*!< モンスター特性: 通常の光(GF_WEAK_LITE)でダメージを受ける / Hurt by lite */
- RF3_HURT_ROCK = 0x00002000, /*!< モンスター特性: 岩石溶解(GF_KILL_WALL)でダメージを受ける / Hurt by rock remover */
+ RF3_HURT_ROCK = 0x00002000, /*!< モンスター特性: 岩石溶解(KILL_WALL)でダメージを受ける / Hurt by rock remover */
RF3_HURT_FIRE = 0x00004000, /*!< モンスター特性: 火炎が弱点 / Hurt badly by fire */
RF3_HURT_COLD = 0x00008000, /*!< モンスター特性: 冷気が弱点 / Hurt badly by cold */
RF3_ANGEL = 0x00010000, /*!< モンスター特性: 天使 / ANGEL */
* @param m_idx ダメージを与えたモンスターのID
* @param dam 与えたダメージ量
* @param fear ダメージによってモンスターが恐慌状態に陥ったならばtrue
- * @param effect_type 与えたダメージの種類 (単一属性)
+ * @param attribute 与えたダメージの種類 (単一属性)
* @param note モンスターが倒された際の特別なメッセージ述語
*/
-MonsterDamageProcessor::MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, EFFECT_ID effect_type)
+MonsterDamageProcessor::MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, AttributeType attribute)
: player_ptr(player_ptr)
, m_idx(m_idx)
, dam(dam)
, fear(fear)
{
- this->effect_flags.clear();
- this->effect_flags.set((spells_type)effect_type);
+ this->attribute_flags.clear();
+ this->attribute_flags.set((AttributeType)attribute);
}
/*
* @param m_idx ダメージを与えたモンスターのID
* @param dam 与えたダメージ量
* @param fear ダメージによってモンスターが恐慌状態に陥ったならばtrue
- * @param effect_flags 与えたダメージの種類 (複数属性)
+ * @param attribute_flags 与えたダメージの種類 (複数属性)
* @param note モンスターが倒された際の特別なメッセージ述語
*/
-MonsterDamageProcessor::MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, EffectFlags effect_flags)
+MonsterDamageProcessor::MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, AttributeFlags attribute_flags)
: player_ptr(player_ptr)
, m_idx(m_idx)
, dam(dam)
, fear(fear)
- , effect_flags(effect_flags)
+ , attribute_flags(attribute_flags)
{
}
sound(SOUND_KILL);
this->show_kill_message(note, m_name);
this->show_bounty_message(m_name);
- monster_death(this->player_ptr, this->m_idx, true, this->effect_flags);
+ monster_death(this->player_ptr, this->m_idx, true, this->attribute_flags);
this->summon_special_unique();
this->get_exp_from_mon(exp_mon, exp_mon->max_maxhp * 2);
*this->fear = false;
#include "monster-race/race-indice-types.h"
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "util/flag-group.h"
#include <tuple>
#include <vector>
typedef std::vector<std::tuple<monster_race_type, monster_race_type, monster_race_type>> combined_uniques;
class MonsterDamageProcessor {
public:
- MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, EFFECT_ID effect_type);
- MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, EffectFlags effect_flags);
+ MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, AttributeType type);
+ MonsterDamageProcessor(player_type *player_ptr, MONSTER_IDX m_idx, HIT_POINT dam, bool *fear, AttributeFlags attribute_flags);
virtual ~MonsterDamageProcessor() = default;
bool mon_take_hit(concptr note);
MONSTER_IDX m_idx;
HIT_POINT dam;
bool *fear;
- EffectFlags effect_flags{};
+ AttributeFlags attribute_flags{};
void get_exp_from_mon(monster_type *m_ptr, HIT_POINT exp_dam);
bool genocide_chaos_patron();
bool process_dead_exp_virtue(concptr note, monster_type *exp_mon);
#include "mspell/mspell-summon.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "util/enum-converter.h"
case RF_ABILITY::XXX2: break; /* RF4_XXX2 */
case RF_ABILITY::XXX3: break; /* RF4_XXX3 */
case RF_ABILITY::XXX4: break; /* RF4_XXX4 */
- case RF_ABILITY::BR_ACID: return spell_RF4_BREATH(player_ptr, GF_ACID, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ACID */
- case RF_ABILITY::BR_ELEC: return spell_RF4_BREATH(player_ptr, GF_ELEC, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ELEC */
- case RF_ABILITY::BR_FIRE: return spell_RF4_BREATH(player_ptr, GF_FIRE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_FIRE */
- case RF_ABILITY::BR_COLD: return spell_RF4_BREATH(player_ptr, GF_COLD, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_COLD */
- case RF_ABILITY::BR_POIS: return spell_RF4_BREATH(player_ptr, GF_POIS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_POIS */
- case RF_ABILITY::BR_NETH: return spell_RF4_BREATH(player_ptr, GF_NETHER, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NETH */
- case RF_ABILITY::BR_LITE: return spell_RF4_BREATH(player_ptr, GF_LITE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_LITE */
- case RF_ABILITY::BR_DARK: return spell_RF4_BREATH(player_ptr, GF_DARK, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DARK */
- case RF_ABILITY::BR_CONF: return spell_RF4_BREATH(player_ptr, GF_CONFUSION, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_CONF */
- case RF_ABILITY::BR_SOUN: return spell_RF4_BREATH(player_ptr, GF_SOUND, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_SOUN */
- case RF_ABILITY::BR_CHAO: return spell_RF4_BREATH(player_ptr, GF_CHAOS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_CHAO */
- case RF_ABILITY::BR_DISE: return spell_RF4_BREATH(player_ptr, GF_DISENCHANT, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DISE */
- case RF_ABILITY::BR_NEXU: return spell_RF4_BREATH(player_ptr, GF_NEXUS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NEXU */
- case RF_ABILITY::BR_TIME: return spell_RF4_BREATH(player_ptr, GF_TIME, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_TIME */
- case RF_ABILITY::BR_INER: return spell_RF4_BREATH(player_ptr, GF_INERTIAL, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_INER */
- case RF_ABILITY::BR_GRAV: return spell_RF4_BREATH(player_ptr, GF_GRAVITY, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_GRAV */
- case RF_ABILITY::BR_SHAR: return spell_RF4_BREATH(player_ptr, GF_SHARDS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_SHAR */
- case RF_ABILITY::BR_PLAS: return spell_RF4_BREATH(player_ptr, GF_PLASMA, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_PLAS */
- case RF_ABILITY::BR_FORC: return spell_RF4_BREATH(player_ptr, GF_FORCE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_WALL */
- case RF_ABILITY::BR_MANA: return spell_RF4_BREATH(player_ptr, GF_MANA, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_MANA */
+ case RF_ABILITY::BR_ACID: return spell_RF4_BREATH(player_ptr, AttributeType::ACID, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ACID */
+ case RF_ABILITY::BR_ELEC: return spell_RF4_BREATH(player_ptr, AttributeType::ELEC, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ELEC */
+ case RF_ABILITY::BR_FIRE: return spell_RF4_BREATH(player_ptr, AttributeType::FIRE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_FIRE */
+ case RF_ABILITY::BR_COLD: return spell_RF4_BREATH(player_ptr, AttributeType::COLD, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_COLD */
+ case RF_ABILITY::BR_POIS: return spell_RF4_BREATH(player_ptr, AttributeType::POIS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_POIS */
+ case RF_ABILITY::BR_NETH: return spell_RF4_BREATH(player_ptr, AttributeType::NETHER, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NETH */
+ case RF_ABILITY::BR_LITE: return spell_RF4_BREATH(player_ptr, AttributeType::LITE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_LITE */
+ case RF_ABILITY::BR_DARK: return spell_RF4_BREATH(player_ptr, AttributeType::DARK, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DARK */
+ case RF_ABILITY::BR_CONF: return spell_RF4_BREATH(player_ptr, AttributeType::CONFUSION, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_CONF */
+ case RF_ABILITY::BR_SOUN: return spell_RF4_BREATH(player_ptr, AttributeType::SOUND, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_SOUN */
+ case RF_ABILITY::BR_CHAO: return spell_RF4_BREATH(player_ptr, AttributeType::CHAOS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_CHAO */
+ case RF_ABILITY::BR_DISE: return spell_RF4_BREATH(player_ptr, AttributeType::DISENCHANT, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DISE */
+ case RF_ABILITY::BR_NEXU: return spell_RF4_BREATH(player_ptr, AttributeType::NEXUS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NEXU */
+ case RF_ABILITY::BR_TIME: return spell_RF4_BREATH(player_ptr, AttributeType::TIME, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_TIME */
+ case RF_ABILITY::BR_INER: return spell_RF4_BREATH(player_ptr, AttributeType::INERTIAL, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_INER */
+ case RF_ABILITY::BR_GRAV: return spell_RF4_BREATH(player_ptr, AttributeType::GRAVITY, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_GRAV */
+ case RF_ABILITY::BR_SHAR: return spell_RF4_BREATH(player_ptr, AttributeType::SHARDS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_SHAR */
+ case RF_ABILITY::BR_PLAS: return spell_RF4_BREATH(player_ptr, AttributeType::PLASMA, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_PLAS */
+ case RF_ABILITY::BR_FORC: return spell_RF4_BREATH(player_ptr, AttributeType::FORCE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_WALL */
+ case RF_ABILITY::BR_MANA: return spell_RF4_BREATH(player_ptr, AttributeType::MANA, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_MANA */
case RF_ABILITY::BA_NUKE: return spell_RF4_BA_NUKE(player_ptr, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BA_NUKE */
- case RF_ABILITY::BR_NUKE: return spell_RF4_BREATH(player_ptr, GF_NUKE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NUKE */
+ case RF_ABILITY::BR_NUKE: return spell_RF4_BREATH(player_ptr, AttributeType::NUKE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NUKE */
case RF_ABILITY::BA_CHAO: return spell_RF4_BA_CHAO(player_ptr, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BA_CHAO */
- case RF_ABILITY::BR_DISI: return spell_RF4_BREATH(player_ptr, GF_DISINTEGRATE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DISI */
+ case RF_ABILITY::BR_DISI: return spell_RF4_BREATH(player_ptr, AttributeType::DISINTEGRATE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DISI */
case RF_ABILITY::BA_ACID: return spell_RF5_BA_ACID(player_ptr, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_ACID */
case RF_ABILITY::BA_ELEC: return spell_RF5_BA_ELEC(player_ptr, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_ELEC */
case RF_ABILITY::BA_FIRE: return spell_RF5_BA_FIRE(player_ptr, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_FIRE */
case RF_ABILITY::XXX2: break; /* RF4_XXX2 */
case RF_ABILITY::XXX3: break; /* RF4_XXX3 */
case RF_ABILITY::XXX4: break; /* RF4_XXX4 */
- case RF_ABILITY::BR_ACID: return spell_RF4_BREATH(player_ptr, GF_ACID, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_ACID */
- case RF_ABILITY::BR_ELEC: return spell_RF4_BREATH(player_ptr, GF_ELEC, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_ELEC */
- case RF_ABILITY::BR_FIRE: return spell_RF4_BREATH(player_ptr, GF_FIRE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_FIRE */
- case RF_ABILITY::BR_COLD: return spell_RF4_BREATH(player_ptr, GF_COLD, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_COLD */
- case RF_ABILITY::BR_POIS: return spell_RF4_BREATH(player_ptr, GF_POIS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_POIS */
- case RF_ABILITY::BR_NETH: return spell_RF4_BREATH(player_ptr, GF_NETHER, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NETH */
- case RF_ABILITY::BR_LITE: return spell_RF4_BREATH(player_ptr, GF_LITE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_LITE */
- case RF_ABILITY::BR_DARK: return spell_RF4_BREATH(player_ptr, GF_DARK, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DARK */
- case RF_ABILITY::BR_CONF: return spell_RF4_BREATH(player_ptr, GF_CONFUSION, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_CONF */
- case RF_ABILITY::BR_SOUN: return spell_RF4_BREATH(player_ptr, GF_SOUND, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_SOUN */
- case RF_ABILITY::BR_CHAO: return spell_RF4_BREATH(player_ptr, GF_CHAOS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_CHAO */
- case RF_ABILITY::BR_DISE: return spell_RF4_BREATH(player_ptr, GF_DISENCHANT, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DISE */
- case RF_ABILITY::BR_NEXU: return spell_RF4_BREATH(player_ptr, GF_NEXUS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NEXU */
- case RF_ABILITY::BR_TIME: return spell_RF4_BREATH(player_ptr, GF_TIME, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_TIME */
- case RF_ABILITY::BR_INER: return spell_RF4_BREATH(player_ptr, GF_INERTIAL, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_INER */
- case RF_ABILITY::BR_GRAV: return spell_RF4_BREATH(player_ptr, GF_GRAVITY, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_GRAV */
- case RF_ABILITY::BR_SHAR: return spell_RF4_BREATH(player_ptr, GF_SHARDS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_SHAR */
- case RF_ABILITY::BR_PLAS: return spell_RF4_BREATH(player_ptr, GF_PLASMA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_PLAS */
- case RF_ABILITY::BR_FORC: return spell_RF4_BREATH(player_ptr, GF_FORCE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_WALL */
- case RF_ABILITY::BR_MANA: return spell_RF4_BREATH(player_ptr, GF_MANA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_MANA */
+ case RF_ABILITY::BR_ACID: return spell_RF4_BREATH(player_ptr, AttributeType::ACID, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_ACID */
+ case RF_ABILITY::BR_ELEC: return spell_RF4_BREATH(player_ptr, AttributeType::ELEC, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_ELEC */
+ case RF_ABILITY::BR_FIRE: return spell_RF4_BREATH(player_ptr, AttributeType::FIRE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_FIRE */
+ case RF_ABILITY::BR_COLD: return spell_RF4_BREATH(player_ptr, AttributeType::COLD, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_COLD */
+ case RF_ABILITY::BR_POIS: return spell_RF4_BREATH(player_ptr, AttributeType::POIS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_POIS */
+ case RF_ABILITY::BR_NETH: return spell_RF4_BREATH(player_ptr, AttributeType::NETHER, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NETH */
+ case RF_ABILITY::BR_LITE: return spell_RF4_BREATH(player_ptr, AttributeType::LITE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_LITE */
+ case RF_ABILITY::BR_DARK: return spell_RF4_BREATH(player_ptr, AttributeType::DARK, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DARK */
+ case RF_ABILITY::BR_CONF: return spell_RF4_BREATH(player_ptr, AttributeType::CONFUSION, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_CONF */
+ case RF_ABILITY::BR_SOUN: return spell_RF4_BREATH(player_ptr, AttributeType::SOUND, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_SOUN */
+ case RF_ABILITY::BR_CHAO: return spell_RF4_BREATH(player_ptr, AttributeType::CHAOS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_CHAO */
+ case RF_ABILITY::BR_DISE: return spell_RF4_BREATH(player_ptr, AttributeType::DISENCHANT, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DISE */
+ case RF_ABILITY::BR_NEXU: return spell_RF4_BREATH(player_ptr, AttributeType::NEXUS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NEXU */
+ case RF_ABILITY::BR_TIME: return spell_RF4_BREATH(player_ptr, AttributeType::TIME, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_TIME */
+ case RF_ABILITY::BR_INER: return spell_RF4_BREATH(player_ptr, AttributeType::INERTIAL, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_INER */
+ case RF_ABILITY::BR_GRAV: return spell_RF4_BREATH(player_ptr, AttributeType::GRAVITY, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_GRAV */
+ case RF_ABILITY::BR_SHAR: return spell_RF4_BREATH(player_ptr, AttributeType::SHARDS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_SHAR */
+ case RF_ABILITY::BR_PLAS: return spell_RF4_BREATH(player_ptr, AttributeType::PLASMA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_PLAS */
+ case RF_ABILITY::BR_FORC: return spell_RF4_BREATH(player_ptr, AttributeType::FORCE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_WALL */
+ case RF_ABILITY::BR_MANA: return spell_RF4_BREATH(player_ptr, AttributeType::MANA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_MANA */
case RF_ABILITY::BA_NUKE: return spell_RF4_BA_NUKE(player_ptr, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BA_NUKE */
- case RF_ABILITY::BR_NUKE: return spell_RF4_BREATH(player_ptr, GF_NUKE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NUKE */
+ case RF_ABILITY::BR_NUKE: return spell_RF4_BREATH(player_ptr, AttributeType::NUKE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_NUKE */
case RF_ABILITY::BA_CHAO: return spell_RF4_BA_CHAO(player_ptr, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BA_CHAO */
- case RF_ABILITY::BR_DISI: return spell_RF4_BREATH(player_ptr, GF_DISINTEGRATE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DISI */
+ case RF_ABILITY::BR_DISI: return spell_RF4_BREATH(player_ptr, AttributeType::DISINTEGRATE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_DISI */
case RF_ABILITY::BA_ACID: return spell_RF5_BA_ACID(player_ptr, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF5_BA_ACID */
case RF_ABILITY::BA_ELEC: return spell_RF5_BA_ELEC(player_ptr, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF5_BA_ELEC */
case RF_ABILITY::BA_FIRE: return spell_RF5_BA_FIRE(player_ptr, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF5_BA_FIRE */
#include "mspell/mspell-damage-calculator.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-type-definition.h"
#include "system/player-type-definition.h"
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_NUKE, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_NUKE, dam, 2, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::NUKE, dam, 2, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_POIS);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_CHAO, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_CHAOS, dam, 4, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::CHAOS, dam, 4, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_CHAOS);
const auto rad = monster_is_powerful(player_ptr->current_floor_ptr, m_idx) ? 4 : 2;
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_ACID, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_ACID, dam, rad, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::ACID, dam, rad, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_ACID);
const auto rad = monster_is_powerful(player_ptr->current_floor_ptr, m_idx) ? 4 : 2;
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_ELEC, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_ELEC, dam, rad, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::ELEC, dam, rad, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_ELEC);
const auto rad = monster_is_powerful(player_ptr->current_floor_ptr, m_idx) ? 4 : 2;
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_FIRE, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_FIRE, dam, rad, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::FIRE, dam, rad, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_FIRE);
const auto rad = monster_is_powerful(player_ptr->current_floor_ptr, m_idx) ? 4 : 2;
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_COLD, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_COLD, dam, rad, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::COLD, dam, rad, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_COLD);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_POIS, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_POIS, dam, 2, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::POIS, dam, 2, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_POIS);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_NETH, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_NETHER, dam, 2, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::NETHER, dam, 2, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_NETH);
}
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_WATE, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_WATER, dam, 4, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::WATER, dam, 4, false, TARGET_TYPE);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_MANA, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_MANA, dam, 4, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::MANA, dam, 4, false, TARGET_TYPE);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_DARK, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_DARK, dam, 4, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::DARK, dam, 4, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_DARK);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BA_LITE, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_LITE, dam, 4, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::LITE, dam, 4, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_LITE);
#include "mspell/mspell-damage-calculator.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/player-type-definition.h"
}
const auto dam = monspell_damage(player_ptr, RF_ABILITY::SHOOT, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_ARROW, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::ARROW, dam, TARGET_TYPE);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_ACID, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_ACID, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::ACID, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_ACID);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_ELEC, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_ELEC, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::ELEC, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_ELEC);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_FIRE, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_FIRE, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::FIRE, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_FIRE);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_COLD, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_COLD, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::COLD, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_COLD);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_NETH, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_NETHER, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::NETHER, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_NETH);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_WATE, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_WATER, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::WATER, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
}
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_MANA, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_MANA, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::MANA, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
}
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_PLAS, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_PLASMA, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::PLASMA, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
}
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BO_ICEE, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_ICE, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::ICE, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_COLD);
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::MISSILE, m_idx, DAM_ROLL);
- const auto proj_res = bolt(player_ptr, m_idx, y, x, GF_MISSILE, dam, TARGET_TYPE);
+ const auto proj_res = bolt(player_ptr, m_idx, y, x, AttributeType::MISSILE, dam, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
update_smart_learn(player_ptr, m_idx, DRS_REFLECT);
}
#include "mspell/mspell-damage-calculator.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-type-definition.h"
#include "system/player-type-definition.h"
* @param GF_TYPE 魔法効果
* @return 表示したらTRUE、しなかったらFALSE
*/
-static bool spell_RF4_BREATH_special_message(MONSTER_IDX r_idx, int GF_TYPE, concptr m_name)
+static bool spell_RF4_BREATH_special_message(MONSTER_IDX r_idx, AttributeType GF_TYPE, concptr m_name)
{
- if (r_idx == MON_JAIAN && GF_TYPE == GF_SOUND) {
+ if (r_idx == MON_JAIAN && GF_TYPE == AttributeType::SOUND) {
msg_format(_("%^s「ボォエ～～～～～～」", "%^s sings, 'Booooeeeeee'"), m_name);
return true;
}
- if (r_idx == MON_BOTEI && GF_TYPE == GF_SHARDS) {
+ if (r_idx == MON_BOTEI && GF_TYPE == AttributeType::SHARDS) {
msg_format(_("%^s「ボ帝ビルカッター！！！」", "%^s shouts, 'Boty-Build cutter!!!'"), m_name);
return true;
}
- if (r_idx == MON_RAOU &&GF_TYPE == GF_FORCE) {
+ if (r_idx == MON_RAOU && GF_TYPE == AttributeType::FORCE) {
if (one_in_(2))
msg_format(_("%^s「北斗剛掌波！！」", "%^s says, 'Hokuto Goh-Sho-Ha!!'"), m_name);
else
*
* プレイヤーに当たったらラーニング可。
*/
-MonsterSpellResult spell_RF4_BREATH(player_type *player_ptr, int GF_TYPE, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx, int TARGET_TYPE)
+MonsterSpellResult spell_RF4_BREATH(player_type *player_ptr, AttributeType GF_TYPE, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx, int TARGET_TYPE)
{
HIT_POINT dam, drs_type = 0;
concptr type_s;
monster_name(player_ptr, t_idx, t_name);
switch (GF_TYPE) {
- case GF_ACID:
+ case AttributeType::ACID:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_ACID, m_idx, DAM_ROLL);
type_s = _("酸", "acid");
drs_type = DRS_ACID;
break;
- case GF_ELEC:
+ case AttributeType::ELEC:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_ELEC, m_idx, DAM_ROLL);
type_s = _("稲妻", "lightning");
drs_type = DRS_ELEC;
break;
- case GF_FIRE:
+ case AttributeType::FIRE:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_FIRE, m_idx, DAM_ROLL);
type_s = _("火炎", "fire");
drs_type = DRS_FIRE;
break;
- case GF_COLD:
+ case AttributeType::COLD:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_COLD, m_idx, DAM_ROLL);
type_s = _("冷気", "frost");
drs_type = DRS_COLD;
break;
- case GF_POIS:
+ case AttributeType::POIS:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_POIS, m_idx, DAM_ROLL);
type_s = _("ガス", "gas");
drs_type = DRS_POIS;
break;
- case GF_NETHER:
+ case AttributeType::NETHER:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_NETH, m_idx, DAM_ROLL);
type_s = _("地獄", "nether");
drs_type = DRS_NETH;
break;
- case GF_LITE:
+ case AttributeType::LITE:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_LITE, m_idx, DAM_ROLL);
type_s = _("閃光", "light");
drs_type = DRS_LITE;
break;
- case GF_DARK:
+ case AttributeType::DARK:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_DARK, m_idx, DAM_ROLL);
type_s = _("暗黒", "darkness");
drs_type = DRS_DARK;
break;
- case GF_CONFUSION:
+ case AttributeType::CONFUSION:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_CONF, m_idx, DAM_ROLL);
type_s = _("混乱", "confusion");
drs_type = DRS_CONF;
break;
- case GF_SOUND:
+ case AttributeType::SOUND:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_SOUN, m_idx, DAM_ROLL);
type_s = _("轟音", "sound");
drs_type = DRS_SOUND;
break;
- case GF_CHAOS:
+ case AttributeType::CHAOS:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_CHAO, m_idx, DAM_ROLL);
type_s = _("カオス", "chaos");
drs_type = DRS_CHAOS;
break;
- case GF_DISENCHANT:
+ case AttributeType::DISENCHANT:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_DISE, m_idx, DAM_ROLL);
type_s = _("劣化", "disenchantment");
drs_type = DRS_DISEN;
break;
- case GF_NEXUS:
+ case AttributeType::NEXUS:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_NEXU, m_idx, DAM_ROLL);
type_s = _("因果混乱", "nexus");
drs_type = DRS_NEXUS;
break;
- case GF_TIME:
+ case AttributeType::TIME:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_TIME, m_idx, DAM_ROLL);
type_s = _("時間逆転", "time");
smart_learn_aux = false;
break;
- case GF_INERTIAL:
+ case AttributeType::INERTIAL:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_INER, m_idx, DAM_ROLL);
type_s = _("遅鈍", "inertia");
smart_learn_aux = false;
break;
- case GF_GRAVITY:
+ case AttributeType::GRAVITY:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_GRAV, m_idx, DAM_ROLL);
type_s = _("重力", "gravity");
smart_learn_aux = false;
break;
- case GF_SHARDS:
+ case AttributeType::SHARDS:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_SHAR, m_idx, DAM_ROLL);
type_s = _("破片", "shards");
drs_type = DRS_SHARD;
break;
- case GF_PLASMA:
+ case AttributeType::PLASMA:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_PLAS, m_idx, DAM_ROLL);
type_s = _("プラズマ", "plasma");
smart_learn_aux = false;
break;
- case GF_FORCE:
+ case AttributeType::FORCE:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_FORC, m_idx, DAM_ROLL);
type_s = _("フォース", "force");
smart_learn_aux = false;
break;
- case GF_MANA:
+ case AttributeType::MANA:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_MANA, m_idx, DAM_ROLL);
type_s = _("魔力", "mana");
smart_learn_aux = false;
break;
- case GF_NUKE:
+ case AttributeType::NUKE:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_NUKE, m_idx, DAM_ROLL);
type_s = _("放射性廃棄物", "toxic waste");
drs_type = DRS_POIS;
break;
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
dam = monspell_damage(player_ptr, RF_ABILITY::BR_DISI, m_idx, DAM_ROLL);
type_s = _("分解", "disintegration");
smart_learn_aux = false;
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct MonsterSpellResult;
struct player_type;
-MonsterSpellResult spell_RF4_BREATH(player_type *player_ptr, int GF_TYPE, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx, int TARGET_TYPE);
+MonsterSpellResult spell_RF4_BREATH(player_type *player_ptr, AttributeType GF_TYPE, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx, int TARGET_TYPE);
#include "dungeon/dungeon-flag-types.h"
#include "dungeon/dungeon.h"
#include "dungeon/quest.h"
+#include "effect/attribute-types.h"
#include "effect/effect-characteristics.h"
#include "effect/effect-processor.h"
#include "floor/cave.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
#include "spell/range-calc.h"
-#include "spell/spell-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
* @param monspell モンスター魔法のID
* @param target_type モンスターからモンスターへ撃つならMONSTER_TO_MONSTER、モンスターからプレイヤーならMONSTER_TO_PLAYER
*/
-ProjectResult bolt(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, EFFECT_ID typ, int dam_hp, int target_type)
+ProjectResult bolt(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type)
{
BIT_FLAGS flg = 0;
switch (target_type) {
break;
}
- if (typ != GF_ARROW)
+ if (typ != AttributeType::ARROW)
flg |= PROJECT_REFLECTABLE;
return project(player_ptr, m_idx, 0, y, x, dam_hp, typ, flg);
* @param monspell モンスター魔法のID
* @param target_type モンスターからモンスターへ撃つならMONSTER_TO_MONSTER、モンスターからプレイヤーならMONSTER_TO_PLAYER
*/
-ProjectResult beam(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, EFFECT_ID typ, int dam_hp, int target_type)
+ProjectResult beam(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type)
{
BIT_FLAGS flg = 0;
switch (target_type) {
* @param monspell モンスター魔法のID
* @param target_type モンスターからモンスターへ撃つならMONSTER_TO_MONSTER、モンスターからプレイヤーならMONSTER_TO_PLAYER
*/
-ProjectResult breath(player_type *player_ptr, POSITION y, POSITION x, MONSTER_IDX m_idx, EFFECT_ID typ, int dam_hp, POSITION rad, bool breath, int target_type)
+ProjectResult breath(player_type *player_ptr, POSITION y, POSITION x, MONSTER_IDX m_idx, AttributeType typ, int dam_hp, POSITION rad, bool breath, int target_type)
{
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
rad = 0 - rad;
switch (typ) {
- case GF_ROCKET:
+ case AttributeType::ROCKET:
flg |= PROJECT_STOP;
break;
- case GF_DRAIN_MANA:
- case GF_MIND_BLAST:
- case GF_BRAIN_SMASH:
- case GF_CAUSE_1:
- case GF_CAUSE_2:
- case GF_CAUSE_3:
- case GF_CAUSE_4:
- case GF_HAND_DOOM:
+ case AttributeType::DRAIN_MANA:
+ case AttributeType::MIND_BLAST:
+ case AttributeType::BRAIN_SMASH:
+ case AttributeType::CAUSE_1:
+ case AttributeType::CAUSE_2:
+ case AttributeType::CAUSE_3:
+ case AttributeType::CAUSE_4:
+ case AttributeType::HAND_DOOM:
flg |= (PROJECT_HIDE | PROJECT_AIMED);
break;
+ default:
+ break;
}
return project(player_ptr, m_idx, rad, y, x, dam_hp, typ, flg);
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct ProjectResult;
enum class RF_ABILITY;
bool summon_possible(player_type *player_ptr, POSITION y1, POSITION x1);
bool raise_possible(player_type *player_ptr, monster_type *m_ptr);
bool spell_is_inate(RF_ABILITY spell);
-ProjectResult beam(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, EFFECT_ID typ, int dam_hp, int target_type);
-ProjectResult bolt(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, EFFECT_ID typ, int dam_hp, int target_type);
+ProjectResult beam(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type);
+ProjectResult bolt(player_type *player_ptr, MONSTER_IDX m_idx, POSITION y, POSITION x, AttributeType typ, int dam_hp, int target_type);
ProjectResult breath(
- player_type *player_ptr, POSITION y, POSITION x, MONSTER_IDX m_idx, EFFECT_ID typ, int dam_hp, POSITION rad, bool breath, int target_type);
+ player_type *player_ptr, POSITION y, POSITION x, MONSTER_IDX m_idx, AttributeType typ, int dam_hp, POSITION rad, bool breath, int target_type);
#include "mspell/mspell-damage-calculator.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
#include "system/floor-type-definition.h"
#include "system/player-type-definition.h"
#include "view/display-messages.h"
* @param MS_TYPE 呪文の番号
* @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
*/
-static MonsterSpellResult spell_RF5_CAUSE(player_type *player_ptr, int GF_TYPE, HIT_POINT dam, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx,
+static MonsterSpellResult spell_RF5_CAUSE(player_type *player_ptr, AttributeType GF_TYPE, HIT_POINT dam, POSITION y, POSITION x, MONSTER_IDX m_idx, MONSTER_IDX t_idx,
concptr msg1, concptr msg2, concptr msg3, int TARGET_TYPE)
{
auto res = MonsterSpellResult::make_valid(dam);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::CAUSE_1, m_idx, DAM_ROLL);
- return spell_RF5_CAUSE(player_ptr, GF_CAUSE_1, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
+ return spell_RF5_CAUSE(player_ptr, AttributeType::CAUSE_1, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
}
/*!
const auto dam = monspell_damage(player_ptr, RF_ABILITY::CAUSE_2, m_idx, DAM_ROLL);
- return spell_RF5_CAUSE(player_ptr, GF_CAUSE_2, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
+ return spell_RF5_CAUSE(player_ptr, AttributeType::CAUSE_2, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
}
/*!
const auto dam = monspell_damage(player_ptr, RF_ABILITY::CAUSE_3, m_idx, DAM_ROLL);
- return spell_RF5_CAUSE(player_ptr, GF_CAUSE_3, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
+ return spell_RF5_CAUSE(player_ptr, AttributeType::CAUSE_3, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
}
/*!
const auto dam = monspell_damage(player_ptr, RF_ABILITY::CAUSE_4, m_idx, DAM_ROLL);
- return spell_RF5_CAUSE(player_ptr, GF_CAUSE_4, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
+ return spell_RF5_CAUSE(player_ptr, AttributeType::CAUSE_4, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, TARGET_TYPE);
}
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
}
} else if (monster_to_monster) {
if (can_use_lite_area) {
- (void)project(player_ptr, m_idx, 3, y, x, 0, GF_LITE_WEAK, PROJECT_GRID | PROJECT_KILL);
+ (void)project(player_ptr, m_idx, 3, y, x, 0, AttributeType::LITE_WEAK, PROJECT_GRID | PROJECT_KILL);
lite_room(player_ptr, y, x);
} else {
- (void)project(player_ptr, m_idx, 3, y, x, 0, GF_DARK_WEAK, PROJECT_GRID | PROJECT_KILL);
+ (void)project(player_ptr, m_idx, 3, y, x, 0, AttributeType::DARK_WEAK, PROJECT_GRID | PROJECT_KILL);
unlite_room(player_ptr, y, x);
}
}
#include "realm/realm-song-numbers.h"
#include "spell-realm/spells-song.h"
#include "spell/range-calc.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
* @param is_friend TRUEならば、プレイヤーを巻き込む時にブレスの判定をFALSEにする。
* @return ブレスを直接当てられるならばTRUEを返す
*/
-bool breath_direct(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, POSITION rad, EFFECT_ID typ, bool is_friend)
+bool breath_direct(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, POSITION rad, AttributeType typ, bool is_friend)
{
BIT_FLAGS flg;
switch (typ) {
- case GF_LITE:
- case GF_LITE_WEAK:
+ case AttributeType::LITE:
+ case AttributeType::LITE_WEAK:
flg = PROJECT_LOS;
break;
- case GF_DISINTEGRATE:
+ case AttributeType::DISINTEGRATE:
flg = PROJECT_DISI;
break;
default:
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct monster_type;
struct player_type;
bool direct_beam(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, monster_type *m_ptr);
-bool breath_direct(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, POSITION rad, EFFECT_ID typ, bool is_friend);
+bool breath_direct(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2, POSITION rad, AttributeType typ, bool is_friend);
void get_project_point(player_type *player_ptr, POSITION sy, POSITION sx, POSITION *ty, POSITION *tx, BIT_FLAGS flg);
bool dispel_check_monster(player_type *player_ptr, MONSTER_IDX m_idx, MONSTER_IDX t_idx);
bool dispel_check(player_type *player_ptr, MONSTER_IDX m_idx);
#include "mspell/mspell-damage-calculator.h"
#include "mspell/mspell-util.h"
#include "mspell/mspell.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
/*!
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::ROCKET, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_ROCKET, dam, 2, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::ROCKET, dam, 2, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_SHARD);
ProjectResult proj_res;
if (TARGET_TYPE == MONSTER_TO_PLAYER) {
const auto dam = monspell_damage(player_ptr, RF_ABILITY::HAND_DOOM, m_idx, DAM_ROLL);
- proj_res = breath(player_ptr, y, x, m_idx, GF_HAND_DOOM, dam, 0, false, MONSTER_TO_PLAYER);
+ proj_res = breath(player_ptr, y, x, m_idx, AttributeType::HAND_DOOM, dam, 0, false, MONSTER_TO_PLAYER);
} else if (TARGET_TYPE == MONSTER_TO_MONSTER) {
const auto dam = 20; /* Dummy power */
- proj_res = breath(player_ptr, y, x, m_idx, GF_HAND_DOOM, dam, 0, false, MONSTER_TO_MONSTER);
+ proj_res = breath(player_ptr, y, x, m_idx, AttributeType::HAND_DOOM, dam, 0, false, MONSTER_TO_MONSTER);
}
auto res = MonsterSpellResult::make_valid();
monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
const auto dam = monspell_damage(player_ptr, RF_ABILITY::PSY_SPEAR, m_idx, DAM_ROLL);
- const auto proj_res = beam(player_ptr, m_idx, y, x, GF_PSY_SPEAR, dam, MONSTER_TO_PLAYER);
+ const auto proj_res = beam(player_ptr, m_idx, y, x, AttributeType::PSY_SPEAR, dam, MONSTER_TO_PLAYER);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
#include "player/player-damage.h"
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-crusade.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
GAME_TEXT m_name_self[MAX_MONSTER_NAME];
monster_desc(player_ptr, m_name_self, m_ptr, MD_PRON_VISIBLE | MD_POSSESSIVE | MD_OBJECTIVE);
msg_format(_("攻撃が%s自身を傷つけた！", "The attack of %s has wounded %s!"), m_name, m_name_self);
- project(player_ptr, 0, 0, m_ptr->fy, m_ptr->fx, get_damage, GF_MISSILE, PROJECT_KILL);
+ project(player_ptr, 0, 0, m_ptr->fy, m_ptr->fx, get_damage, AttributeType::MISSILE, PROJECT_KILL);
set_tim_eyeeye(player_ptr, player_ptr->tim_eyeeye - 5, true);
}
}
#include "mspell/mspell.h"
#include "player/player-personality-types.h"
#include "player/player-status-flags.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
#include "system/floor-type-definition.h"
}
const auto dam = monspell_damage(player_ptr, RF_ABILITY::DRAIN_MANA, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_DRAIN_MANA, dam, 0, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::DRAIN_MANA, dam, 0, false, TARGET_TYPE);
if (TARGET_TYPE == MONSTER_TO_PLAYER)
update_smart_learn(player_ptr, m_idx, DRS_MANA);
}
const auto dam = monspell_damage(player_ptr, RF_ABILITY::MIND_BLAST, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_MIND_BLAST, dam, 0, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::MIND_BLAST, dam, 0, false, TARGET_TYPE);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
}
const auto dam = monspell_damage(player_ptr, RF_ABILITY::BRAIN_SMASH, m_idx, DAM_ROLL);
- const auto proj_res = breath(player_ptr, y, x, m_idx, GF_BRAIN_SMASH, dam, 0, false, TARGET_TYPE);
+ const auto proj_res = breath(player_ptr, y, x, m_idx, AttributeType::BRAIN_SMASH, dam, 0, false, TARGET_TYPE);
auto res = MonsterSpellResult::make_valid(dam);
res.learnable = proj_res.affected_player;
#include "mspell/mspell.h"
#include "mspell/specified-summon.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-summon.h"
#include "spell/summon-types.h"
#include "system/floor-type-definition.h"
#include "mspell/mspell-checker.h"
#include "mspell/mspell-util.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/summon-types.h"
#include "system/monster-race-definition.h"
#include "system/player-type-definition.h"
simple_monspell_message(player_ptr, m_idx, t_idx, msg, TARGET_TYPE);
if (mon_to_player)
- fire_ball_hide(player_ptr, GF_WATER_FLOW, 0, 3, 8);
+ fire_ball_hide(player_ptr, AttributeType::WATER_FLOW, 0, 3, 8);
else if (mon_to_mon)
- project(player_ptr, t_idx, 8, y, x, 3, GF_WATER_FLOW, PROJECT_GRID | PROJECT_HIDE);
+ project(player_ptr, t_idx, 8, y, x, 3, AttributeType::WATER_FLOW, PROJECT_GRID | PROJECT_HIDE);
}
int count = 0;
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/summon-types.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
disturb(player_ptr, false, true);
msg_print(_("ブゥーーッ！おっと。", "BRRAAAP! Oops."));
msg_print(nullptr);
- fire_ball(player_ptr, GF_POIS, 0, player_ptr->lev, 3);
+ fire_ball(player_ptr, AttributeType::POIS, 0, player_ptr->lev, 3);
}
if (player_ptr->muta.has(MUTA::PROD_MANA) && !player_ptr->anti_magic && one_in_(9000)) {
flush();
msg_print(nullptr);
(void)get_hack_dir(player_ptr, &dire);
- fire_ball(player_ptr, GF_MANA, dire, player_ptr->lev * 2, 3);
+ fire_ball(player_ptr, AttributeType::MANA, dire, player_ptr->lev * 2, 3);
}
if (player_ptr->muta.has(MUTA::ATT_DEMON) && !player_ptr->anti_magic && (randint1(6666) == 666)) {
disturb(player_ptr, false, true);
msg_print(_("周りの空間が歪んでいる気がする！", "You feel the world warping around you!"));
msg_print(nullptr);
- fire_ball(player_ptr, GF_CHAOS, 0, player_ptr->lev, 8);
+ fire_ball(player_ptr, AttributeType::CHAOS, 0, player_ptr->lev, 8);
}
if (player_ptr->muta.has(MUTA::NORMALITY) && one_in_(5000)) {
#include "hpmp/hp-mp-processor.h"
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-specific-bolt.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_MISSILE, dir, damroll(2, 6));
+ (void)fire_bolt(player_ptr, AttributeType::MISSILE, dir, damroll(2, 6));
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_ARROW, dir, 150);
+ (void)fire_bolt(player_ptr, AttributeType::ARROW, dir, 150);
return true;
}
return false;
msg_print(_("あなたはエレメントのブレスを吐いた。", "You breathe the elements."));
- fire_breath(player_ptr, GF_MISSILE, dir, 300, 4);
+ fire_breath(player_ptr, AttributeType::MISSILE, dir, 300, 4);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_ACID, dir, damroll(5, 8));
+ (void)fire_bolt(player_ptr, AttributeType::ACID, dir, damroll(5, 8));
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_ELEC, dir, damroll(4, 8));
+ (void)fire_bolt(player_ptr, AttributeType::ELEC, dir, damroll(4, 8));
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_FIRE, dir, damroll(9, 8));
+ (void)fire_bolt(player_ptr, AttributeType::FIRE, dir, damroll(9, 8));
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_COLD, dir, damroll(6, 8));
+ (void)fire_bolt(player_ptr, AttributeType::COLD, dir, damroll(6, 8));
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_bolt(player_ptr, GF_ARROW, dir, 150);
+ (void)fire_bolt(player_ptr, AttributeType::ARROW, dir, 150);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_POIS, dir, 12, 3);
+ (void)fire_ball(player_ptr, AttributeType::POIS, dir, 12, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_COLD, dir, 48, 2);
+ (void)fire_ball(player_ptr, AttributeType::COLD, dir, 48, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_COLD, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::COLD, dir, 100, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_COLD, dir, 400, 3);
+ (void)fire_ball(player_ptr, AttributeType::COLD, dir, 400, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_FIRE, dir, 72, 2);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, 72, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_FIRE, dir, 120, 3);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, 120, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_FIRE, dir, 300, 3);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, 300, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_FIRE, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, 100, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_ELEC, dir, 100, 3);
+ (void)fire_ball(player_ptr, AttributeType::ELEC, dir, 100, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_ELEC, dir, 500, 3);
+ (void)fire_ball(player_ptr, AttributeType::ELEC, dir, 500, 3);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_ACID, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::ACID, dir, 100, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_NUKE, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::NUKE, dir, 100, 2);
return true;
}
return false;
msg_print(_("ロケットを発射した！", "You launch a rocket!"));
- (void)fire_ball(player_ptr, GF_ROCKET, dir, 250 + player_ptr->lev * 3, 2);
+ (void)fire_ball(player_ptr, AttributeType::ROCKET, dir, 250 + player_ptr->lev * 3, 2);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_WATER, dir, 200, 3);
+ (void)fire_ball(player_ptr, AttributeType::WATER, dir, 200, 3);
return true;
}
break;
}
- project(player_ptr, 0, 3, y, x, 150, GF_ELEC, PROJECT_THRU | PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
+ project(player_ptr, 0, 3, y, x, 150, AttributeType::ELEC, PROJECT_THRU | PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
}
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_DARK, dir, 250, 4);
+ (void)fire_ball(player_ptr, AttributeType::DARK, dir, 250, 4);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_MANA, dir, 250, 4);
+ (void)fire_ball(player_ptr, AttributeType::MANA, dir, 250, 4);
return true;
}
#include "spell-kind/spells-launcher.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/element-resistance.h"
#include "sv-definition/sv-ring-types.h"
#include "system/object-type-definition.h"
auto resistance_flags = object_flags(o_ptr);
- int type[20];
+ AttributeType type[20];
int n = 0;
concptr name[20];
for (int i = 0; dragonbreath_info[i].flag != 0; i++) {
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_breath(player_ptr, GF_FIRE, dir, 200, 2);
+ fire_breath(player_ptr, AttributeType::FIRE, dir, 200, 2);
if ((o_ptr->tval == ItemKindType::RING) && (o_ptr->sval == SV_RING_FLAMES))
(void)set_oppose_fire(player_ptr, randint1(20) + 20, false);
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_breath(player_ptr, GF_COLD, dir, 200, 2);
+ fire_breath(player_ptr, AttributeType::COLD, dir, 200, 2);
if ((o_ptr->tval == ItemKindType::RING) && (o_ptr->sval == SV_RING_ICE))
(void)set_oppose_cold(player_ptr, randint1(20) + 20, false);
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/bad-status-setter.h"
#include "status/body-improvement.h"
bool activate_grand_cross(player_type *player_ptr)
{
msg_print(_("「闇に還れ！」", "You say, 'Return to darkness!'"));
- (void)project(player_ptr, 0, 8, player_ptr->y, player_ptr->x, (randint1(100) + 200) * 2, GF_HOLY_FIRE, PROJECT_KILL | PROJECT_ITEM | PROJECT_GRID);
+ (void)project(player_ptr, 0, 8, player_ptr->y, player_ptr->x, (randint1(100) + 200) * 2, AttributeType::HOLY_FIRE, PROJECT_KILL | PROJECT_ITEM | PROJECT_GRID);
return true;
}
bool activate_blinding_light(player_type *player_ptr, concptr name)
{
msg_format(_("%sが眩しい光で輝いた...", "The %s gleams with blinding light..."), name);
- (void)fire_ball(player_ptr, GF_LITE, 0, 300, 6);
+ (void)fire_ball(player_ptr, AttributeType::LITE, 0, 300, 6);
confuse_monsters(player_ptr, 3 * player_ptr->lev / 2);
return true;
}
#include "object-activation/activation-resistance.h"
#include "hpmp/hp-mp-processor.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/buff-setter.h"
#include "status/element-resistance.h"
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_ACID, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::ACID, dir, 100, 2);
(void)set_oppose_acid(player_ptr, randint1(20) + 20, false);
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_ELEC, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::ELEC, dir, 100, 2);
(void)set_oppose_elec(player_ptr, randint1(20) + 20, false);
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_FIRE, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, 100, 2);
(void)set_oppose_fire(player_ptr, randint1(20) + 20, false);
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_COLD, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::COLD, dir, 100, 2);
(void)set_oppose_cold(player_ptr, randint1(20) + 20, false);
return true;
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball(player_ptr, GF_POIS, dir, 100, 2);
+ (void)fire_ball(player_ptr, AttributeType::POIS, dir, 100, 2);
(void)set_oppose_pois(player_ptr, randint1(20) + 20, false);
return true;
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_beam(player_ptr, GF_AWAY_ALL, dir, player_ptr->lev);
+ (void)fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, player_ptr->lev);
return true;
}
#include "object-enchant/dragon-breaths-table.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
/*!
* @brief 装備耐性に準じたブレス効果の選択テーブル /
* Define flags, effect type, name for dragon breath activation
*/
const dragonbreath_type dragonbreath_info[] = {
- { TR_RES_ACID, GF_ACID, _("酸", "acid") },
- { TR_RES_ELEC, GF_ELEC, _("電撃", "lightning") },
- { TR_RES_FIRE, GF_FIRE, _("火炎", "fire") },
- { TR_RES_COLD, GF_COLD, _("冷気", "cold") },
- { TR_RES_POIS, GF_POIS, _("毒", "poison") },
- { TR_RES_LITE, GF_LITE, _("閃光", "light") },
- { TR_RES_DARK, GF_DARK, _("暗黒", "dark") },
- { TR_RES_SHARDS, GF_SHARDS, _("破片", "shards") },
- { TR_RES_CONF, GF_CONFUSION, _("混乱", "confusion") },
- { TR_RES_SOUND, GF_SOUND, _("轟音", "sound") },
- { TR_RES_NEXUS, GF_NEXUS, _("因果混乱", "nexus") },
- { TR_RES_NETHER, GF_NETHER, _("地獄", "nether") },
- { TR_RES_CHAOS, GF_CHAOS, _("カオス", "chaos") },
- { TR_RES_DISEN, GF_DISENCHANT, _("劣化", "disenchantment") },
- { TR_STR, 0, nullptr }
+ { TR_RES_ACID, AttributeType::ACID, _("酸", "acid") },
+ { TR_RES_ELEC, AttributeType::ELEC, _("電撃", "lightning") },
+ { TR_RES_FIRE, AttributeType::FIRE, _("火炎", "fire") },
+ { TR_RES_COLD, AttributeType::COLD, _("冷気", "cold") },
+ { TR_RES_POIS, AttributeType::POIS, _("毒", "poison") },
+ { TR_RES_LITE, AttributeType::LITE, _("閃光", "light") },
+ { TR_RES_DARK, AttributeType::DARK, _("暗黒", "dark") },
+ { TR_RES_SHARDS, AttributeType::SHARDS, _("破片", "shards") },
+ { TR_RES_CONF, AttributeType::CONFUSION, _("混乱", "confusion") },
+ { TR_RES_SOUND, AttributeType::SOUND, _("轟音", "sound") },
+ { TR_RES_NEXUS, AttributeType::NEXUS, _("因果混乱", "nexus") },
+ { TR_RES_NETHER, AttributeType::NETHER, _("地獄", "nether") },
+ { TR_RES_CHAOS, AttributeType::CHAOS, _("カオス", "chaos") },
+ { TR_RES_DISEN, AttributeType::DISENCHANT, _("劣化", "disenchantment") },
+ { TR_STR, AttributeType::NONE, nullptr }
};
#include "system/angband.h"
#include "object-enchant/tr-types.h"
+#include "effect/attribute-types.h"
typedef struct {
tr_type flag;
- int type;
+ AttributeType type;
concptr name;
} dragonbreath_type;
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-object.h"
#include "spell/spells-summon.h"
#include "spell/summon-types.h"
break;
}
case SV_SCROLL_FIRE: {
- fire_ball(this->player_ptr, GF_FIRE, 0, 666, 4);
+ fire_ball(this->player_ptr, AttributeType::FIRE, 0, 666, 4);
if (!(is_oppose_fire(this->player_ptr) || has_resist_fire(this->player_ptr) || has_immune_fire(this->player_ptr)))
take_hit(this->player_ptr, DAMAGE_NOESCAPE, 50 + randint1(50), _("炎の巻物", "a Scroll of Fire"));
break;
}
case SV_SCROLL_ICE: {
- fire_ball(this->player_ptr, GF_ICE, 0, 777, 4);
+ fire_ball(this->player_ptr, AttributeType::ICE, 0, 777, 4);
if (!(is_oppose_cold(this->player_ptr) || has_resist_cold(this->player_ptr) || has_immune_cold(this->player_ptr)))
take_hit(this->player_ptr, DAMAGE_NOESCAPE, 100 + randint1(100), _("氷の巻物", "a Scroll of Ice"));
break;
}
case SV_SCROLL_CHAOS: {
- fire_ball(this->player_ptr, GF_CHAOS, 0, 1000, 4);
+ fire_ball(this->player_ptr, AttributeType::CHAOS, 0, 1000, 4);
if (!has_resist_chaos(this->player_ptr))
take_hit(this->player_ptr, DAMAGE_NOESCAPE, 111 + randint1(111), _("ログルスの巻物", "a Scroll of Logrus"));
#include "player/player-status-table.h"
#include "racial/racial-android.h"
#include "specific-object/torch.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-type-definition.h"
this->m_ptr->hp - this->tdam, this->m_ptr->maxhp, this->m_ptr->max_maxhp);
auto fear = false;
- EffectFlags effect_flags{};
- effect_flags.set(GF_PLAYER_SHOOT);
+ AttributeFlags attribute_flags{};
+ attribute_flags.set(AttributeType::PLAYER_SHOOT);
if (is_active_torch(this->o_ptr))
- effect_flags.set(GF_FIRE);
+ attribute_flags.set(AttributeType::FIRE);
- MonsterDamageProcessor mdp(this->player_ptr, this->g_ptr->m_idx, this->tdam, &fear, effect_flags);
+ MonsterDamageProcessor mdp(this->player_ptr, this->g_ptr->m_idx, this->tdam, &fear, attribute_flags);
if (mdp.mon_take_hit(extract_note_dies(real_r_idx(this->m_ptr)))) {
return;
}
#include "object-enchant/tr-types.h"
#include "object/object-flags.h"
#include "object/object-kind.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "sv-definition/sv-potion-types.h"
#include "system/object-type-definition.h"
#include "system/player-type-definition.h"
bool potion_smash_effect(player_type *player_ptr, MONSTER_IDX who, POSITION y, POSITION x, KIND_OBJECT_IDX k_idx)
{
int radius = 2;
- int dt = 0;
+ AttributeType dt = AttributeType::NONE;
int dam = 0;
bool angry = false;
object_kind *k_ptr = &k_info[k_idx];
/* All of the above potions have no effect when shattered */
return false;
case SV_POTION_SLOWNESS:
- dt = GF_OLD_SLOW;
+ dt = AttributeType::OLD_SLOW;
dam = 5;
angry = true;
break;
case SV_POTION_POISON:
- dt = GF_POIS;
+ dt = AttributeType::POIS;
dam = 3;
angry = true;
break;
case SV_POTION_BLINDNESS:
- dt = GF_DARK;
+ dt = AttributeType::DARK;
angry = true;
break;
case SV_POTION_BOOZE:
- dt = GF_OLD_CONF;
+ dt = AttributeType::OLD_CONF;
angry = true;
break;
case SV_POTION_SLEEP:
- dt = GF_OLD_SLEEP;
+ dt = AttributeType::OLD_SLEEP;
angry = true;
break;
case SV_POTION_RUINATION:
case SV_POTION_DETONATIONS:
- dt = GF_SHARDS;
+ dt = AttributeType::SHARDS;
dam = damroll(25, 25);
angry = true;
break;
case SV_POTION_DEATH:
- dt = GF_DEATH_RAY;
+ dt = AttributeType::DEATH_RAY;
dam = k_ptr->level * 10;
angry = true;
radius = 1;
break;
case SV_POTION_SPEED:
- dt = GF_OLD_SPEED;
+ dt = AttributeType::OLD_SPEED;
break;
case SV_POTION_CURE_LIGHT:
- dt = GF_OLD_HEAL;
+ dt = AttributeType::OLD_HEAL;
dam = damroll(2, 3);
break;
case SV_POTION_CURE_SERIOUS:
- dt = GF_OLD_HEAL;
+ dt = AttributeType::OLD_HEAL;
dam = damroll(4, 3);
break;
case SV_POTION_CURE_CRITICAL:
case SV_POTION_CURING:
- dt = GF_OLD_HEAL;
+ dt = AttributeType::OLD_HEAL;
dam = damroll(6, 3);
break;
case SV_POTION_HEALING:
- dt = GF_OLD_HEAL;
+ dt = AttributeType::OLD_HEAL;
dam = damroll(10, 10);
break;
case SV_POTION_RESTORE_EXP:
- dt = GF_STAR_HEAL;
+ dt = AttributeType::STAR_HEAL;
dam = 0;
radius = 1;
break;
case SV_POTION_LIFE:
- dt = GF_STAR_HEAL;
+ dt = AttributeType::STAR_HEAL;
dam = damroll(50, 50);
radius = 1;
break;
case SV_POTION_STAR_HEALING:
- dt = GF_OLD_HEAL;
+ dt = AttributeType::OLD_HEAL;
dam = damroll(50, 50);
radius = 1;
break;
case SV_POTION_RESTORE_MANA:
- dt = GF_MANA;
+ dt = AttributeType::MANA;
dam = damroll(10, 10);
radius = 1;
break;
case SV_POTION_POLY_SELF:
- dt = GF_NEXUS;
+ dt = AttributeType::NEXUS;
dam = damroll(20, 20);
radius = 1;
break;
#include "core/disturbance.h"
#include "dungeon/dungeon-flag-types.h"
#include "dungeon/dungeon.h"
+#include "effect/attribute-types.h"
#include "flavor/flavor-describer.h"
#include "flavor/object-flavor-types.h"
#include "floor/cave.h"
#include "player/player-status-flags.h"
#include "player/player-status-resist.h"
#include "player/special-defense-types.h"
-#include "spell/spell-types.h"
#include "status/element-resistance.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
* @param dam 基本ダメージ
* @param max 算出した最大ダメージを返すポインタ
*/
-static void spell_damcalc(player_type *player_ptr, monster_type *m_ptr, EFFECT_ID typ, HIT_POINT dam, int *max)
+static void spell_damcalc(player_type *player_ptr, monster_type *m_ptr, AttributeType typ, HIT_POINT dam, int *max)
{
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int rlev = r_ptr->level;
/* Vulnerability, resistance and immunity */
switch (typ) {
- case GF_ELEC:
+ case AttributeType::ELEC:
if (has_immune_elec(player_ptr)) {
ignore_wraith_form = true;
}
dam = dam * calc_elec_damage_rate(player_ptr) / 100;
break;
- case GF_POIS:
+ case AttributeType::POIS:
dam = dam * calc_pois_damage_rate(player_ptr) / 100;
break;
- case GF_ACID:
+ case AttributeType::ACID:
if (has_immune_acid(player_ptr)) {
ignore_wraith_form = true;
}
dam = dam * calc_acid_damage_rate(player_ptr) / 100;
break;
- case GF_COLD:
- case GF_ICE:
+ case AttributeType::COLD:
+ case AttributeType::ICE:
if (has_immune_cold(player_ptr)) {
ignore_wraith_form = true;
}
dam = dam * calc_cold_damage_rate(player_ptr) / 100;
break;
- case GF_FIRE:
+ case AttributeType::FIRE:
if (has_immune_fire(player_ptr)) {
ignore_wraith_form = true;
}
dam = dam * calc_fire_damage_rate(player_ptr) / 100;
break;
- case GF_PSY_SPEAR:
+ case AttributeType::PSY_SPEAR:
ignore_wraith_form = true;
break;
- case GF_ARROW:
+ case AttributeType::ARROW:
if (!player_ptr->blind && (has_invuln_arrow(player_ptr))) {
dam = 0;
ignore_wraith_form = true;
}
break;
- case GF_LITE:
+ case AttributeType::LITE:
dam = dam * calc_lite_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_DARK:
+ case AttributeType::DARK:
dam = dam * calc_dark_damage_rate(player_ptr, CALC_MAX) / 100;
if (has_immune_dark(player_ptr) || player_ptr->wraith_form)
ignore_wraith_form = true;
break;
- case GF_SHARDS:
+ case AttributeType::SHARDS:
dam = dam * calc_shards_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_SOUND:
+ case AttributeType::SOUND:
dam = dam * calc_sound_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_CONFUSION:
+ case AttributeType::CONFUSION:
dam = dam * calc_conf_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_CHAOS:
+ case AttributeType::CHAOS:
dam = dam * calc_chaos_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_NETHER:
+ case AttributeType::NETHER:
dam = dam * calc_nether_damage_rate(player_ptr, CALC_MAX) / 100;
if (PlayerRace(player_ptr).equals(PlayerRaceType::SPECTRE)) {
ignore_wraith_form = true;
}
break;
- case GF_DISENCHANT:
+ case AttributeType::DISENCHANT:
dam = dam * calc_disenchant_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_NEXUS:
+ case AttributeType::NEXUS:
dam = dam * calc_nexus_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_TIME:
+ case AttributeType::TIME:
dam = dam * calc_time_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_GRAVITY:
+ case AttributeType::GRAVITY:
dam = dam * calc_gravity_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_ROCKET:
+ case AttributeType::ROCKET:
dam = dam * calc_rocket_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_NUKE:
+ case AttributeType::NUKE:
dam = dam * calc_nuke_damage_rate(player_ptr) / 100;
break;
- case GF_DEATH_RAY:
+ case AttributeType::DEATH_RAY:
dam = dam * calc_deathray_damage_rate(player_ptr, CALC_MAX) / 100;
if (dam == 0)
ignore_wraith_form = true;
break;
- case GF_HOLY_FIRE:
+ case AttributeType::HOLY_FIRE:
dam = dam * calc_holy_fire_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_HELL_FIRE:
+ case AttributeType::HELL_FIRE:
dam = dam * calc_hell_fire_damage_rate(player_ptr, CALC_MAX) / 100;
break;
- case GF_MIND_BLAST:
- case GF_BRAIN_SMASH:
+ case AttributeType::MIND_BLAST:
+ case AttributeType::BRAIN_SMASH:
if (100 + rlev / 2 <= std::max<short>(5, player_ptr->skill_sav)) {
dam = 0;
ignore_wraith_form = true;
break;
- case GF_CAUSE_1:
- case GF_CAUSE_2:
- case GF_CAUSE_3:
- case GF_HAND_DOOM:
+ case AttributeType::CAUSE_1:
+ case AttributeType::CAUSE_2:
+ case AttributeType::CAUSE_3:
+ case AttributeType::HAND_DOOM:
if (100 + rlev / 2 <= player_ptr->skill_sav) {
dam = 0;
ignore_wraith_form = true;
break;
- case GF_CAUSE_4:
+ case AttributeType::CAUSE_4:
if ((100 + rlev / 2 <= player_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU)) {
dam = 0;
ignore_wraith_form = true;
}
break;
+ default:
+ break;
}
if (player_ptr->wraith_form && !ignore_wraith_form) {
* @param m_idx 魔法を行使するモンスターのID
* @param max 算出した最大ダメージを返すポインタ
*/
-static void spell_damcalc_by_spellnum(player_type *player_ptr, RF_ABILITY ms_type, EFFECT_ID typ, MONSTER_IDX m_idx, int *max)
+static void spell_damcalc_by_spellnum(player_type *player_ptr, RF_ABILITY ms_type, AttributeType typ, MONSTER_IDX m_idx, int *max)
{
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
HIT_POINT dam = monspell_damage(player_ptr, ms_type, m_idx, DAM_MAX);
break;
case RaceBlowEffectType::ACID:
- spell_damcalc(player_ptr, m_ptr, GF_ACID, dam, &dummy_max);
+ spell_damcalc(player_ptr, m_ptr, AttributeType::ACID, dam, &dummy_max);
dam = dummy_max;
check_wraith_form = false;
break;
case RaceBlowEffectType::ELEC:
- spell_damcalc(player_ptr, m_ptr, GF_ELEC, dam, &dummy_max);
+ spell_damcalc(player_ptr, m_ptr, AttributeType::ELEC, dam, &dummy_max);
dam = dummy_max;
check_wraith_form = false;
break;
case RaceBlowEffectType::FIRE:
- spell_damcalc(player_ptr, m_ptr, GF_FIRE, dam, &dummy_max);
+ spell_damcalc(player_ptr, m_ptr, AttributeType::FIRE, dam, &dummy_max);
dam = dummy_max;
check_wraith_form = false;
break;
case RaceBlowEffectType::COLD:
- spell_damcalc(player_ptr, m_ptr, GF_COLD, dam, &dummy_max);
+ spell_damcalc(player_ptr, m_ptr, AttributeType::COLD, dam, &dummy_max);
dam = dummy_max;
check_wraith_form = false;
break;
if (d_info[player_ptr->dungeon_idx].flags.has_not(DF::NO_MAGIC)) {
if (flags.has(RF_ABILITY::BA_CHAO))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_CHAO, GF_CHAOS, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_CHAO, AttributeType::CHAOS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BA_MANA))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_MANA, GF_MANA, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_MANA, AttributeType::MANA, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BA_DARK))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_DARK, GF_DARK, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_DARK, AttributeType::DARK, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BA_LITE))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_LITE, GF_LITE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BA_LITE, AttributeType::LITE, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::HAND_DOOM))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::HAND_DOOM, GF_HAND_DOOM, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::HAND_DOOM, AttributeType::HAND_DOOM, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::PSY_SPEAR))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::PSY_SPEAR, GF_PSY_SPEAR, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::PSY_SPEAR, AttributeType::PSY_SPEAR, g_ptr->m_idx, &dam_max0);
}
if (flags.has(RF_ABILITY::ROCKET))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::ROCKET, GF_ROCKET, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::ROCKET, AttributeType::ROCKET, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_ACID))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_ACID, GF_ACID, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_ACID, AttributeType::ACID, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_ELEC))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_ELEC, GF_ELEC, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_ELEC, AttributeType::ELEC, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_FIRE))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_FIRE, GF_FIRE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_FIRE, AttributeType::FIRE, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_COLD))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_COLD, GF_COLD, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_COLD, AttributeType::COLD, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_POIS))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_POIS, GF_POIS, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_POIS, AttributeType::POIS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_NETH))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NETH, GF_NETHER, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NETH, AttributeType::NETHER, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_LITE))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_LITE, GF_LITE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_LITE, AttributeType::LITE, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_DARK))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DARK, GF_DARK, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DARK, AttributeType::DARK, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_CONF))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_CONF, GF_CONFUSION, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_CONF, AttributeType::CONFUSION, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_SOUN))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_SOUN, GF_SOUND, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_SOUN, AttributeType::SOUND, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_CHAO))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_CHAO, GF_CHAOS, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_CHAO, AttributeType::CHAOS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_DISE))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DISE, GF_DISENCHANT, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DISE, AttributeType::DISENCHANT, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_NEXU))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NEXU, GF_NEXUS, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NEXU, AttributeType::NEXUS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_TIME))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_TIME, GF_TIME, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_TIME, AttributeType::TIME, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_INER))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_INER, GF_INERTIAL, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_INER, AttributeType::INERTIAL, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_GRAV))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_GRAV, GF_GRAVITY, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_GRAV, AttributeType::GRAVITY, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_SHAR))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_SHAR, GF_SHARDS, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_SHAR, AttributeType::SHARDS, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_PLAS))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_PLAS, GF_PLASMA, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_PLAS, AttributeType::PLASMA, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_FORC))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_FORC, GF_FORCE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_FORC, AttributeType::FORCE, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_MANA))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_MANA, GF_MANA, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_MANA, AttributeType::MANA, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_NUKE))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NUKE, GF_NUKE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_NUKE, AttributeType::NUKE, g_ptr->m_idx, &dam_max0);
if (flags.has(RF_ABILITY::BR_DISI))
- spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DISI, GF_DISINTEGRATE, g_ptr->m_idx, &dam_max0);
+ spell_damcalc_by_spellnum(player_ptr, RF_ABILITY::BR_DISI, AttributeType::DISINTEGRATE, g_ptr->m_idx, &dam_max0);
}
/* Monster melee attacks */
#include "object-enchant/tr-flags.h"
#include "system/angband.h"
#include "system/system-variables.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
/*!
* @brief カオス効果種別
int drain_result{}; //!< 吸血した累積量
int drain_left{}; //!< 吸血できる残量(最大MAX_VAMPIRIC_DRAIN)
bool weak{}; //!< 打撃効果でモンスターが弱くなったかどうか
- EffectFlags effect_flags{}; //!< 与えたダメージの種類
+ AttributeFlags attribute_flags{}; //!< 与えたダメージの種類
} player_attack_type;
*/
static bool check_fear_death(player_type *player_ptr, player_attack_type *pa_ptr, const int num, const bool is_lowlevel)
{
- MonsterDamageProcessor mdp(player_ptr, pa_ptr->m_idx, pa_ptr->attack_damage, pa_ptr->fear, pa_ptr->effect_flags);
+ MonsterDamageProcessor mdp(player_ptr, pa_ptr->m_idx, pa_ptr->attack_damage, pa_ptr->fear, pa_ptr->attribute_flags);
if (!mdp.mon_take_hit(nullptr))
return false;
if (!process_attack_hit(player_ptr, pa_ptr, chance))
continue;
- pa_ptr->effect_flags = melee_effect_type(player_ptr, o_ptr, pa_ptr->mode);
+ pa_ptr->attribute_flags = melee_attribute(player_ptr, o_ptr, pa_ptr->mode);
apply_actual_attack(player_ptr, pa_ptr, &do_quake, is_zantetsu_nullified, is_ej_nullified);
calc_drain(pa_ptr);
if (check_fear_death(player_ptr, pa_ptr, num, is_lowlevel))
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-random.h"
#include "spell-kind/spells-sight.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
#include "spell/spells-summon.h"
msg_format(_("%sの声が響き渡った:", "The voice of %s booms out:"), this->name.c_str());
msg_print(_("「苦しむがよい、無能な愚か者よ！」", "'Suffer, pathetic fool!'"));
- fire_ball(player_ptr, GF_DISINTEGRATE, 0, this->player_ptr->lev * 4, 4);
+ fire_ball(player_ptr, AttributeType::DISINTEGRATE, 0, this->player_ptr->lev * 4, 4);
take_hit(player_ptr, DAMAGE_NOESCAPE, this->player_ptr->lev * 4, wrath_reason);
reward = _("分解の球が発生した。", "generating disintegration ball");
break;
#include "realm/realm-song-numbers.h"
#include "spell-kind/spells-floor.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/action-setter.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
if (mpe_mode & MPE_ENERGY_USE) {
if (music_singing(player_ptr, MUSIC_WALL)) {
- (void)project(player_ptr, 0, 0, player_ptr->y, player_ptr->x, (60 + player_ptr->lev), GF_DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM);
+ (void)project(player_ptr, 0, 0, player_ptr->y, player_ptr->x, (60 + player_ptr->lev), AttributeType::DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM);
if (!player_bold(player_ptr, ny, nx) || player_ptr->is_dead || player_ptr->leaving)
return false;
}
#include "player-info/equipment-info.h"
#include "player/player-status.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "sv-definition/sv-armor-types.h"
#include "sv-definition/sv-protector-types.h"
#include "sv-definition/sv-weapon-types.h"
if (player_ptr->lev < 10) {
msg_print(_("レイガンを発射した。", "You fire your ray gun."));
- fire_bolt(player_ptr, GF_MISSILE, dir, (player_ptr->lev + 1) / 2);
+ fire_bolt(player_ptr, AttributeType::MISSILE, dir, (player_ptr->lev + 1) / 2);
return true;
}
if (player_ptr->lev < 25) {
msg_print(_("ブラスターを発射した。", "You fire your blaster."));
- fire_bolt(player_ptr, GF_MISSILE, dir, player_ptr->lev);
+ fire_bolt(player_ptr, AttributeType::MISSILE, dir, player_ptr->lev);
return true;
}
if (player_ptr->lev < 35) {
msg_print(_("バズーカを発射した。", "You fire your bazooka."));
- fire_ball(player_ptr, GF_MISSILE, dir, player_ptr->lev * 2, 2);
+ fire_ball(player_ptr, AttributeType::MISSILE, dir, player_ptr->lev * 2, 2);
return true;
}
if (player_ptr->lev < 45) {
msg_print(_("ビームキャノンを発射した。", "You fire a beam cannon."));
- fire_beam(player_ptr, GF_MISSILE, dir, player_ptr->lev * 2);
+ fire_beam(player_ptr, AttributeType::MISSILE, dir, player_ptr->lev * 2);
return true;
}
msg_print(_("ロケットを発射した。", "You fire a rocket."));
- fire_rocket(player_ptr, GF_ROCKET, dir, player_ptr->lev * 5, 2);
+ fire_rocket(player_ptr, AttributeType::ROCKET, dir, player_ptr->lev * 5, 2);
return true;
}
#include "racial/racial-balrog.h"
#include "player/player-status.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
bool demonic_breath(player_type *player_ptr)
{
DIRECTION dir;
- int type = (one_in_(2) ? GF_NETHER : GF_FIRE);
+ AttributeType type = (one_in_(2) ? AttributeType::NETHER : AttributeType::FIRE);
if (!get_aim_dir(player_ptr, &dir))
return false;
stop_mouth(player_ptr);
- msg_format(_("あなたは%sのブレスを吐いた。", "You breathe %s."), ((type == GF_NETHER) ? _("地獄", "nether") : _("火炎", "fire")));
+ msg_format(_("あなたは%sのブレスを吐いた。", "You breathe %s."), ((type == AttributeType::NETHER) ? _("地獄", "nether") : _("火炎", "fire")));
fire_breath(player_ptr, type, dir, player_ptr->lev * 3, (player_ptr->lev / 15) + 1);
return true;
}
#include "mind/mind-elementalist.h"
#include "player/player-status.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
-static void decide_breath_kind(player_type *player_ptr, int *breath_type, concptr *breath_type_description)
+static void decide_breath_kind(player_type *player_ptr, AttributeType *breath_type, concptr *breath_type_description)
{
if (randint1(100) >= player_ptr->lev)
return;
case PlayerClassType::ARCHER:
case PlayerClassType::SMITH:
if (one_in_(3)) {
- *breath_type = GF_MISSILE;
+ *breath_type = AttributeType::MISSILE;
*breath_type_description = _("エレメント", "the elements");
} else {
- *breath_type = GF_SHARDS;
+ *breath_type = AttributeType::SHARDS;
*breath_type_description = _("破片", "shards");
}
case PlayerClassType::BLUE_MAGE:
case PlayerClassType::MIRROR_MASTER:
if (one_in_(3)) {
- *breath_type = GF_MANA;
+ *breath_type = AttributeType::MANA;
*breath_type_description = _("魔力", "mana");
} else {
- *breath_type = GF_DISENCHANT;
+ *breath_type = AttributeType::DISENCHANT;
*breath_type_description = _("劣化", "disenchantment");
}
break;
case PlayerClassType::CHAOS_WARRIOR:
if (!one_in_(3)) {
- *breath_type = GF_CONFUSION;
+ *breath_type = AttributeType::CONFUSION;
*breath_type_description = _("混乱", "confusion");
} else {
- *breath_type = GF_CHAOS;
+ *breath_type = AttributeType::CHAOS;
*breath_type_description = _("カオス", "chaos");
}
case PlayerClassType::SAMURAI:
case PlayerClassType::FORCETRAINER:
if (!one_in_(3)) {
- *breath_type = GF_CONFUSION;
+ *breath_type = AttributeType::CONFUSION;
*breath_type_description = _("混乱", "confusion");
} else {
- *breath_type = GF_SOUND;
+ *breath_type = AttributeType::SOUND;
*breath_type_description = _("轟音", "sound");
}
break;
case PlayerClassType::MINDCRAFTER:
if (!one_in_(3)) {
- *breath_type = GF_CONFUSION;
+ *breath_type = AttributeType::CONFUSION;
*breath_type_description = _("混乱", "confusion");
} else {
- *breath_type = GF_PSI;
+ *breath_type = AttributeType::PSI;
*breath_type_description = _("精神エネルギー", "mental energy");
}
case PlayerClassType::PRIEST:
case PlayerClassType::PALADIN:
if (one_in_(3)) {
- *breath_type = GF_HELL_FIRE;
+ *breath_type = AttributeType::HELL_FIRE;
*breath_type_description = _("地獄の劫火", "hellfire");
} else {
- *breath_type = GF_HOLY_FIRE;
+ *breath_type = AttributeType::HOLY_FIRE;
*breath_type_description = _("聖なる炎", "holy fire");
}
case PlayerClassType::ROGUE:
case PlayerClassType::NINJA:
if (one_in_(3)) {
- *breath_type = GF_DARK;
+ *breath_type = AttributeType::DARK;
*breath_type_description = _("暗黒", "darkness");
} else {
- *breath_type = GF_POIS;
+ *breath_type = AttributeType::POIS;
*breath_type_description = _("毒", "poison");
}
break;
case PlayerClassType::BARD:
if (!one_in_(3)) {
- *breath_type = GF_SOUND;
+ *breath_type = AttributeType::SOUND;
*breath_type_description = _("轟音", "sound");
} else {
- *breath_type = GF_CONFUSION;
+ *breath_type = AttributeType::CONFUSION;
*breath_type_description = _("混乱", "confusion");
}
bool draconian_breath(player_type *player_ptr)
{
- int breath_type = (one_in_(3) ? GF_COLD : GF_FIRE);
- concptr breath_type_description = ((breath_type == GF_COLD) ? _("冷気", "cold") : _("炎", "fire"));
+ AttributeType breath_type = (one_in_(3) ? AttributeType::COLD : AttributeType::FIRE);
+ concptr breath_type_description = ((breath_type == AttributeType::COLD) ? _("冷気", "cold") : _("炎", "fire"));
DIRECTION dir;
if (!get_aim_dir(player_ptr, &dir))
return false;
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-hex.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/action-setter.h"
#include "status/bad-status-setter.h"
if (!get_aim_dir(player_ptr, &dir))
return false;
- fire_beam(player_ptr, is_good_realm(player_ptr->realm1) ? GF_HOLY_FIRE : GF_HELL_FIRE, dir, player_ptr->lev * 3);
+ fire_beam(player_ptr, is_good_realm(player_ptr->realm1) ? AttributeType::HOLY_FIRE : AttributeType::HELL_FIRE, dir, player_ptr->lev * 3);
return true;
case PlayerClassType::WARRIOR_MAGE:
if (command == -3)
return false;
project_length = 1;
- fire_beam(player_ptr, GF_PHOTO, dir, 1);
+ fire_beam(player_ptr, AttributeType::PHOTO, dir, 1);
return true;
}
if (!get_aim_dir(player_ptr, &dir))
return false;
- (void)fire_ball_hide(player_ptr, GF_CHARM_LIVING, dir, player_ptr->lev, 0);
+ (void)fire_ball_hide(player_ptr, AttributeType::CHARM_LIVING, dir, player_ptr->lev, 0);
return true;
}
if (command == -4)
- project_all_los(player_ptr, GF_CHARM_LIVING, player_ptr->lev);
+ project_all_los(player_ptr, AttributeType::CHARM_LIVING, player_ptr->lev);
return true;
case PlayerClassType::ARCHER:
return false;
msg_print(_("巨大な岩を投げた。", "You throw a huge boulder."));
- (void)fire_bolt(player_ptr, GF_MISSILE, dir, (3 * player_ptr->lev) / 2);
+ (void)fire_bolt(player_ptr, AttributeType::MISSILE, dir, (3 * player_ptr->lev) / 2);
return true;
case PlayerRaceType::YEEK:
if (!get_aim_dir(player_ptr, &dir))
stop_mouth(player_ptr);
msg_print(_("酸を吐いた。", "You spit acid."));
if (player_ptr->lev < 25)
- (void)fire_bolt(player_ptr, GF_ACID, dir, player_ptr->lev);
+ (void)fire_bolt(player_ptr, AttributeType::ACID, dir, player_ptr->lev);
else
- (void)fire_ball(player_ptr, GF_ACID, dir, player_ptr->lev, 2);
+ (void)fire_ball(player_ptr, AttributeType::ACID, dir, player_ptr->lev, 2);
return true;
case PlayerRaceType::KOBOLD:
return false;
msg_print(_("毒のダーツを投げた。", "You throw a poisoned dart."));
- (void)fire_bolt(player_ptr, GF_POIS, dir, player_ptr->lev);
+ (void)fire_bolt(player_ptr, AttributeType::POIS, dir, player_ptr->lev);
return true;
case PlayerRaceType::NIBELUNG:
msg_print(_("周囲を調査した。", "You examine your surroundings."));
return false;
msg_print(_("マジック・ミサイルを放った。", "You cast a magic missile."));
- (void)fire_bolt_or_beam(player_ptr, 10, GF_MISSILE, dir, damroll(3 + ((player_ptr->lev - 1) / 5), 4));
+ (void)fire_bolt_or_beam(player_ptr, 10, AttributeType::MISSILE, dir, damroll(3 + ((player_ptr->lev - 1) / 5), 4));
return true;
case PlayerRaceType::DRACONIAN:
return draconian_breath(player_ptr);
return false;
msg_print(_("あなたは集中し、目が赤く輝いた...", "You concentrate and your eyes glow red..."));
- (void)fire_bolt(player_ptr, GF_PSI, dir, player_ptr->lev);
+ (void)fire_bolt(player_ptr, AttributeType::PSI, dir, player_ptr->lev);
return true;
case PlayerRaceType::IMP:
if (!get_aim_dir(player_ptr, &dir))
if (player_ptr->lev >= 30) {
msg_print(_("ファイア・ボールを放った。", "You cast a ball of fire."));
- (void)fire_ball(player_ptr, GF_FIRE, dir, player_ptr->lev, 2);
+ (void)fire_ball(player_ptr, AttributeType::FIRE, dir, player_ptr->lev, 2);
} else {
msg_print(_("ファイア・ボルトを放った。", "You cast a bolt of fire."));
- (void)fire_bolt(player_ptr, GF_FIRE, dir, player_ptr->lev);
+ (void)fire_bolt(player_ptr, AttributeType::FIRE, dir, player_ptr->lev);
}
return true;
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-arcane.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-status.h"
#include "spell/summon-types.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_ELEC, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::ELEC, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_AWAY_ALL, dir, power);
+ fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, power);
}
}
break;
return info_damage(0, 0, dam);
if (cast) {
- int type;
+ AttributeType type;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
switch (randint1(4)) {
case 1:
- type = GF_FIRE;
+ type = AttributeType::FIRE;
break;
case 2:
- type = GF_ELEC;
+ type = AttributeType::ELEC;
break;
case 3:
- type = GF_COLD;
+ type = AttributeType::COLD;
break;
default:
- type = GF_ACID;
+ type = AttributeType::ACID;
break;
}
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-chaos.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_MISSILE, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::MISSILE, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_MISSILE, dir, damroll(dice, sides) + base, rad);
+ fire_ball(player_ptr, AttributeType::MISSILE, dir, damroll(dice, sides) + base, rad);
/*
- * Shouldn't actually use GF_MANA, as
+ * Shouldn't actually use MANA, as
* it will destroy all items on the
* floor
*/
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_FIRE, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::FIRE, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_DISINTEGRATE, dir, damroll(dice, sides), 0);
+ fire_ball(player_ptr, AttributeType::DISINTEGRATE, dir, damroll(dice, sides), 0);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_CHAOS, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::CHAOS, dir, damroll(dice, sides));
}
}
break;
if (cast) {
msg_print(_("ドーン！部屋が揺れた！", "BOOM! Shake the room!"));
- project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, GF_SOUND, PROJECT_KILL | PROJECT_ITEM);
+ project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, AttributeType::SOUND, PROJECT_KILL | PROJECT_ITEM);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_MANA, dir, damroll(dice, sides));
+ fire_beam(player_ptr, AttributeType::MANA, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_FIRE, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_AWAY_ALL, dir, power);
+ fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, power);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_CHAOS, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::CHAOS, dir, dam, rad);
}
}
break;
if (cast) {
for (dir = 0; dir <= 9; dir++)
- fire_beam(player_ptr, GF_ELEC, dir, damroll(dice, sides));
+ fire_beam(player_ptr, AttributeType::ELEC, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_DISINTEGRATE, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::DISINTEGRATE, dir, dam, rad);
}
}
break;
return nullptr;
msg_print(_("ロケット発射！", "You launch a rocket!"));
- fire_rocket(player_ptr, GF_ROCKET, dir, dam, rad);
+ fire_rocket(player_ptr, AttributeType::ROCKET, dir, dam, rad);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_GRAVITY, dir, damroll(dice, sides));
+ fire_beam(player_ptr, AttributeType::GRAVITY, dir, damroll(dice, sides));
}
}
break;
return info_damage(0, 0, dam / 2);
if (cast) {
- fire_ball(player_ptr, GF_FIRE, 0, dam, rad);
+ fire_ball(player_ptr, AttributeType::FIRE, 0, dam, rad);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_MANA, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::MANA, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_CHAOS, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::CHAOS, dir, dam, rad);
}
}
break;
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-crusade.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_ELEC, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::ELEC, dir, damroll(dice, sides));
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_blast(player_ptr, GF_LITE, dir, dice, sides, 10, 3);
+ fire_blast(player_ptr, AttributeType::LITE, dir, dice, sides, 10, 3);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_AWAY_EVIL, dir, power, 0);
+ fire_ball(player_ptr, AttributeType::AWAY_EVIL, dir, power, 0);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_HOLY_FIRE, dir, damroll(dice, sides) + base, rad);
+ fire_ball(player_ptr, AttributeType::HOLY_FIRE, dir, damroll(dice, sides) + base, rad);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt(player_ptr, GF_ELEC, dir, dam);
+ fire_bolt(player_ptr, AttributeType::ELEC, dir, dam);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_LITE, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::LITE, dir, dam, rad);
}
}
break;
if (info)
return format(_("回%d/損%d+%d", "h%d/dm%d+%d"), heal, d_dam, b_dam / 2);
if (cast) {
- project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, b_dam, GF_HOLY_FIRE, PROJECT_KILL);
+ project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, b_dam, AttributeType::HOLY_FIRE, PROJECT_KILL);
dispel_monsters(player_ptr, d_dam);
slow_monsters(player_ptr, plev);
stun_monsters(player_ptr, power);
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-specific-bolt.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
* travel to the monster.
*/
- fire_ball(player_ptr, GF_HELL_FIRE, dir, damroll(dice, sides), rad);
+ fire_ball(player_ptr, AttributeType::HELL_FIRE, dir, damroll(dice, sides), rad);
if (one_in_(5)) {
/* Special effect first */
int effect = randint1(1000);
if (effect == 666)
- fire_ball_hide(player_ptr, GF_DEATH_RAY, dir, plev * 200, 0);
+ fire_ball_hide(player_ptr, AttributeType::DEATH_RAY, dir, plev * 200, 0);
else if (effect < 500)
- fire_ball_hide(player_ptr, GF_TURN_ALL, dir, plev, 0);
+ fire_ball_hide(player_ptr, AttributeType::TURN_ALL, dir, plev, 0);
else if (effect < 800)
- fire_ball_hide(player_ptr, GF_OLD_CONF, dir, plev, 0);
+ fire_ball_hide(player_ptr, AttributeType::OLD_CONF, dir, plev, 0);
else
- fire_ball_hide(player_ptr, GF_STUN, dir, plev, 0);
+ fire_ball_hide(player_ptr, AttributeType::STUN, dir, plev, 0);
}
}
}
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_POIS, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::POIS, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_HYPODYNAMIA, dir, damroll(dice, sides) + base, rad);
+ fire_ball(player_ptr, AttributeType::HYPODYNAMIA, dir, damroll(dice, sides) + base, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_NETHER, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::NETHER, dir, damroll(dice, sides));
}
}
break;
return info_damage(0, 0, dam / 2);
if (cast) {
- project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, GF_POIS, PROJECT_KILL | PROJECT_ITEM);
+ project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, AttributeType::POIS, PROJECT_KILL | PROJECT_ITEM);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball_hide(player_ptr, GF_GENOCIDE, dir, power, 0);
+ fire_ball_hide(player_ptr, AttributeType::GENOCIDE, dir, power, 0);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_DARK, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::DARK, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_DARK, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::DARK, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_HELL_FIRE, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::HELL_FIRE, dir, dam, rad);
take_hit(player_ptr, DAMAGE_USELIFE, 20 + randint1(30), _("地獄の劫火の呪文を唱えた疲労", "the strain of casting Hellfire"));
}
}
#include "spell-kind/spells-pet.h"
#include "spell-kind/spells-sight.h"
#include "spell-realm/spells-demon.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_MISSILE, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::MISSILE, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_NETHER, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::NETHER, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_HELL_FIRE, dir, damroll(dice, sides) + base, rad);
+ fire_ball(player_ptr, AttributeType::HELL_FIRE, dir, damroll(dice, sides) + base, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_PLASMA, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::PLASMA, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_FIRE, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_NETHER, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::NETHER, dir, dam, rad);
}
}
break;
return info_damage(0, 0, dam / 2);
if (cast) {
- fire_ball(player_ptr, GF_FIRE, 0, dam, rad);
- fire_ball_hide(player_ptr, GF_LAVA_FLOW, 0, 2 + randint1(2), rad);
+ fire_ball(player_ptr, AttributeType::FIRE, 0, dam, rad);
+ fire_ball_hide(player_ptr, AttributeType::LAVA_FLOW, 0, 2 + randint1(2), rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_PLASMA, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::PLASMA, dir, dam, rad);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_NEXUS, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::NEXUS, dir, dam, rad);
}
}
break;
else
msg_print(_("<破滅の手>を放った！", "You invoke the Hand of Doom!"));
- fire_ball_hide(player_ptr, GF_HAND_DOOM, dir, plev * 2, 0);
+ fire_ball_hide(player_ptr, AttributeType::HAND_DOOM, dir, plev * 2, 0);
}
}
break;
return format("%s%d+%d", KWD_DAM, dam / 2, dam / 2);
if (cast) {
- fire_ball(player_ptr, GF_CHAOS, 0, dam, rad);
- fire_ball(player_ptr, GF_CONFUSION, 0, dam, rad);
- fire_ball(player_ptr, GF_CHARM, 0, power, rad);
+ fire_ball(player_ptr, AttributeType::CHAOS, 0, dam, rad);
+ fire_ball(player_ptr, AttributeType::CONFUSION, 0, dam, rad);
+ fire_ball(player_ptr, AttributeType::CHARM, 0, power, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_NETHER, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::NETHER, dir, dam, rad);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball_hide(player_ptr, GF_BLOOD_CURSE, dir, dam, rad);
+ fire_ball_hide(player_ptr, AttributeType::BLOOD_CURSE, dir, dam, rad);
take_hit(player_ptr, DAMAGE_USELIFE, 20 + randint1(30), _("血の呪い", "Blood curse"));
}
}
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
#include "spell-realm/spells-hex.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-execution.h"
#include "spell/spells-status.h"
#include "spell/technic-info-table.h"
if (info)
return info_damage(1, power, 0);
if (cast || continuation) {
- project_all_los(player_ptr, GF_POIS, randint1(power));
+ project_all_los(player_ptr, AttributeType::POIS, randint1(power));
}
break;
if ((spell_hex.get_revenge_turn() == 0) || (power >= 200)) {
msg_print(_("我慢が解かれた！", "My patience is at an end!"));
if (power) {
- project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, power, GF_HELL_FIRE, (PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
+ project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, power, AttributeType::HELL_FIRE, (PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
}
if (allow_debug_options) {
if (info)
return info_damage(1, power, 0);
if (cast || continuation) {
- project_all_los(player_ptr, GF_HYPODYNAMIA, randint1(power));
+ project_all_los(player_ptr, AttributeType::HYPODYNAMIA, randint1(power));
}
break;
if (info)
return info_damage(1, power, 0);
if (cast || continuation) {
- project_all_los(player_ptr, GF_PSI_DRAIN, randint1(power));
+ project_all_los(player_ptr, AttributeType::PSI_DRAIN, randint1(power));
}
break;
msg_print(_("復讐の時だ！", "Time for revenge!"));
} while (!get_aim_dir(player_ptr, &dir));
- fire_ball(player_ptr, GF_HELL_FIRE, dir, power, 1);
+ fire_ball(player_ptr, AttributeType::HELL_FIRE, dir, power, 1);
if (allow_debug_options) {
msg_format(_("%d点のダメージを返した。", "You return %d damage."), power);
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/technic-info-table.h"
#include "status/bad-status-setter.h"
#include "system/floor-type-definition.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- project_hook(player_ptr, GF_ATTACK, dir, HISSATSU_2, PROJECT_STOP | PROJECT_KILL);
+ project_hook(player_ptr, AttributeType::ATTACK, dir, HISSATSU_2, PROJECT_STOP | PROJECT_KILL);
}
break;
if (i)
total_damage = total_damage * 7 / 10;
}
- fire_beam(player_ptr, GF_FORCE, dir, total_damage);
+ fire_beam(player_ptr, AttributeType::FORCE, dir, total_damage);
}
break;
if (cast) {
msg_print(_("雄叫びをあげた！", "You roar!"));
- project_all_los(player_ptr, GF_SOUND, randint1(plev * 3));
+ project_all_los(player_ptr, AttributeType::SOUND, randint1(plev * 3));
aggravate_monsters(player_ptr, 0);
}
break;
if (cast) {
msg_print(_("武器を不規則に揺らした．．．", "You irregularly wave your weapon..."));
- project_all_los(player_ptr, GF_ENGETSU, plev * 4);
+ project_all_los(player_ptr, AttributeType::ENGETSU, plev * 4);
}
break;
msg_print(_("不思議な力がテレポートを防いだ！", "A mysterious force prevents you from teleporting!"));
break;
}
- project(player_ptr, 0, 0, y, x, HISSATSU_ISSEN, GF_ATTACK, PROJECT_BEAM | PROJECT_KILL);
+ project(player_ptr, 0, 0, y, x, HISSATSU_ISSEN, AttributeType::ATTACK, PROJECT_BEAM | PROJECT_KILL);
teleport_player_to(player_ptr, y, x, TELEPORT_SPONTANEOUS);
}
break;
damage *= player_ptr->num_blow[i];
total_damage += (damage / 100);
}
- project(player_ptr, 0, (cave_has_flag_bold(player_ptr->current_floor_ptr, y, x, FF::PROJECT) ? 5 : 0), y, x, total_damage * 3 / 2, GF_METEOR,
+ project(player_ptr, 0, (cave_has_flag_bold(player_ptr->current_floor_ptr, y, x, FF::PROJECT) ? 5 : 0), y, x, total_damage * 3 / 2, AttributeType::METEOR,
PROJECT_KILL | PROJECT_JUMP | PROJECT_ITEM);
}
break;
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/bad-status-setter.h"
#include "status/buff-setter.h"
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball_hide(player_ptr, GF_WOUNDS, dir, damroll(dice, sides), 0);
+ fire_ball_hide(player_ptr, AttributeType::WOUNDS, dir, damroll(dice, sides), 0);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball_hide(player_ptr, GF_WOUNDS, dir, damroll(dice, sides), 0);
+ fire_ball_hide(player_ptr, AttributeType::WOUNDS, dir, damroll(dice, sides), 0);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball_hide(player_ptr, GF_WOUNDS, dir, damroll(dice, sides), 0);
+ fire_ball_hide(player_ptr, AttributeType::WOUNDS, dir, damroll(dice, sides), 0);
}
}
break;
#include "spell-kind/spells-perception.h"
#include "spell-kind/spells-sight.h"
#include "spell-realm/spells-nature.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_ELEC, dir, damroll(dice, sides));
+ fire_beam(player_ptr, AttributeType::ELEC, dir, damroll(dice, sides));
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_COLD, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::COLD, dir, damroll(dice, sides));
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_FIRE, dir, damroll(dice, sides));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::FIRE, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_COLD, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::COLD, dir, dam, rad);
}
}
break;
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_ELEC, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, dam, rad);
break;
}
}
if (cast) {
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_WATER, dir, dam, rad);
+ fire_ball(player_ptr, AttributeType::WATER, dir, dam, rad);
}
}
break;
return info_damage(0, 0, dam / 2);
if (cast) {
- fire_ball(player_ptr, GF_LITE, 0, dam, rad);
+ fire_ball(player_ptr, AttributeType::LITE, 0, dam, rad);
chg_virtue(player_ptr, V_KNOWLEDGE, 1);
chg_virtue(player_ptr, V_ENLIGHTEN, 1);
wiz_lite(player_ptr, false);
if (cast) {
dispel_monsters(player_ptr, d_dam);
earthquake(player_ptr, player_ptr->y, player_ptr->x, q_rad, 0);
- project(player_ptr, 0, b_rad, player_ptr->y, player_ptr->x, b_dam, GF_DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM);
+ project(player_ptr, 0, b_rad, player_ptr->y, player_ptr->x, b_dam, AttributeType::DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM);
}
}
break;
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-song.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/action-setter.h"
#include "status/bad-status-setter.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_bolt(player_ptr, GF_SOUND, dir, damroll(dice, sides));
+ fire_bolt(player_ptr, AttributeType::SOUND, dir, damroll(dice, sides));
}
}
break;
return info_power(power);
if (cont) {
- project_all_los(player_ptr, GF_TURN_ALL, power);
+ project_all_los(player_ptr, AttributeType::TURN_ALL, power);
}
}
return info_damage(dice, sides, 0);
if (cont) {
- project_all_los(player_ptr, GF_PSI, damroll(dice, sides));
+ project_all_los(player_ptr, AttributeType::PSI, damroll(dice, sides));
}
}
* MP不足で鑑定が発動される前に歌が中断してしまうのを防止。
*/
if (cont || cast) {
- project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, 0, GF_IDENTIFY, PROJECT_ITEM);
+ project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, 0, AttributeType::IDENTIFY, PROJECT_ITEM);
}
}
return info_damage(dice, sides, 0);
if (cont) {
- project_all_los(player_ptr, GF_SOUND, damroll(dice, sides));
+ project_all_los(player_ptr, AttributeType::SOUND, damroll(dice, sides));
}
}
* MP不足で効果が発動される前に歌が中断してしまうのを防止。
*/
if (cont || cast) {
- project(player_ptr, 0, 0, player_ptr->y, player_ptr->x, 0, GF_DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM | PROJECT_HIDE);
+ project(player_ptr, 0, 0, player_ptr->y, player_ptr->x, 0, AttributeType::DISINTEGRATE, PROJECT_KILL | PROJECT_ITEM | PROJECT_HIDE);
}
}
break;
if (cast) {
msg_print(_("歌が空間を歪めた．．．", "Reality whirls wildly as you sing a dizzying melody..."));
- project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, power, GF_AWAY_ALL, PROJECT_KILL);
+ project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, power, AttributeType::AWAY_ALL, PROJECT_KILL);
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_SOUND, dir, damroll(dice, sides));
+ fire_beam(player_ptr, AttributeType::SOUND, dir, damroll(dice, sides));
}
}
break;
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_ball(player_ptr, GF_SOUND, dir, damroll(dice, sides), rad);
+ fire_ball(player_ptr, AttributeType::SOUND, dir, damroll(dice, sides), rad);
}
}
break;
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-sorcery.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-status.h"
#include "status/body-improvement.h"
#include "status/buff-setter.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_AWAY_ALL, dir, power);
+ fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, power);
}
}
break;
#include "spell-kind/spells-world.h"
#include "spell-realm/spells-chaos.h"
#include "spell-realm/spells-trump.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-object.h"
#include "spell/spells-status.h"
#include "spell/spells-summon.h"
if (!get_aim_dir(player_ptr, &dir))
return nullptr;
- fire_beam(player_ptr, GF_AWAY_ALL, dir, power);
+ fire_beam(player_ptr, AttributeType::AWAY_ALL, dir, power);
}
}
break;
#include "specific-object/blade-turner.h"
#include "hpmp/hp-mp-processor.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/buff-setter.h"
#include "status/element-resistance.h"
return false;
msg_print(_("あなたはエレメントのブレスを吐いた。", "You breathe the elements."));
- fire_breath(player_ptr, GF_MISSILE, dir, 300, 4);
+ fire_breath(player_ptr, AttributeType::MISSILE, dir, 300, 4);
msg_print(_("鎧が様々な色に輝いた...", "Your armor glows many colours..."));
(void)BadStatusSetter(player_ptr).afraidness(0);
(void)set_hero(player_ptr, randint1(50) + 50, false);
#include "spell-kind/spells-equipment.h"
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-sight.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-summon.h"
#include "spell/summon-types.h"
#include "status/bad-status-setter.h"
msg_print(_("鳥の群れがあなたを取り巻いた！", "A storm of birds swirls around you!"));
for (i = 0; i < randint1(3) + 3; i++)
- (void)fire_meteor(this->player_ptr, -1, GF_FORCE, y, x, o_ptr->pval / 5, 7);
+ (void)fire_meteor(this->player_ptr, -1, AttributeType::FORCE, y, x, o_ptr->pval / 5, 7);
for (i = 0; i < randint1(5) + o_ptr->pval / 5; i++) {
(void)summon_specific(this->player_ptr, 0, y, x, mon_level, SUMMON_BIRD, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
if (one_in_(4)) {
msg_print(_("炎と硫黄の雲の中に悪魔が姿を現した！", "Demons materialize in clouds of fire and brimstone!"));
for (i = 0; i < randint1(3) + 2; i++) {
- (void)fire_meteor(this->player_ptr, -1, GF_FIRE, y, x, 10, 5);
+ (void)fire_meteor(this->player_ptr, -1, AttributeType::FIRE, y, x, 10, 5);
(void)summon_specific(this->player_ptr, 0, y, x, mon_level, SUMMON_DEMON, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
}
}
continue;
}
- (void)fire_meteor(this->player_ptr, -1, GF_NETHER, y, x, 150, 1);
+ (void)fire_meteor(this->player_ptr, -1, AttributeType::NETHER, y, x, 150, 1);
}
}
#include "effect/effect-characteristics.h"
#include "effect/effect-processor.h"
#include "floor/geometry.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/object-type-definition.h"
#include "system/player-type-definition.h"
#include "target/target-checker.h"
BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
for (int i = 0; i < num; i++)
- (void)project(player_ptr, 0, player_ptr->lev / 20 + 1, ty, tx, player_ptr->lev * player_ptr->lev * 6 / 50, GF_ROCKET, flg);
+ (void)project(player_ptr, 0, player_ptr->lev / 20 + 1, ty, tx, player_ptr->lev * player_ptr->lev * 6 / 50, AttributeType::ROCKET, flg);
return true;
}
#include "pet/pet-util.h"
#include "racial/racial-android.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
}
target_pet = old_target_pet;
- if (!fire_ball(player_ptr, GF_CAPTURE, ae_ptr->dir, 0, 0))
+ if (!fire_ball(player_ptr, AttributeType::CAPTURE, ae_ptr->dir, 0, 0))
return true;
ae_ptr->o_ptr->pval = (PARAMETER_VALUE)cap_mon;
#include "player/player-status.h"
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-sight.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/base-status.h"
#include "system/player-type-definition.h"
#include "target/target-getter.h"
case 4:
case 5:
case 6:
- fire_ball(player_ptr, GF_MANA, dir, 600, 3);
+ fire_ball(player_ptr, AttributeType::MANA, dir, 600, 3);
break;
case 7:
case 8:
case 9:
case 10:
- fire_bolt(player_ptr, GF_MANA, dir, 500);
+ fire_bolt(player_ptr, AttributeType::MANA, dir, 500);
break;
default:
break;
#include "spell-kind/earthquake.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-summon.h"
#include "spell/summon-types.h"
#include "status/base-status.h"
if (!count) {
int extra_dam = damroll(10, 10);
msg_print(_("純粋な魔力の次元への扉が開いた！", "A portal opens to a plane of raw mana!"));
- project(player_ptr, 0, 8, m_ptr->fy, m_ptr->fx, extra_dam, GF_MANA, curse_flg);
+ project(player_ptr, 0, 8, m_ptr->fy, m_ptr->fx, extra_dam, AttributeType::MANA, curse_flg);
if (!one_in_(6))
break;
}
case 10:
case 11:
msg_print(_("エネルギーのうねりを感じた！", "You feel a surge of energy!"));
- project(player_ptr, 0, 7, m_ptr->fy, m_ptr->fx, 50, GF_DISINTEGRATE, curse_flg);
+ project(player_ptr, 0, 7, m_ptr->fy, m_ptr->fx, 50, AttributeType::DISINTEGRATE, curse_flg);
if (!one_in_(6))
break;
/* Fall through */
#include "spell-kind/spells-beam.h"
#include "effect/effect-characteristics.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell-kind/spells-launcher.h"
#include "system/player-type-definition.h"
bool wall_to_mud(player_type *player_ptr, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
- return (project_hook(player_ptr, GF_KILL_WALL, dir, dam, flg));
+ return (project_hook(player_ptr, AttributeType::KILL_WALL, dir, dam, flg));
}
/*!
bool wizard_lock(player_type *player_ptr, DIRECTION dir)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
- return (project_hook(player_ptr, GF_JAM_DOOR, dir, 20 + randint1(30), flg));
+ return (project_hook(player_ptr, AttributeType::JAM_DOOR, dir, 20 + randint1(30), flg));
}
/*!
bool destroy_door(player_type *player_ptr, DIRECTION dir)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM;
- return (project_hook(player_ptr, GF_KILL_DOOR, dir, 0, flg));
+ return (project_hook(player_ptr, AttributeType::KILL_DOOR, dir, 0, flg));
}
/*!
bool disarm_trap(player_type *player_ptr, DIRECTION dir)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM;
- return (project_hook(player_ptr, GF_KILL_TRAP, dir, 0, flg));
+ return (project_hook(player_ptr, AttributeType::KILL_TRAP, dir, 0, flg));
}
#include "spell-kind/spells-charm.h"
#include "effect/effect-characteristics.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
/*!
bool charm_monster(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
- return (project_hook(player_ptr, GF_CHARM, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::CHARM, dir, plev, flg));
}
/*!
bool control_one_undead(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
- return (project_hook(player_ptr, GF_CONTROL_UNDEAD, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::CONTROL_UNDEAD, dir, plev, flg));
}
/*!
bool control_one_demon(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
- return (project_hook(player_ptr, GF_CONTROL_DEMON, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::CONTROL_DEMON, dir, plev, flg));
}
/*!
bool charm_animal(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
- return (project_hook(player_ptr, GF_CONTROL_ANIMAL, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::CONTROL_ANIMAL, dir, plev, flg));
}
#include "player/player-status-flags.h"
#include "player/special-defense-types.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "system/artifact-type-definition.h"
#include "system/floor-type-definition.h"
#include "effect/effect-characteristics.h"
#include "effect/effect-processor.h"
#include "floor/geometry.h"
-#include "spell/spell-types.h"
#include "system/player-type-definition.h"
#include "target/target-checker.h"
* Affect grids, objects, and monsters
* </pre>
*/
-bool fire_ball(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
+bool fire_ball(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
- if (typ == GF_CHARM_LIVING)
+ if (typ == AttributeType::CHARM_LIVING)
flg |= PROJECT_HIDE;
POSITION tx = player_ptr->x + 99 * ddx[dir];
* Affect grids, objects, and monsters
* </pre>
*/
-bool fire_breath(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
+bool fire_breath(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
{
return fire_ball(player_ptr, typ, dir, dam, -rad);
}
* Affect grids, objects, and monsters
* </pre>
*/
-bool fire_rocket(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
+bool fire_rocket(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
{
POSITION tx = player_ptr->x + 99 * ddx[dir];
POSITION ty = player_ptr->y + 99 * ddy[dir];
* Affect grids, objects, and monsters
* </pre>
*/
-bool fire_ball_hide(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
+bool fire_ball_hide(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
{
POSITION tx = player_ptr->x + 99 * ddx[dir];
POSITION ty = player_ptr->y + 99 * ddy[dir];
* Option to hurt the player.
* </pre>
*/
-bool fire_meteor(player_type *player_ptr, MONSTER_IDX who, EFFECT_ID typ, POSITION y, POSITION x, HIT_POINT dam, POSITION rad)
+bool fire_meteor(player_type *player_ptr, MONSTER_IDX who, AttributeType typ, POSITION y, POSITION x, HIT_POINT dam, POSITION rad)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
return project(player_ptr, who, rad, y, x, dam, typ, flg).notice;
* @param dev 回数分散
* @return 作用が実際にあった場合TRUEを返す
*/
-bool fire_blast(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, DICE_NUMBER dd, DICE_SID ds, int num, int dev)
+bool fire_blast(player_type *player_ptr, AttributeType typ, DIRECTION dir, DICE_NUMBER dd, DICE_SID ds, int num, int dev)
{
POSITION ty, tx, y, x;
POSITION ly, lx;
* Affect monsters and grids (not objects).
* </pre>
*/
-bool fire_bolt(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
+bool fire_bolt(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_GRID;
- if (typ != GF_ARROW)
+ if (typ != AttributeType::ARROW)
flg |= PROJECT_REFLECTABLE;
return (project_hook(player_ptr, typ, dir, dam, flg));
}
* Affect monsters, grids and objects.
* </pre>
*/
-bool fire_beam(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
+bool fire_beam(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM;
return (project_hook(player_ptr, typ, dir, dam, flg));
* Affect monsters, grids and objects.
* </pre>
*/
-bool fire_bolt_or_beam(player_type *player_ptr, PERCENTAGE prob, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
+bool fire_bolt_or_beam(player_type *player_ptr, PERCENTAGE prob, AttributeType typ, DIRECTION dir, HIT_POINT dam)
{
if (randint0(100) < prob) {
return (fire_beam(player_ptr, typ, dir, dam));
* @param flg フラグ
* @return 作用が実際にあった場合TRUEを返す
*/
-bool project_hook(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, BIT_FLAGS flg)
+bool project_hook(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, BIT_FLAGS flg)
{
flg |= (PROJECT_THRU);
POSITION tx = player_ptr->x + ddx[dir];
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct player_type;
-bool fire_ball(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
-bool fire_breath(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
-bool fire_rocket(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
-bool fire_ball_hide(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
-bool fire_meteor(player_type *player_ptr, MONSTER_IDX who, EFFECT_ID typ, POSITION x, POSITION y, HIT_POINT dam, POSITION rad);
-bool fire_bolt(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam);
-bool fire_blast(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, DICE_NUMBER dd, DICE_SID ds, int num, int dev);
-bool fire_beam(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam);
-bool fire_bolt_or_beam(player_type *player_ptr, PERCENTAGE prob, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam);
-bool project_hook(player_type *player_ptr, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, BIT_FLAGS flg);
+bool fire_ball(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
+bool fire_breath(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
+bool fire_rocket(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
+bool fire_ball_hide(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, POSITION rad);
+bool fire_meteor(player_type *player_ptr, MONSTER_IDX who, AttributeType typ, POSITION x, POSITION y, HIT_POINT dam, POSITION rad);
+bool fire_bolt(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam);
+bool fire_blast(player_type *player_ptr, AttributeType typ, DIRECTION dir, DICE_NUMBER dd, DICE_SID ds, int num, int dev);
+bool fire_beam(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam);
+bool fire_bolt_or_beam(player_type *player_ptr, PERCENTAGE prob, AttributeType typ, DIRECTION dir, HIT_POINT dam);
+bool project_hook(player_type *player_ptr, AttributeType typ, DIRECTION dir, HIT_POINT dam, BIT_FLAGS flg);
#include "player/special-defense-types.h"
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-lite.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
break;
}
- project(player_ptr, 0, 0, y, x, damroll(6 + player_ptr->lev / 8, 10), GF_LITE_WEAK,
+ project(player_ptr, 0, 0, y, x, damroll(6 + player_ptr->lev / 8, 10), AttributeType::LITE_WEAK,
(PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_KILL | PROJECT_LOS));
}
}
BIT_FLAGS flg = PROJECT_GRID | PROJECT_KILL;
- (void)project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, GF_LITE_WEAK, flg);
+ (void)project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, AttributeType::LITE_WEAK, flg);
lite_room(player_ptr, player_ptr->y, player_ptr->x);
}
BIT_FLAGS flg = PROJECT_GRID | PROJECT_KILL;
- (void)project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, GF_DARK_WEAK, flg);
+ (void)project(player_ptr, 0, rad, player_ptr->y, player_ptr->x, dam, AttributeType::DARK_WEAK, flg);
unlite_room(player_ptr, player_ptr->y, player_ptr->x);
bool lite_line(player_type *player_ptr, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_KILL;
- return (project_hook(player_ptr, GF_LITE_WEAK, dir, dam, flg));
+ return (project_hook(player_ptr, AttributeType::LITE_WEAK, dir, dam, flg));
}
#include "grid/feature-flag-types.h"
#include "grid/grid.h"
#include "spell-kind/earthquake.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
#include "util/bit-flags-calculator.h"
bool door_creation(player_type *player_ptr, POSITION y, POSITION x)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, 0, 1, y, x, 0, GF_MAKE_DOOR, flg).notice;
+ return project(player_ptr, 0, 1, y, x, 0, AttributeType::MAKE_DOOR, flg).notice;
}
/*!
bool trap_creation(player_type *player_ptr, POSITION y, POSITION x)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, 0, 1, y, x, 0, GF_MAKE_TRAP, flg).notice;
+ return project(player_ptr, 0, 1, y, x, 0, AttributeType::MAKE_TRAP, flg).notice;
}
/*!
bool tree_creation(player_type *player_ptr, POSITION y, POSITION x)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, 0, 1, y, x, 0, GF_MAKE_TREE, flg).notice;
+ return project(player_ptr, 0, 1, y, x, 0, AttributeType::MAKE_TREE, flg).notice;
}
/*!
bool create_rune_protection_area(player_type *player_ptr, POSITION y, POSITION x)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM;
- return project(player_ptr, 0, 1, y, x, 0, GF_MAKE_RUNE_PROTECTION, flg).notice;
+ return project(player_ptr, 0, 1, y, x, 0, AttributeType::MAKE_RUNE_PROTECTION, flg).notice;
}
/*!
bool wall_stone(player_type *player_ptr)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- bool dummy = project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, GF_STONE_WALL, flg).notice;
+ bool dummy = project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, AttributeType::STONE_WALL, flg).notice;
player_ptr->update |= (PU_FLOW);
player_ptr->redraw |= (PR_MAP);
return dummy;
bool destroy_doors_touch(player_type *player_ptr)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, GF_KILL_DOOR, flg).notice;
+ return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, AttributeType::KILL_DOOR, flg).notice;
}
/*!
bool disarm_traps_touch(player_type *player_ptr)
{
BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, GF_KILL_TRAP, flg).notice;
+ return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, AttributeType::KILL_TRAP, flg).notice;
}
/*!
bool sleep_monsters_touch(player_type *player_ptr)
{
BIT_FLAGS flg = PROJECT_KILL | PROJECT_HIDE;
- return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, player_ptr->lev, GF_OLD_SLEEP, flg).notice;
+ return project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, player_ptr->lev, AttributeType::OLD_SLEEP, flg).notice;
}
/*!
bool animate_dead(player_type *player_ptr, MONSTER_IDX who, POSITION y, POSITION x)
{
BIT_FLAGS flg = PROJECT_ITEM | PROJECT_HIDE;
- return project(player_ptr, who, 5, y, x, 0, GF_ANIM_DEAD, flg).notice;
+ return project(player_ptr, who, 5, y, x, 0, AttributeType::ANIM_DEAD, flg).notice;
}
/*!
break;
}
- project(player_ptr, 0, 0, y, x, 20 + randint1(30), GF_KILL_WALL, (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
+ project(player_ptr, 0, 0, y, x, 20 + randint1(30), AttributeType::KILL_WALL, (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
return;
}
break;
}
- project(player_ptr, 0, 0, y, x, 20 + randint1(30), GF_KILL_WALL, (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
+ project(player_ptr, 0, 0, y, x, 20 + randint1(30), AttributeType::KILL_WALL, (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL));
}
}
#include "monster/monster-description-types.h"
#include "monster/monster-info.h"
#include "monster/smart-learn-types.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
dam = (dam - 400) / 2 + 400;
if (dam > 800)
dam = 800;
- project(player_ptr, i, 2 + (r_ptr->level / 20), m_ptr->fy, m_ptr->fx, dam, GF_PLASMA, PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
+ project(player_ptr, i, 2 + (r_ptr->level / 20), m_ptr->fy, m_ptr->fx, dam, AttributeType::PLASMA, PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
if (record_named_pet && m_ptr->nickname) {
GAME_TEXT m_name[MAX_NLEN];
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-specific-bolt.h"
#include "spell-kind/spells-teleport.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-status.h"
#include "spell/spells-summon.h"
*/
void call_chaos(player_type *player_ptr)
{
- int hurt_types[31] = { GF_ELEC, GF_POIS, GF_ACID, GF_COLD, GF_FIRE, GF_MISSILE, GF_ARROW, GF_PLASMA, GF_HOLY_FIRE, GF_WATER, GF_LITE, GF_DARK, GF_FORCE,
- GF_INERTIAL, GF_MANA, GF_METEOR, GF_ICE, GF_CHAOS, GF_NETHER, GF_DISENCHANT, GF_SHARDS, GF_SOUND, GF_NEXUS, GF_CONFUSION, GF_TIME, GF_GRAVITY,
- GF_ROCKET, GF_NUKE, GF_HELL_FIRE, GF_DISINTEGRATE, GF_PSY_SPEAR };
-
- int chaos_type = hurt_types[randint0(31)];
+ AttributeType hurt_types[31] = { AttributeType::ELEC, AttributeType::POIS, AttributeType::ACID, AttributeType::COLD, AttributeType::FIRE,
+ AttributeType::MISSILE, AttributeType::ARROW, AttributeType::PLASMA, AttributeType::HOLY_FIRE, AttributeType::WATER, AttributeType::LITE,
+ AttributeType::DARK, AttributeType::FORCE, AttributeType::INERTIAL, AttributeType::MANA, AttributeType::METEOR, AttributeType::ICE,
+ AttributeType::CHAOS, AttributeType::NETHER, AttributeType::DISENCHANT, AttributeType::SHARDS, AttributeType::SOUND, AttributeType::NEXUS,
+ AttributeType::CONFUSION, AttributeType::TIME, AttributeType::GRAVITY, AttributeType::ROCKET, AttributeType::NUKE, AttributeType::HELL_FIRE,
+ AttributeType::DISINTEGRATE, AttributeType::PSY_SPEAR };
+
+ AttributeType chaos_type = hurt_types[randint0(31)];
bool line_chaos = false;
if (one_in_(4))
line_chaos = true;
if (!(*count)) {
HIT_POINT dam = damroll(10, 10);
msg_print(_("純粋な魔力の次元への扉が開いた！", "A portal opens to a plane of raw mana!"));
- project(player_ptr, 0, 8, player_ptr->y, player_ptr->x, dam, GF_MANA, flg);
+ project(player_ptr, 0, 8, player_ptr->y, player_ptr->x, dam, AttributeType::MANA, flg);
take_hit(player_ptr, DAMAGE_NOESCAPE, dam, _("純粋な魔力の解放", "released pure mana"));
if (!one_in_(6))
break;
msg_print(_("エネルギーのうねりを感じた！", "You feel a surge of energy!"));
wall_breaker(player_ptr);
if (!randint0(7)) {
- project(player_ptr, 0, 7, player_ptr->y, player_ptr->x, 50, GF_KILL_WALL, flg);
+ project(player_ptr, 0, 7, player_ptr->y, player_ptr->x, 50, AttributeType::KILL_WALL, flg);
take_hit(player_ptr, DAMAGE_NOESCAPE, 50, _("エネルギーのうねり", "surge of energy"));
}
lose_all_info(player_ptr);
break;
case 32:
- fire_ball(player_ptr, GF_CHAOS, 0, spell + 5, 1 + (spell / 10));
+ fire_ball(player_ptr, AttributeType::CHAOS, 0, spell + 5, 1 + (spell / 10));
break;
case 33:
wall_stone(player_ptr);
}
if (die < 36) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_MISSILE, dir, damroll(3 + ((plev - 1) / 5), 4));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::MISSILE, dir, damroll(3 + ((plev - 1) / 5), 4));
return;
}
}
if (die < 46) {
- fire_ball(player_ptr, GF_POIS, dir, 20 + (plev / 2), 3);
+ fire_ball(player_ptr, AttributeType::POIS, dir, 20 + (plev / 2), 3);
return;
}
}
if (die < 56) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_ELEC, dir, damroll(3 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::ELEC, dir, damroll(3 + ((plev - 5) / 4), 8));
return;
}
if (die < 61) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_COLD, dir, damroll(5 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::COLD, dir, damroll(5 + ((plev - 5) / 4), 8));
return;
}
if (die < 66) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_ACID, dir, damroll(6 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::ACID, dir, damroll(6 + ((plev - 5) / 4), 8));
return;
}
if (die < 71) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_FIRE, dir, damroll(8 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::FIRE, dir, damroll(8 + ((plev - 5) / 4), 8));
return;
}
}
if (die < 81) {
- fire_ball(player_ptr, GF_ELEC, dir, 30 + plev / 2, 2);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, 30 + plev / 2, 2);
return;
}
if (die < 86) {
- fire_ball(player_ptr, GF_ACID, dir, 40 + plev, 2);
+ fire_ball(player_ptr, AttributeType::ACID, dir, 40 + plev, 2);
return;
}
if (die < 91) {
- fire_ball(player_ptr, GF_ICE, dir, 70 + plev, 3);
+ fire_ball(player_ptr, AttributeType::ICE, dir, 70 + plev, 3);
return;
}
if (die < 96) {
- fire_ball(player_ptr, GF_FIRE, dir, 80 + plev, 3);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, 80 + plev, 3);
return;
}
#include "monster/monster-status-setter.h"
#include "monster/monster-status.h"
#include "monster/smart-learn-types.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/monster-race-definition.h"
#include "system/monster-type-definition.h"
* this is done in two passes. -- JDL
* </pre>
*/
-bool project_all_los(player_type *player_ptr, EFFECT_ID typ, HIT_POINT dam)
+bool project_all_los(player_type *player_ptr, AttributeType typ, HIT_POINT dam)
{
for (MONSTER_IDX i = 1; i < player_ptr->current_floor_ptr->m_max; i++) {
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[i];
*/
bool speed_monsters(player_type *player_ptr)
{
- return (project_all_los(player_ptr, GF_OLD_SPEED, player_ptr->lev));
+ return (project_all_los(player_ptr, AttributeType::OLD_SPEED, player_ptr->lev));
}
/*!
*/
bool slow_monsters(player_type *player_ptr, int power)
{
- return (project_all_los(player_ptr, GF_OLD_SLOW, power));
+ return (project_all_los(player_ptr, AttributeType::OLD_SLOW, power));
}
/*!
*/
bool sleep_monsters(player_type *player_ptr, int power)
{
- return (project_all_los(player_ptr, GF_OLD_SLEEP, power));
+ return (project_all_los(player_ptr, AttributeType::OLD_SLEEP, power));
}
/*!
*/
bool banish_evil(player_type *player_ptr, int dist)
{
- return (project_all_los(player_ptr, GF_AWAY_EVIL, dist));
+ return (project_all_los(player_ptr, AttributeType::AWAY_EVIL, dist));
}
/*!
*/
bool turn_undead(player_type *player_ptr)
{
- bool tester = (project_all_los(player_ptr, GF_TURN_UNDEAD, player_ptr->lev));
+ bool tester = (project_all_los(player_ptr, AttributeType::TURN_UNDEAD, player_ptr->lev));
if (tester)
chg_virtue(player_ptr, V_UNLIFE, -1);
return tester;
*/
bool dispel_undead(player_type *player_ptr, HIT_POINT dam)
{
- bool tester = (project_all_los(player_ptr, GF_DISP_UNDEAD, dam));
+ bool tester = (project_all_los(player_ptr, AttributeType::DISP_UNDEAD, dam));
if (tester)
chg_virtue(player_ptr, V_UNLIFE, -2);
return tester;
*/
bool dispel_evil(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_DISP_EVIL, dam));
+ return (project_all_los(player_ptr, AttributeType::DISP_EVIL, dam));
}
/*!
*/
bool dispel_good(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_DISP_GOOD, dam));
+ return (project_all_los(player_ptr, AttributeType::DISP_GOOD, dam));
}
/*!
*/
bool dispel_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_DISP_ALL, dam));
+ return (project_all_los(player_ptr, AttributeType::DISP_ALL, dam));
}
/*!
*/
bool dispel_living(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_DISP_LIVING, dam));
+ return (project_all_los(player_ptr, AttributeType::DISP_LIVING, dam));
}
/*!
*/
bool dispel_demons(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_DISP_DEMON, dam));
+ return (project_all_los(player_ptr, AttributeType::DISP_DEMON, dam));
}
/*!
*/
bool crusade(player_type *player_ptr)
{
- return (project_all_los(player_ptr, GF_CRUSADE, player_ptr->lev * 4));
+ return (project_all_los(player_ptr, AttributeType::CRUSADE, player_ptr->lev * 4));
}
/*!
*/
bool confuse_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_OLD_CONF, dam));
+ return (project_all_los(player_ptr, AttributeType::OLD_CONF, dam));
}
/*!
*/
bool charm_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_CHARM, dam));
+ return (project_all_los(player_ptr, AttributeType::CHARM, dam));
}
/*!
*/
bool charm_animals(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_CONTROL_ANIMAL, dam));
+ return (project_all_los(player_ptr, AttributeType::CONTROL_ANIMAL, dam));
}
/*!
*/
bool stun_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_STUN, dam));
+ return (project_all_los(player_ptr, AttributeType::STUN, dam));
}
/*!
*/
bool stasis_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_STASIS, dam));
+ return (project_all_los(player_ptr, AttributeType::STASIS, dam));
}
/*!
*/
bool mindblast_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_PSI, dam));
+ return (project_all_los(player_ptr, AttributeType::PSI, dam));
}
/*!
*/
bool banish_monsters(player_type *player_ptr, int dist)
{
- return (project_all_los(player_ptr, GF_AWAY_ALL, dist));
+ return (project_all_los(player_ptr, AttributeType::AWAY_ALL, dist));
}
/*!
*/
bool turn_evil(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_TURN_EVIL, dam));
+ return (project_all_los(player_ptr, AttributeType::TURN_EVIL, dam));
}
/*!
*/
bool turn_monsters(player_type *player_ptr, HIT_POINT dam)
{
- return (project_all_los(player_ptr, GF_TURN_ALL, dam));
+ return (project_all_los(player_ptr, AttributeType::TURN_ALL, dam));
}
/*!
*/
bool deathray_monsters(player_type *player_ptr)
{
- return (project_all_los(player_ptr, GF_DEATH_RAY, player_ptr->lev * 200));
+ return (project_all_los(player_ptr, AttributeType::DEATH_RAY, player_ptr->lev * 200));
}
/*!
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct monster_race;
struct monster_type;
struct player_type;
-bool project_all_los(player_type *player_ptr, EFFECT_ID typ, HIT_POINT dam);
+bool project_all_los(player_type *player_ptr, AttributeType typ, HIT_POINT dam);
bool speed_monsters(player_type *player_ptr);
bool slow_monsters(player_type *player_ptr, int power);
bool sleep_monsters(player_type *player_ptr, int power);
#include "spell-kind/spells-specific-bolt.h"
#include "effect/effect-characteristics.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/player-type-definition.h"
/*!
bool hypodynamic_bolt(player_type *player_ptr, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_HYPODYNAMIA, dir, dam, flg));
+ return (project_hook(player_ptr, AttributeType::HYPODYNAMIA, dir, dam, flg));
}
/*!
bool death_ray(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_DEATH_RAY, dir, plev * 200, flg));
+ return (project_hook(player_ptr, AttributeType::DEATH_RAY, dir, plev * 200, flg));
}
#include "player/player-move.h"
#include "player/player-status.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-race-definition.h"
bool teleport_monster(player_type *player_ptr, DIRECTION dir, int distance)
{
BIT_FLAGS flg = PROJECT_BEAM | PROJECT_KILL;
- return (project_hook(player_ptr, GF_AWAY_ALL, dir, distance, flg));
+ return (project_hook(player_ptr, AttributeType::AWAY_ALL, dir, distance, flg));
}
/*!
#include "player/player-damage.h"
#include "spell-kind/spells-floor.h"
#include "spell-kind/spells-launcher.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/monster-type-definition.h"
if (do_call) {
for (int i = 1; i < 10; i++) {
if (i - 5)
- fire_ball(player_ptr, GF_ROCKET, i, 175, 2);
+ fire_ball(player_ptr, AttributeType::ROCKET, i, 175, 2);
}
for (int i = 1; i < 10; i++) {
if (i - 5)
- fire_ball(player_ptr, GF_MANA, i, 175, 3);
+ fire_ball(player_ptr, AttributeType::MANA, i, 175, 3);
}
for (int i = 1; i < 10; i++) {
if (i - 5)
- fire_ball(player_ptr, GF_NUKE, i, 175, 4);
+ fire_ball(player_ptr, AttributeType::NUKE, i, 175, 4);
}
return;
if (count > 20)
continue;
- project(player_ptr, 0, rad, y, x, dam, GF_METEOR, PROJECT_KILL | PROJECT_JUMP | PROJECT_ITEM);
+ project(player_ptr, 0, rad, y, x, dam, AttributeType::METEOR, PROJECT_KILL | PROJECT_JUMP | PROJECT_ITEM);
}
}
#include "grid/feature-flag-types.h"
#include "spell-realm/spells-crusade.h"
#include "spell/range-calc.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/player-type-definition.h"
|| !in_disintegration_range(player_ptr->current_floor_ptr, ty, tx, y, x))
continue;
- project(player_ptr, 0, rad, y, x, dam, GF_DISINTEGRATE, PROJECT_JUMP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
+ project(player_ptr, 0, rad, y, x, dam, AttributeType::DISINTEGRATE, PROJECT_JUMP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL);
}
return true;
#include "spell-realm/spells-crusade.h"
#include "spell-realm/spells-song.h"
#include "spell/spell-info.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-execution.h"
#include "spell/technic-info-table.h"
#include "status/action-setter.h"
#endif
const auto y = this->monap_ptr->m_ptr->fy;
const auto x = this->monap_ptr->m_ptr->fx;
- project(this->player_ptr, 0, 0, y, x, this->monap_ptr->get_damage, GF_MISSILE, PROJECT_KILL);
+ project(this->player_ptr, 0, 0, y, x, this->monap_ptr->get_damage, AttributeType::MISSILE, PROJECT_KILL);
if (this->player_ptr->tim_eyeeye) {
set_tim_eyeeye(this->player_ptr, this->player_ptr->tim_eyeeye - 5, true);
}
#include "floor/line-of-sight.h"
#include "grid/feature.h"
#include "grid/grid.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "system/floor-type-definition.h"
#include "system/player-type-definition.h"
#include "target/projection-path-calculator.h"
*/
POSITION dist_to_line(POSITION y, POSITION x, POSITION y1, POSITION x1, POSITION y2, POSITION x2)
{
- POSITION py = y1 - y;
- POSITION px = x1 - x;
- POSITION ny = x2 - x1;
- POSITION nx = y1 - y2;
- POSITION pd = distance(y1, x1, y, x);
- POSITION nd = distance(y1, x1, y2, x2);
-
- if (pd > nd) return distance(y, x, y2, x2);
-
- nd = ((nd) ? ((py * ny + px * nx) / nd) : 0);
- return((nd >= 0) ? nd : 0 - nd);
+ POSITION py = y1 - y;
+ POSITION px = x1 - x;
+ POSITION ny = x2 - x1;
+ POSITION nx = y1 - y2;
+ POSITION pd = distance(y1, x1, y, x);
+ POSITION nd = distance(y1, x1, y2, x2);
+
+ if (pd > nd)
+ return distance(y, x, y2, x2);
+
+ nd = ((nd) ? ((py * ny + px * nx) / nd) : 0);
+ return ((nd >= 0) ? nd : 0 - nd);
}
-
/*
*
* Modified version of los() for calculation of disintegration balls.
*/
bool in_disintegration_range(floor_type *floor_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2)
{
- POSITION delta_y = y2 - y1;
- POSITION delta_x = x2 - x1;
- POSITION absolute_y = std::abs(delta_y);
- POSITION absolute_x = std::abs(delta_x);
- if ((absolute_x < 2) && (absolute_y < 2)) return true;
-
- POSITION scanner_y;
- if (!delta_x)
- {
- /* South -- check for walls */
- if (delta_y > 0)
- {
- for (scanner_y = y1 + 1; scanner_y < y2; scanner_y++)
- {
- if (cave_stop_disintegration(floor_ptr, scanner_y, x1)) return false;
- }
- }
-
- /* North -- check for walls */
- else
- {
- for (scanner_y = y1 - 1; scanner_y > y2; scanner_y--)
- {
- if (cave_stop_disintegration(floor_ptr, scanner_y, x1)) return false;
- }
- }
-
- return true;
- }
-
- /* Directly East/West */
- POSITION scanner_x;
- if (!delta_y)
- {
- /* East -- check for walls */
- if (delta_x > 0)
- {
- for (scanner_x = x1 + 1; scanner_x < x2; scanner_x++)
- {
- if (cave_stop_disintegration(floor_ptr, y1, scanner_x)) return false;
- }
- }
-
- /* West -- check for walls */
- else
- {
- for (scanner_x = x1 - 1; scanner_x > x2; scanner_x--)
- {
- if (cave_stop_disintegration(floor_ptr, y1, scanner_x)) return false;
- }
- }
-
- return true;
- }
-
- POSITION sign_x = (delta_x < 0) ? -1 : 1;
- POSITION sign_y = (delta_y < 0) ? -1 : 1;
- if (absolute_x == 1)
- {
- if (absolute_y == 2)
- {
- if (!cave_stop_disintegration(floor_ptr, y1 + sign_y, x1)) return true;
- }
- }
- else if (absolute_y == 1)
- {
- if (absolute_x == 2)
- {
- if (!cave_stop_disintegration(floor_ptr, y1, x1 + sign_x)) return true;
- }
- }
-
- POSITION scale_factor_2 = (absolute_x * absolute_y);
- POSITION scale_factor_1 = scale_factor_2 << 1;
- POSITION fraction_y;
- POSITION m; /* Slope, or 1/Slope, of LOS */
- if (absolute_x >= absolute_y)
- {
- fraction_y = absolute_y * absolute_y;
- m = fraction_y << 1;
- scanner_x = x1 + sign_x;
- if (fraction_y == scale_factor_2)
- {
- scanner_y = y1 + sign_y;
- fraction_y -= scale_factor_1;
- }
- else
- {
- scanner_y = y1;
- }
-
- /* Note (below) the case (qy == f2), where */
- /* the LOS exactly meets the corner of a tile. */
- while (x2 - scanner_x)
- {
- if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x)) return false;
-
- fraction_y += m;
-
- if (fraction_y < scale_factor_2)
- {
- scanner_x += sign_x;
- }
- else if (fraction_y > scale_factor_2)
- {
- scanner_y += sign_y;
- if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x)) return false;
- fraction_y -= scale_factor_1;
- scanner_x += sign_x;
- }
- else
- {
- scanner_y += sign_y;
- fraction_y -= scale_factor_1;
- scanner_x += sign_x;
- }
- }
-
- return true;
- }
-
- POSITION fraction_x = absolute_x * absolute_x;
- m = fraction_x << 1;
- scanner_y = y1 + sign_y;
- if (fraction_x == scale_factor_2)
- {
- scanner_x = x1 + sign_x;
- fraction_x -= scale_factor_1;
- }
- else
- {
- scanner_x = x1;
- }
-
- /* Note (below) the case (qx == f2), where */
- /* the LOS exactly meets the corner of a tile. */
- while (y2 - scanner_y)
- {
- if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x)) return false;
-
- fraction_x += m;
-
- if (fraction_x < scale_factor_2)
- {
- scanner_y += sign_y;
- }
- else if (fraction_x > scale_factor_2)
- {
- scanner_x += sign_x;
- if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x)) return false;
- fraction_x -= scale_factor_1;
- scanner_y += sign_y;
- }
- else
- {
- scanner_x += sign_x;
- fraction_x -= scale_factor_1;
- scanner_y += sign_y;
- }
- }
-
- return true;
+ POSITION delta_y = y2 - y1;
+ POSITION delta_x = x2 - x1;
+ POSITION absolute_y = std::abs(delta_y);
+ POSITION absolute_x = std::abs(delta_x);
+ if ((absolute_x < 2) && (absolute_y < 2))
+ return true;
+
+ POSITION scanner_y;
+ if (!delta_x) {
+ /* South -- check for walls */
+ if (delta_y > 0) {
+ for (scanner_y = y1 + 1; scanner_y < y2; scanner_y++) {
+ if (cave_stop_disintegration(floor_ptr, scanner_y, x1))
+ return false;
+ }
+ }
+
+ /* North -- check for walls */
+ else {
+ for (scanner_y = y1 - 1; scanner_y > y2; scanner_y--) {
+ if (cave_stop_disintegration(floor_ptr, scanner_y, x1))
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /* Directly East/West */
+ POSITION scanner_x;
+ if (!delta_y) {
+ /* East -- check for walls */
+ if (delta_x > 0) {
+ for (scanner_x = x1 + 1; scanner_x < x2; scanner_x++) {
+ if (cave_stop_disintegration(floor_ptr, y1, scanner_x))
+ return false;
+ }
+ }
+
+ /* West -- check for walls */
+ else {
+ for (scanner_x = x1 - 1; scanner_x > x2; scanner_x--) {
+ if (cave_stop_disintegration(floor_ptr, y1, scanner_x))
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ POSITION sign_x = (delta_x < 0) ? -1 : 1;
+ POSITION sign_y = (delta_y < 0) ? -1 : 1;
+ if (absolute_x == 1) {
+ if (absolute_y == 2) {
+ if (!cave_stop_disintegration(floor_ptr, y1 + sign_y, x1))
+ return true;
+ }
+ } else if (absolute_y == 1) {
+ if (absolute_x == 2) {
+ if (!cave_stop_disintegration(floor_ptr, y1, x1 + sign_x))
+ return true;
+ }
+ }
+
+ POSITION scale_factor_2 = (absolute_x * absolute_y);
+ POSITION scale_factor_1 = scale_factor_2 << 1;
+ POSITION fraction_y;
+ POSITION m; /* Slope, or 1/Slope, of LOS */
+ if (absolute_x >= absolute_y) {
+ fraction_y = absolute_y * absolute_y;
+ m = fraction_y << 1;
+ scanner_x = x1 + sign_x;
+ if (fraction_y == scale_factor_2) {
+ scanner_y = y1 + sign_y;
+ fraction_y -= scale_factor_1;
+ } else {
+ scanner_y = y1;
+ }
+
+ /* Note (below) the case (qy == f2), where */
+ /* the LOS exactly meets the corner of a tile. */
+ while (x2 - scanner_x) {
+ if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x))
+ return false;
+
+ fraction_y += m;
+
+ if (fraction_y < scale_factor_2) {
+ scanner_x += sign_x;
+ } else if (fraction_y > scale_factor_2) {
+ scanner_y += sign_y;
+ if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x))
+ return false;
+ fraction_y -= scale_factor_1;
+ scanner_x += sign_x;
+ } else {
+ scanner_y += sign_y;
+ fraction_y -= scale_factor_1;
+ scanner_x += sign_x;
+ }
+ }
+
+ return true;
+ }
+
+ POSITION fraction_x = absolute_x * absolute_x;
+ m = fraction_x << 1;
+ scanner_y = y1 + sign_y;
+ if (fraction_x == scale_factor_2) {
+ scanner_x = x1 + sign_x;
+ fraction_x -= scale_factor_1;
+ } else {
+ scanner_x = x1;
+ }
+
+ /* Note (below) the case (qx == f2), where */
+ /* the LOS exactly meets the corner of a tile. */
+ while (y2 - scanner_y) {
+ if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x))
+ return false;
+
+ fraction_x += m;
+
+ if (fraction_x < scale_factor_2) {
+ scanner_y += sign_y;
+ } else if (fraction_x > scale_factor_2) {
+ scanner_x += sign_x;
+ if (cave_stop_disintegration(floor_ptr, scanner_y, scanner_x))
+ return false;
+ fraction_x -= scale_factor_1;
+ scanner_y += sign_y;
+ } else {
+ scanner_x += sign_x;
+ fraction_x -= scale_factor_1;
+ scanner_y += sign_y;
+ }
+ }
+
+ return true;
}
-
/*
* breath shape
*/
-void breath_shape(player_type *player_ptr, uint16_t *path_g, int dist, int *pgrids, POSITION *gx, POSITION *gy, POSITION *gm, POSITION *pgm_rad, POSITION rad, POSITION y1, POSITION x1, POSITION y2, POSITION x2, EFFECT_ID typ)
+void breath_shape(player_type *player_ptr, uint16_t *path_g, int dist, int *pgrids, POSITION *gx, POSITION *gy, POSITION *gm, POSITION *pgm_rad, POSITION rad, POSITION y1, POSITION x1, POSITION y2, POSITION x2, AttributeType typ)
{
- POSITION by = y1;
- POSITION bx = x1;
- int brad = 0;
- int brev = rad * rad / dist;
- int bdis = 0;
- int cdis;
- int path_n = 0;
- int mdis = distance(y1, x1, y2, x2) + rad;
-
- floor_type *floor_ptr = player_ptr->current_floor_ptr;
- while (bdis <= mdis)
- {
- if ((0 < dist) && (path_n < dist))
- {
- POSITION ny = get_grid_y(path_g[path_n]);
- POSITION nx = get_grid_x(path_g[path_n]);
- POSITION nd = distance(ny, nx, y1, x1);
-
- if (bdis >= nd)
- {
- by = ny;
- bx = nx;
- path_n++;
- }
- }
-
- /* Travel from center outward */
- for (cdis = 0; cdis <= brad; cdis++)
- {
- for (POSITION y = by - cdis; y <= by + cdis; y++)
- {
- for (POSITION x = bx - cdis; x <= bx + cdis; x++)
- {
- if (!in_bounds(floor_ptr, y, x)) continue;
- if (distance(y1, x1, y, x) != bdis) continue;
- if (distance(by, bx, y, x) != cdis) continue;
-
- switch (typ)
- {
- case GF_LITE:
- case GF_LITE_WEAK:
- /* Lights are stopped by opaque terrains */
- if (!los(player_ptr, by, bx, y, x)) continue;
- break;
- case GF_DISINTEGRATE:
- /* Disintegration are stopped only by perma-walls */
- if (!in_disintegration_range(floor_ptr, by, bx, y, x)) continue;
- break;
- default:
- /* Ball explosions are stopped by walls */
- if (!projectable(player_ptr, by, bx, y, x)) continue;
- break;
- }
-
- gy[*pgrids] = y;
- gx[*pgrids] = x;
- (*pgrids)++;
- }
- }
- }
-
- gm[bdis + 1] = *pgrids;
- brad = rad * (path_n + brev) / (dist + brev);
- bdis++;
- }
-
- *pgm_rad = bdis;
+ POSITION by = y1;
+ POSITION bx = x1;
+ int brad = 0;
+ int brev = rad * rad / dist;
+ int bdis = 0;
+ int cdis;
+ int path_n = 0;
+ int mdis = distance(y1, x1, y2, x2) + rad;
+
+ floor_type *floor_ptr = player_ptr->current_floor_ptr;
+ while (bdis <= mdis) {
+ if ((0 < dist) && (path_n < dist)) {
+ POSITION ny = get_grid_y(path_g[path_n]);
+ POSITION nx = get_grid_x(path_g[path_n]);
+ POSITION nd = distance(ny, nx, y1, x1);
+
+ if (bdis >= nd) {
+ by = ny;
+ bx = nx;
+ path_n++;
+ }
+ }
+
+ /* Travel from center outward */
+ for (cdis = 0; cdis <= brad; cdis++) {
+ for (POSITION y = by - cdis; y <= by + cdis; y++) {
+ for (POSITION x = bx - cdis; x <= bx + cdis; x++) {
+ if (!in_bounds(floor_ptr, y, x))
+ continue;
+ if (distance(y1, x1, y, x) != bdis)
+ continue;
+ if (distance(by, bx, y, x) != cdis)
+ continue;
+
+ switch (typ) {
+ case AttributeType::LITE:
+ case AttributeType::LITE_WEAK:
+ /* Lights are stopped by opaque terrains */
+ if (!los(player_ptr, by, bx, y, x))
+ continue;
+ break;
+ case AttributeType::DISINTEGRATE:
+ /* Disintegration are stopped only by perma-walls */
+ if (!in_disintegration_range(floor_ptr, by, bx, y, x))
+ continue;
+ break;
+ default:
+ /* Ball explosions are stopped by walls */
+ if (!projectable(player_ptr, by, bx, y, x))
+ continue;
+ break;
+ }
+
+ gy[*pgrids] = y;
+ gx[*pgrids] = x;
+ (*pgrids)++;
+ }
+ }
+ }
+
+ gm[bdis + 1] = *pgrids;
+ brad = rad * (path_n + brev) / (dist + brev);
+ bdis++;
+ }
+
+ *pgm_rad = bdis;
}
#pragma once
#include "system/angband.h"
+#include "effect/attribute-types.h"
struct floor_type;
struct player_type;
bool in_disintegration_range(floor_type *floor_ptr, POSITION y1, POSITION x1, POSITION y2, POSITION x2);
-void breath_shape(player_type *player_ptr, uint16_t *path_g, int dist, int *pgrids, POSITION *gx, POSITION *gy, POSITION *gm, POSITION *pgm_rad, POSITION rad, POSITION y1, POSITION x1, POSITION y2, POSITION x2, EFFECT_ID typ);
+void breath_shape(player_type *player_ptr, uint16_t *path_g, int dist, int *pgrids, POSITION *gx, POSITION *gy, POSITION *gm, POSITION *pgm_rad, POSITION rad, POSITION y1, POSITION x1, POSITION y2, POSITION x2, AttributeType typ);
POSITION dist_to_line(POSITION y, POSITION x, POSITION y1, POSITION x1, POSITION y2, POSITION x2);
+++ /dev/null
-#pragma once
-#include "util/flag-group.h"
-
-enum spells_type
-{
- GF_NONE = 0,
- GF_ELEC = 1, /*!< 魔法効果: 電撃*/
- GF_POIS = 2, /*!< 魔法効果: 毒*/
- GF_ACID = 3, /*!< 魔法効果: 酸*/
- GF_COLD = 4, /*!< 魔法効果: 冷気*/
- GF_FIRE = 5, /*!< 魔法効果: 火炎*/
- GF_PSY_SPEAR = 9, /*!< 魔法効果: 光の剣*/
- GF_MISSILE = 10, /*!< 魔法効果: 弱魔力*/
- GF_ARROW = 11, /*!< 魔法効果: 射撃*/
- GF_PLASMA = 12, /*!< 魔法効果: プラズマ*/
- GF_WATER = 14, /*!< 魔法効果: 水流*/
- GF_LITE = 15, /*!< 魔法効果: 閃光*/
- GF_DARK = 16, /*!< 魔法効果: 暗黒*/
- GF_LITE_WEAK = 17, /*!< 魔法効果: 弱光*/
- GF_DARK_WEAK = 18, /*!< 魔法効果: 弱暗*/
- GF_SHARDS = 20, /*!< 魔法効果: 破片*/
- GF_SOUND = 21, /*!< 魔法効果: 轟音*/
- GF_CONFUSION = 22, /*!< 魔法効果: 混乱*/
- GF_FORCE = 23, /*!< 魔法効果: フォース*/
- GF_INERTIAL = 24, /*!< 魔法効果: 遅鈍*/
- GF_MANA = 26, /*!< 魔法効果: 純粋魔力*/
- GF_METEOR = 27, /*!< 魔法効果: 隕石*/
- GF_ICE = 28, /*!< 魔法効果: 極寒*/
- GF_CHAOS = 30, /*!< 魔法効果: カオス*/
- GF_NETHER = 31, /*!< 魔法効果: 地獄*/
- GF_DISENCHANT = 32, /*!< 魔法効果: 劣化*/
- GF_NEXUS = 33, /*!< 魔法効果: 因果混乱*/
- GF_TIME = 34, /*!< 魔法効果: 時間逆転*/
- GF_GRAVITY = 35, /*!< 魔法効果: 重力*/
- GF_KILL_WALL = 40, /*!< 魔法効果: 岩石溶解*/
- GF_KILL_DOOR = 41, /*!< 魔法効果: ドア破壊*/
- GF_KILL_TRAP = 42, /*!< 魔法効果: トラップ破壊*/
- GF_MAKE_WALL = 45, /*!< 魔法効果: 壁生成*/
- GF_MAKE_DOOR = 46, /*!< 魔法効果: ドア生成*/
- GF_MAKE_TRAP = 47, /*!< 魔法効果: トラップ生成*/
- GF_MAKE_TREE = 48, /*!< 魔法効果: 森林生成*/
- GF_OLD_CLONE = 51, /*!< 魔法効果: クローン・モンスター*/
- GF_OLD_POLY = 52, /*!< 魔法効果: チェンジ・モンスター*/
- GF_OLD_HEAL = 53, /*!< 魔法効果: 回復モンスター*/
- GF_OLD_SPEED = 54, /*!< 魔法効果: スピード・モンスター*/
- GF_OLD_SLOW = 55, /*!< 魔法効果: スロウ・モンスター*/
- GF_OLD_CONF = 56, /*!< 魔法効果: パニック・モンスター*/
- GF_OLD_SLEEP = 57, /*!< 魔法効果: スリープ・モンスター*/
- GF_HYPODYNAMIA = 58, /*!< 魔法効果: 衰弱*/
- GF_AWAY_UNDEAD = 61, /*!< 魔法効果: アンデッド・アウェイ*/
- GF_AWAY_EVIL = 62, /*!< 魔法効果: 邪悪飛ばし*/
- GF_AWAY_ALL = 63, /*!< 魔法効果: テレポート・アウェイ*/
- GF_TURN_UNDEAD = 64, /*!< 魔法効果: アンデッド恐慌*/
- GF_TURN_EVIL = 65, /*!< 魔法効果: 邪悪恐慌*/
- GF_TURN_ALL = 66, /*!< 魔法効果: モンスター恐慌*/
- GF_DISP_UNDEAD = 67, /*!< 魔法効果: アンデッド退散*/
- GF_DISP_EVIL = 68, /*!< 魔法効果: 邪悪退散*/
- GF_DISP_ALL = 69, /*!< 魔法効果: モンスター退散*/
- GF_DISP_DEMON = 70, /*!< 魔法効果: 悪魔退散*/
- GF_DISP_LIVING = 71, /*!< 魔法効果: 生命退散*/
- GF_ROCKET = 72, /*!< 魔法効果: ロケット*/
- GF_NUKE = 73, /*!< 魔法効果: 放射性廃棄物*/
- GF_MAKE_RUNE_PROTECTION = 74, /*!< 魔法効果: 守りのルーン生成*/
- GF_STASIS = 75, /*!< 魔法効果: モンスター拘束*/
- GF_STONE_WALL = 76, /*!< 魔法効果: 壁生成*/
- GF_DEATH_RAY = 77, /*!< 魔法効果: 死の光線*/
- GF_STUN = 78, /*!< 魔法効果: 朦朧*/
- GF_HOLY_FIRE = 79, /*!< 魔法効果: 聖光*/
- GF_HELL_FIRE = 80, /*!< 魔法効果: 地獄の劫火*/
- GF_DISINTEGRATE = 81, /*!< 魔法効果: 分解*/
- GF_CHARM = 82, /*!< 魔法効果: モンスター魅了*/
- GF_CONTROL_UNDEAD = 83, /*!< 魔法効果: アンデッド支配*/
- GF_CONTROL_ANIMAL = 84, /*!< 魔法効果: 動物支配*/
- GF_PSI = 85, /*!< 魔法効果: サイキック攻撃*/
- GF_PSI_DRAIN = 86, /*!< 魔法効果: 精神吸収*/
- GF_TELEKINESIS = 87, /*!< 魔法効果: テレキシネス*/
- GF_JAM_DOOR = 88, /*!< 魔法効果: 施錠*/
- GF_DOMINATION = 89, /*!< 魔法効果: 精神支配*/
- GF_DISP_GOOD = 90, /*!< 魔法効果: 善良退散*/
- GF_DRAIN_MANA = 91, /*!< 魔法効果: 魔力吸収*/
- GF_MIND_BLAST = 92, /*!< 魔法効果: 精神攻撃*/
- GF_BRAIN_SMASH = 93, /*!< 魔法効果: 脳攻撃*/
- GF_CAUSE_1 = 94, /*!< 魔法効果: 軽傷の呪い*/
- GF_CAUSE_2 = 95, /*!< 魔法効果: 重傷の呪い*/
- GF_CAUSE_3 = 96, /*!< 魔法効果: 致命傷の呪い*/
- GF_CAUSE_4 = 97, /*!< 魔法効果: 秘孔を突く*/
- GF_HAND_DOOM = 98, /*!< 魔法効果: 破滅の手*/
- GF_CAPTURE = 99, /*!< 魔法効果: 捕縛*/
- GF_ANIM_DEAD = 100, /*!< 魔法効果: 死者復活*/
- GF_CHARM_LIVING = 101, /*!< 魔法効果: 生命魅了*/
- GF_IDENTIFY = 102, /*!< 魔法効果: 鑑定*/
- GF_ATTACK = 103, /*!< 魔法効果: 白兵*/
- GF_ENGETSU = 104, /*!< 魔法効果: 円月*/
- GF_GENOCIDE = 105, /*!< 魔法効果: 抹殺*/
- GF_PHOTO = 106, /*!< 魔法効果: 撮影*/
- GF_CONTROL_DEMON = 107, /*!< 魔法効果: 悪魔支配*/
- GF_LAVA_FLOW = 108, /*!< 魔法効果: 溶岩噴出*/
- GF_BLOOD_CURSE = 109, /*!< 魔法効果: 血の呪い*/
- GF_SEEKER = 110, /*!< 魔法効果: シーカーレイ*/
- GF_SUPER_RAY = 111, /*!< 魔法効果: スーパーレイ*/
- GF_STAR_HEAL = 112, /*!< 魔法効果: 星の癒し*/
- GF_WATER_FLOW = 113, /*!< 魔法効果: 流水*/
- GF_CRUSADE = 114, /*!< 魔法効果: 聖戦*/
- GF_STASIS_EVIL = 115, /*!< 魔法効果: 邪悪拘束*/
- GF_WOUNDS = 116, /*!< 魔法効果: 創傷*/
- GF_E_GENOCIDE = 117, /*!< 魔法効果: 元素抹殺 */
- GF_VOID = 118, /*!< 魔法効果: 虚無 */
- GF_ABYSS = 119, /*!< 魔法効果: 深淵 */
- GF_HUNGRY = 120, /*!< 魔法効果: 空腹>*/
- GF_PLAYER_SHOOT = 121, /*!< 属性取得用: プレイヤーの射撃/投擲>*/
- GF_PLAYER_MELEE = 122, /*!< 属性取得用: プレイヤーの近接攻撃>*/
- MAX_GF = 123, /*!< 欠番を無視した最大サイズ (直上の値+1) */
-};
-
-
-/*! 属性フラグspell_typesの集合を表すクラス */
-using EffectFlags = FlagGroup<spells_type, MAX_GF>;
#include "hpmp/hp-mp-processor.h"
#include "player/player-damage.h"
#include "spell-kind/spells-sight.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/bad-status-setter.h"
#include "status/body-improvement.h"
#include "system/player-type-definition.h"
bool unleash_mana_storm(player_type *player_ptr, bool powerful)
{
msg_print(_("強力な魔力が敵を引き裂いた！", "Mighty magics rend your enemies!"));
- project(player_ptr, 0, (powerful ? 7 : 5), player_ptr->y, player_ptr->x, (randint1(200) + (powerful ? 500 : 300)) * 2, GF_MANA,
+ project(player_ptr, 0, (powerful ? 7 : 5), player_ptr->y, player_ptr->x, (randint1(200) + (powerful ? 500 : 300)) * 2, AttributeType::MANA,
PROJECT_KILL | PROJECT_ITEM | PROJECT_GRID);
bool is_special_class = player_ptr->pclass != PlayerClassType::MAGE;
#include "spell-kind/spells-launcher.h"
#include "spell-kind/spells-teleport.h"
#include "spell-kind/spells-world.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "status/action-setter.h"
#include "status/bad-status-setter.h"
#include "status/base-status.h"
bool heal_monster(player_type *player_ptr, DIRECTION dir, HIT_POINT dam)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_HEAL, dir, dam, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_HEAL, dir, dam, flg));
}
/*!
bool speed_monster(player_type *player_ptr, DIRECTION dir, int power)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_SPEED, dir, power, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_SPEED, dir, power, flg));
}
/*!
bool slow_monster(player_type *player_ptr, DIRECTION dir, int power)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_SLOW, dir, power, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_SLOW, dir, power, flg));
}
/*!
bool sleep_monster(player_type *player_ptr, DIRECTION dir, int power)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_SLEEP, dir, power, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_SLEEP, dir, power, flg));
}
/*!
*/
bool stasis_monster(player_type *player_ptr, DIRECTION dir)
{
- return (fire_ball_hide(player_ptr, GF_STASIS, dir, player_ptr->lev * 2, 0));
+ return (fire_ball_hide(player_ptr, AttributeType::STASIS, dir, player_ptr->lev * 2, 0));
}
/*!
*/
bool stasis_evil(player_type *player_ptr, DIRECTION dir)
{
- return (fire_ball_hide(player_ptr, GF_STASIS_EVIL, dir, player_ptr->lev * 2, 0));
+ return (fire_ball_hide(player_ptr, AttributeType::STASIS_EVIL, dir, player_ptr->lev * 2, 0));
}
/*!
bool confuse_monster(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_CONF, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_CONF, dir, plev, flg));
}
/*!
bool stun_monster(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_STUN, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::STUN, dir, plev, flg));
}
/*!
bool poly_monster(player_type *player_ptr, DIRECTION dir, int power)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- bool tester = (project_hook(player_ptr, GF_OLD_POLY, dir, power, flg));
+ bool tester = (project_hook(player_ptr, AttributeType::OLD_POLY, dir, power, flg));
if (tester)
chg_virtue(player_ptr, V_CHANCE, 1);
return (tester);
bool clone_monster(player_type *player_ptr, DIRECTION dir)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_OLD_CLONE, dir, 0, flg));
+ return (project_hook(player_ptr, AttributeType::OLD_CLONE, dir, 0, flg));
}
/*!
bool fear_monster(player_type *player_ptr, DIRECTION dir, PLAYER_LEVEL plev)
{
BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
- return (project_hook(player_ptr, GF_TURN_ALL, dir, plev, flg));
+ return (project_hook(player_ptr, AttributeType::TURN_ALL, dir, plev, flg));
}
bool time_walk(player_type *player_ptr)
#include "spell-kind/spells-lite.h"
#include "spell-kind/spells-sight.h"
#include "spell-kind/spells-specific-bolt.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#include "spell/spells-diceroll.h"
#include "spell/spells-status.h"
#include "spell/summon-types.h"
} else if (die < 31) {
poly_monster(player_ptr, dir, plev);
} else if (die < 36) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_MISSILE, dir, damroll(3 + ((plev - 1) / 5), 4));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::MISSILE, dir, damroll(3 + ((plev - 1) / 5), 4));
} else if (die < 41) {
confuse_monster(player_ptr, dir, plev);
} else if (die < 46) {
- fire_ball(player_ptr, GF_POIS, dir, 20 + (plev / 2), 3);
+ fire_ball(player_ptr, AttributeType::POIS, dir, 20 + (plev / 2), 3);
} else if (die < 51) {
(void)lite_line(player_ptr, dir, damroll(6, 8));
} else if (die < 56) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_ELEC, dir, damroll(3 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::ELEC, dir, damroll(3 + ((plev - 5) / 4), 8));
} else if (die < 61) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, GF_COLD, dir, damroll(5 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr) - 10, AttributeType::COLD, dir, damroll(5 + ((plev - 5) / 4), 8));
} else if (die < 66) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_ACID, dir, damroll(6 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::ACID, dir, damroll(6 + ((plev - 5) / 4), 8));
} else if (die < 71) {
- fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), GF_FIRE, dir, damroll(8 + ((plev - 5) / 4), 8));
+ fire_bolt_or_beam(player_ptr, beam_chance(player_ptr), AttributeType::FIRE, dir, damroll(8 + ((plev - 5) / 4), 8));
} else if (die < 76) {
hypodynamic_bolt(player_ptr, dir, 75);
} else if (die < 81) {
- fire_ball(player_ptr, GF_ELEC, dir, 30 + plev / 2, 2);
+ fire_ball(player_ptr, AttributeType::ELEC, dir, 30 + plev / 2, 2);
} else if (die < 86) {
- fire_ball(player_ptr, GF_ACID, dir, 40 + plev, 2);
+ fire_ball(player_ptr, AttributeType::ACID, dir, 40 + plev, 2);
} else if (die < 91) {
- fire_ball(player_ptr, GF_ICE, dir, 70 + plev, 3);
+ fire_ball(player_ptr, AttributeType::ICE, dir, 70 + plev, 3);
} else if (die < 96) {
- fire_ball(player_ptr, GF_FIRE, dir, 80 + plev, 3);
+ fire_ball(player_ptr, AttributeType::FIRE, dir, 80 + plev, 3);
} else if (die < 101) {
hypodynamic_bolt(player_ptr, dir, 100 + plev);
} else if (die < 104) {
#include "util/quarks.h"
#include "util/string-processor.h"
- /*
+/*
* Convert an "attr"/"char" pair into a "pict" (P)
*/
#define PICT(A, C) ((((uint16_t)(A)) << 8) | ((byte)(C)))
/*
* Standard window names
*/
-const char angband_term_name[8][16] =
-{
- "Hengband",
- "Term-1",
- "Term-2",
- "Term-3",
- "Term-4",
- "Term-5",
- "Term-6",
- "Term-7"
+const char angband_term_name[8][16] = {
+ "Hengband",
+ "Term-1",
+ "Term-2",
+ "Term-3",
+ "Term-4",
+ "Term-5",
+ "Term-6",
+ "Term-7"
};
/*
* Global table of color definitions
*/
-byte angband_color_table[256][4] =
-{
- {0x00, 0x00, 0x00, 0x00}, /* TERM_DARK */
- {0x00, 0xFF, 0xFF, 0xFF}, /* TERM_WHITE */
- {0x00, 0x80, 0x80, 0x80}, /* TERM_SLATE */
- {0x00, 0xFF, 0x80, 0x00}, /* TERM_ORANGE */
- {0x00, 0xC0, 0x00, 0x00}, /* TERM_RED */
- {0x00, 0x00, 0x80, 0x40}, /* TERM_GREEN */
- {0x00, 0x00, 0x00, 0xFF}, /* TERM_BLUE */
- {0x00, 0x80, 0x40, 0x00}, /* TERM_UMBER */
- {0x00, 0x40, 0x40, 0x40}, /* TERM_L_DARK */
- {0x00, 0xC0, 0xC0, 0xC0}, /* TERM_L_WHITE */
- {0x00, 0xFF, 0x00, 0xFF}, /* TERM_VIOLET */
- {0x00, 0xFF, 0xFF, 0x00}, /* TERM_YELLOW */
- {0x00, 0xFF, 0x00, 0x00}, /* TERM_L_RED */
- {0x00, 0x00, 0xFF, 0x00}, /* TERM_L_GREEN */
- {0x00, 0x00, 0xFF, 0xFF}, /* TERM_L_BLUE */
- {0x00, 0xC0, 0x80, 0x40} /* TERM_L_UMBER */
+byte angband_color_table[256][4] = {
+ { 0x00, 0x00, 0x00, 0x00 }, /* TERM_DARK */
+ { 0x00, 0xFF, 0xFF, 0xFF }, /* TERM_WHITE */
+ { 0x00, 0x80, 0x80, 0x80 }, /* TERM_SLATE */
+ { 0x00, 0xFF, 0x80, 0x00 }, /* TERM_ORANGE */
+ { 0x00, 0xC0, 0x00, 0x00 }, /* TERM_RED */
+ { 0x00, 0x00, 0x80, 0x40 }, /* TERM_GREEN */
+ { 0x00, 0x00, 0x00, 0xFF }, /* TERM_BLUE */
+ { 0x00, 0x80, 0x40, 0x00 }, /* TERM_UMBER */
+ { 0x00, 0x40, 0x40, 0x40 }, /* TERM_L_DARK */
+ { 0x00, 0xC0, 0xC0, 0xC0 }, /* TERM_L_WHITE */
+ { 0x00, 0xFF, 0x00, 0xFF }, /* TERM_VIOLET */
+ { 0x00, 0xFF, 0xFF, 0x00 }, /* TERM_YELLOW */
+ { 0x00, 0xFF, 0x00, 0x00 }, /* TERM_L_RED */
+ { 0x00, 0x00, 0xFF, 0x00 }, /* TERM_L_GREEN */
+ { 0x00, 0x00, 0xFF, 0xFF }, /* TERM_L_BLUE */
+ { 0x00, 0xC0, 0x80, 0x40 } /* TERM_L_UMBER */
};
/*!
* @brief 色名称テーブル / Hack -- the "basic" color names (see "TERM_xxx")
*/
-const concptr color_names[16] =
-{
+const concptr color_names[16] = {
#ifdef JP
- "黒",
- "白",
- "青灰色",
- "オレンジ",
- "赤",
- "緑",
- "青",
- "琥珀色",
- "灰色",
- "明青灰色",
- "紫",
- "黄",
- "明るい赤",
- "明るい緑",
- "明るい青",
- "明琥珀色",
+ "黒",
+ "白",
+ "青灰色",
+ "オレンジ",
+ "赤",
+ "緑",
+ "青",
+ "琥珀色",
+ "灰色",
+ "明青灰色",
+ "紫",
+ "黄",
+ "明るい赤",
+ "明るい緑",
+ "明るい青",
+ "明琥珀色",
#else
- "Dark",
- "White",
- "Slate",
- "Orange",
- "Red",
- "Green",
- "Blue",
- "Umber",
- "Light Dark",
- "Light Slate",
- "Violet",
- "Yellow",
- "Light Red",
- "Light Green",
- "Light Blue",
- "Light Umber",
+ "Dark",
+ "White",
+ "Slate",
+ "Orange",
+ "Red",
+ "Green",
+ "Blue",
+ "Umber",
+ "Light Dark",
+ "Light Slate",
+ "Violet",
+ "Yellow",
+ "Light Red",
+ "Light Green",
+ "Light Blue",
+ "Light Umber",
#endif
-
};
-
/*!
* @brief サブウィンドウ名称テーブル
* @details
* of the main screen into any interested windows.
* </pre>
*/
-const concptr window_flag_desc[32] =
-{
- _("持ち物/装備一覧", "Display inven/equip"),
- _("装備/持ち物一覧", "Display equip/inven"),
- _("呪文一覧", "Display spell list"),
- _("キャラクタ情報", "Display character"),
- _("視界内のモンスター表示", "Display monsters in sight"),
- nullptr,
- _("メッセージ", "Display messages"),
- _("ダンジョン全体図", "Display overhead view"),
- _("モンスターの思い出", "Display monster recall"),
- _("アイテムの詳細", "Display object recall"),
- _("自分の周囲を表示", "Display dungeon view"),
- _("記念撮影", "Display snap-shot"),
- _("足元/床上のアイテム一覧", "Display items on floor"),
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr
+const concptr window_flag_desc[32] = {
+ _("持ち物/装備一覧", "Display inven/equip"),
+ _("装備/持ち物一覧", "Display equip/inven"),
+ _("呪文一覧", "Display spell list"),
+ _("キャラクタ情報", "Display character"),
+ _("視界内のモンスター表示", "Display monsters in sight"),
+ nullptr,
+ _("メッセージ", "Display messages"),
+ _("ダンジョン全体図", "Display overhead view"),
+ _("モンスターの思い出", "Display monster recall"),
+ _("アイテムの詳細", "Display object recall"),
+ _("自分の周囲を表示", "Display dungeon view"),
+ _("記念撮影", "Display snap-shot"),
+ _("足元/床上のアイテム一覧", "Display items on floor"),
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr
};
-
/*!
* @brief シンボル解説テーブル /
* The table of "symbol info" -- each entry is a string of the form "X:desc" where "X" is the trigger, and "desc" is the "info".
*/
-const concptr ident_info[] =
-{
+const concptr ident_info[] = {
#ifdef JP
- " :暗闇",
- "!:薬, オイル",
- "\":アミュレット, 頸飾り",
- "#:壁(隠しドア)/植物/気体",
- "$:財宝(金か宝石)",
- "%:鉱脈(溶岩か石英)",
- "&:箱",
- "':開いたドア",
- "(:軟らかい防具",
- "):盾",
- "*:財宝を含んだ鉱脈または球形の怪物",
- "+:閉じたドア",
- ",:食べ物, おばけキノコ",
- "-:魔法棒, ロッド",
- ".:床",
- "/:竿状武器(アックス/パイク/等)",
- "0:博物館の入口",
- "1:雑貨屋の入口",
- "2:防具屋の入口",
- "3:武器専門店の入口",
- "4:寺院の入口",
- "5:錬金術の店の入口",
- "6:魔法の店の入口",
- "7:ブラックマーケットの入口",
- "8:我が家の入口",
- "9:書店の入口",
- "::岩石",
- ";:守りのルーン/爆発のルーン",
- "<:上り階段",
- "=:指輪",
- ">:下り階段",
- "?:巻物",
- "@:プレイヤー",
- "A:天使",
- "B:鳥",
- "C:犬",
- "D:古代ドラゴン/ワイアーム",
- "E:エレメンタル",
- "F:トンボ",
- "G:ゴースト",
- "H:雑種",
- "I:昆虫",
- "J:ヘビ",
- "K:キラー・ビートル",
- "L:リッチ",
- "M:多首の爬虫類",
- "N:謎の生物",
- "O:オーガ",
- "P:巨大人間型生物",
- "Q:クイルスルグ(脈打つ肉塊)",
- "R:爬虫類/両生類",
- "S:蜘蛛/サソリ/ダニ",
- "T:トロル",
- "U:上級デーモン",
- "V:バンパイア",
- "W:ワイト/レイス/等",
- "X:ゾーン/ザレン/等",
- "Y:イエティ",
- "Z:ハウンド",
- "[:堅いアーマー",
- "\\:鈍器(メイス/ムチ/等)",
- "]:種々の防具",
- "^:トラップ",
- "_:杖",
- "`:人形，彫像",
- "a:アリ",
- "b:コウモリ",
- "c:ムカデ",
- "d:ドラゴン",
- "e:目玉",
- "f:ネコ",
- "g:ゴーレム",
- "h:ホビット/エルフ/ドワーフ",
- "i:ベトベト",
- "j:ゼリー",
- "k:コボルド",
- "l:水棲生物",
- "m:モルド",
- "n:ナーガ",
- "o:オーク",
- "p:人間",
- "q:四足獣",
- "r:ネズミ",
- "s:スケルトン",
- "t:町の人",
- "u:下級デーモン",
- "v:ボルテックス",
- "w:イモムシ/大群",
- /* "x:unused", */
- "y:イーク",
- "z:ゾンビ/ミイラ",
- "{:飛び道具の弾(矢/弾)",
- "|:刀剣類(ソード/ダガー/等)",
- "}:飛び道具(弓/クロスボウ/スリング)",
- "~:水/溶岩流(種々のアイテム)",
+ " :暗闇",
+ "!:薬, オイル",
+ "\":アミュレット, 頸飾り",
+ "#:壁(隠しドア)/植物/気体",
+ "$:財宝(金か宝石)",
+ "%:鉱脈(溶岩か石英)",
+ "&:箱",
+ "':開いたドア",
+ "(:軟らかい防具",
+ "):盾",
+ "*:財宝を含んだ鉱脈または球形の怪物",
+ "+:閉じたドア",
+ ",:食べ物, おばけキノコ",
+ "-:魔法棒, ロッド",
+ ".:床",
+ "/:竿状武器(アックス/パイク/等)",
+ "0:博物館の入口",
+ "1:雑貨屋の入口",
+ "2:防具屋の入口",
+ "3:武器専門店の入口",
+ "4:寺院の入口",
+ "5:錬金術の店の入口",
+ "6:魔法の店の入口",
+ "7:ブラックマーケットの入口",
+ "8:我が家の入口",
+ "9:書店の入口",
+ "::岩石",
+ ";:守りのルーン/爆発のルーン",
+ "<:上り階段",
+ "=:指輪",
+ ">:下り階段",
+ "?:巻物",
+ "@:プレイヤー",
+ "A:天使",
+ "B:鳥",
+ "C:犬",
+ "D:古代ドラゴン/ワイアーム",
+ "E:エレメンタル",
+ "F:トンボ",
+ "G:ゴースト",
+ "H:雑種",
+ "I:昆虫",
+ "J:ヘビ",
+ "K:キラー・ビートル",
+ "L:リッチ",
+ "M:多首の爬虫類",
+ "N:謎の生物",
+ "O:オーガ",
+ "P:巨大人間型生物",
+ "Q:クイルスルグ(脈打つ肉塊)",
+ "R:爬虫類/両生類",
+ "S:蜘蛛/サソリ/ダニ",
+ "T:トロル",
+ "U:上級デーモン",
+ "V:バンパイア",
+ "W:ワイト/レイス/等",
+ "X:ゾーン/ザレン/等",
+ "Y:イエティ",
+ "Z:ハウンド",
+ "[:堅いアーマー",
+ "\\:鈍器(メイス/ムチ/等)",
+ "]:種々の防具",
+ "^:トラップ",
+ "_:杖",
+ "`:人形，彫像",
+ "a:アリ",
+ "b:コウモリ",
+ "c:ムカデ",
+ "d:ドラゴン",
+ "e:目玉",
+ "f:ネコ",
+ "g:ゴーレム",
+ "h:ホビット/エルフ/ドワーフ",
+ "i:ベトベト",
+ "j:ゼリー",
+ "k:コボルド",
+ "l:水棲生物",
+ "m:モルド",
+ "n:ナーガ",
+ "o:オーク",
+ "p:人間",
+ "q:四足獣",
+ "r:ネズミ",
+ "s:スケルトン",
+ "t:町の人",
+ "u:下級デーモン",
+ "v:ボルテックス",
+ "w:イモムシ/大群",
+ /* "x:unused", */
+ "y:イーク",
+ "z:ゾンビ/ミイラ",
+ "{:飛び道具の弾(矢/弾)",
+ "|:刀剣類(ソード/ダガー/等)",
+ "}:飛び道具(弓/クロスボウ/スリング)",
+ "~:水/溶岩流(種々のアイテム)",
#else
- " :A dark grid",
- "!:A potion (or oil)",
- "\":An amulet (or necklace)",
- "#:A wall (or secret door) / a plant / a gas",
- "$:Treasure (gold or gems)",
- "%:A vein (magma or quartz)",
- "&:A chest",
- "':An open door",
- "(:Soft armor",
- "):A shield",
- "*:A vein with treasure or a ball monster",
- "+:A closed door",
- ",:Food (or mushroom patch)",
- "-:A wand (or rod)",
- ".:Floor",
- "/:A polearm (Axe/Pike/etc)",
- "0:Entrance to the Museum",
- "1:Entrance to the General Store",
- "2:Entrance to the Armoury",
- "3:Entrance to the Weaponsmith's Shop",
- "4:Entrance to the Temple",
- "5:Entrance to the Alchemy Shop",
- "6:Entrance to the Magic Shop",
- "7:Entrance to the Black Market",
- "8:Entrance to your home",
- "9:Entrance to the Bookstore",
- "::Rubble",
- ";:A rune of protection / an explosive rune",
- "<:An up staircase",
- "=:A ring",
- ">:A down staircase",
- "?:A scroll",
- "@:You",
- "A:Angel",
- "B:Bird",
- "C:Canine",
- "D:Ancient Dragon/Wyrm",
- "E:Elemental",
- "F:Dragon Fly",
- "G:Ghost",
- "H:Hybrid",
- "I:Insect",
- "J:Snake",
- "K:Killer Beetle",
- "L:Lich",
- "M:Multi-Headed Reptile",
- "N:Mystery Living",
- "O:Ogre",
- "P:Giant Humanoid",
- "Q:Quylthulg (Pulsing Flesh Mound)",
- "R:Reptile/Amphibian",
- "S:Spider/Scorpion/Tick",
- "T:Troll",
- "U:Major Demon",
- "V:Vampire",
- "W:Wight/Wraith/etc",
- "X:Xorn/Xaren/etc",
- "Y:Yeti",
- "Z:Zephyr Hound",
- "[:Hard armor",
- "\\:A hafted weapon (mace/whip/etc)",
- "]:Misc. armor",
- "^:A trap",
- "_:A staff",
- "`:A figurine or statue",
- "a:Ant",
- "b:Bat",
- "c:Centipede",
- "d:Dragon",
- "e:Floating Eye",
- "f:Feline",
- "g:Golem",
- "h:Hobbit/Elf/Dwarf",
- "i:Icky Thing",
- "j:Jelly",
- "k:Kobold",
- "l:Aquatic monster",
- "m:Mold",
- "n:Naga",
- "o:Orc",
- "p:Person/Human",
- "q:Quadruped",
- "r:Rodent",
- "s:Skeleton",
- "t:Townsperson",
- "u:Minor Demon",
- "v:Vortex",
- "w:Worm/Worm-Mass",
- /* "x:unused", */
- "y:Yeek",
- "z:Zombie/Mummy",
- "{:A missile (arrow/bolt/shot)",
- "|:An edged weapon (sword/dagger/etc)",
- "}:A launcher (bow/crossbow/sling)",
- "~:Fluid terrain (or miscellaneous item)",
+ " :A dark grid",
+ "!:A potion (or oil)",
+ "\":An amulet (or necklace)",
+ "#:A wall (or secret door) / a plant / a gas",
+ "$:Treasure (gold or gems)",
+ "%:A vein (magma or quartz)",
+ "&:A chest",
+ "':An open door",
+ "(:Soft armor",
+ "):A shield",
+ "*:A vein with treasure or a ball monster",
+ "+:A closed door",
+ ",:Food (or mushroom patch)",
+ "-:A wand (or rod)",
+ ".:Floor",
+ "/:A polearm (Axe/Pike/etc)",
+ "0:Entrance to the Museum",
+ "1:Entrance to the General Store",
+ "2:Entrance to the Armoury",
+ "3:Entrance to the Weaponsmith's Shop",
+ "4:Entrance to the Temple",
+ "5:Entrance to the Alchemy Shop",
+ "6:Entrance to the Magic Shop",
+ "7:Entrance to the Black Market",
+ "8:Entrance to your home",
+ "9:Entrance to the Bookstore",
+ "::Rubble",
+ ";:A rune of protection / an explosive rune",
+ "<:An up staircase",
+ "=:A ring",
+ ">:A down staircase",
+ "?:A scroll",
+ "@:You",
+ "A:Angel",
+ "B:Bird",
+ "C:Canine",
+ "D:Ancient Dragon/Wyrm",
+ "E:Elemental",
+ "F:Dragon Fly",
+ "G:Ghost",
+ "H:Hybrid",
+ "I:Insect",
+ "J:Snake",
+ "K:Killer Beetle",
+ "L:Lich",
+ "M:Multi-Headed Reptile",
+ "N:Mystery Living",
+ "O:Ogre",
+ "P:Giant Humanoid",
+ "Q:Quylthulg (Pulsing Flesh Mound)",
+ "R:Reptile/Amphibian",
+ "S:Spider/Scorpion/Tick",
+ "T:Troll",
+ "U:Major Demon",
+ "V:Vampire",
+ "W:Wight/Wraith/etc",
+ "X:Xorn/Xaren/etc",
+ "Y:Yeti",
+ "Z:Zephyr Hound",
+ "[:Hard armor",
+ "\\:A hafted weapon (mace/whip/etc)",
+ "]:Misc. armor",
+ "^:A trap",
+ "_:A staff",
+ "`:A figurine or statue",
+ "a:Ant",
+ "b:Bat",
+ "c:Centipede",
+ "d:Dragon",
+ "e:Floating Eye",
+ "f:Feline",
+ "g:Golem",
+ "h:Hobbit/Elf/Dwarf",
+ "i:Icky Thing",
+ "j:Jelly",
+ "k:Kobold",
+ "l:Aquatic monster",
+ "m:Mold",
+ "n:Naga",
+ "o:Orc",
+ "p:Person/Human",
+ "q:Quadruped",
+ "r:Rodent",
+ "s:Skeleton",
+ "t:Townsperson",
+ "u:Minor Demon",
+ "v:Vortex",
+ "w:Worm/Worm-Mass",
+ /* "x:unused", */
+ "y:Yeek",
+ "z:Zombie/Mummy",
+ "{:A missile (arrow/bolt/shot)",
+ "|:An edged weapon (sword/dagger/etc)",
+ "}:A launcher (bow/crossbow/sling)",
+ "~:Fluid terrain (or miscellaneous item)",
#endif
- nullptr
+ nullptr
};
/*
/*
* Default spell color table (quark index)
*/
-TERM_COLOR gf_color[MAX_GF];
+TERM_COLOR gf_color[(int)AttributeType::MAX];
/*!
* @brief 万色表現用にランダムな色を選択する関数 /
*/
static TERM_COLOR mh_attr(int max)
{
- switch (randint1(max))
- {
- case 1: return (TERM_RED);
- case 2: return (TERM_GREEN);
- case 3: return (TERM_BLUE);
- case 4: return (TERM_YELLOW);
- case 5: return (TERM_ORANGE);
- case 6: return (TERM_VIOLET);
- case 7: return (TERM_L_RED);
- case 8: return (TERM_L_GREEN);
- case 9: return (TERM_L_BLUE);
- case 10: return (TERM_UMBER);
- case 11: return (TERM_L_UMBER);
- case 12: return (TERM_SLATE);
- case 13: return (TERM_WHITE);
- case 14: return (TERM_L_WHITE);
- case 15: return (TERM_L_DARK);
- }
-
- return (TERM_WHITE);
+ switch (randint1(max)) {
+ case 1:
+ return (TERM_RED);
+ case 2:
+ return (TERM_GREEN);
+ case 3:
+ return (TERM_BLUE);
+ case 4:
+ return (TERM_YELLOW);
+ case 5:
+ return (TERM_ORANGE);
+ case 6:
+ return (TERM_VIOLET);
+ case 7:
+ return (TERM_L_RED);
+ case 8:
+ return (TERM_L_GREEN);
+ case 9:
+ return (TERM_L_BLUE);
+ case 10:
+ return (TERM_UMBER);
+ case 11:
+ return (TERM_L_UMBER);
+ case 12:
+ return (TERM_SLATE);
+ case 13:
+ return (TERM_WHITE);
+ case 14:
+ return (TERM_L_WHITE);
+ case 15:
+ return (TERM_L_DARK);
+ }
+
+ return (TERM_WHITE);
}
-
/*!
* @brief 魔法属性に応じたエフェクトの色を返す /
* Return a color to use for the bolt/ball spells
* @param type 魔法属性
* @return 対応する色ID
*/
-static TERM_COLOR spell_color(EFFECT_ID type)
+static TERM_COLOR spell_color(AttributeType type)
{
- /* Check if A.B.'s new graphics should be used (rr9) */
- if (streq(ANGBAND_GRAF, "new") || streq(ANGBAND_GRAF, "ne2"))
- {
- /* Analyze */
- switch (type)
- {
- case GF_PSY_SPEAR: return (0x06);
- case GF_MISSILE: return (0x0F);
- case GF_ACID: return (0x04);
- case GF_ELEC: return (0x02);
- case GF_FIRE: return (0x00);
- case GF_COLD: return (0x01);
- case GF_POIS: return (0x03);
- case GF_HOLY_FIRE: return (0x00);
- case GF_HELL_FIRE: return (0x00);
- case GF_MANA: return (0x0E);
- /* by henkma */
- case GF_SEEKER: return (0x0E);
- case GF_SUPER_RAY: return (0x0E);
-
- case GF_ARROW: return (0x0F);
- case GF_WATER: return (0x04);
- case GF_NETHER: return (0x07);
- case GF_CHAOS: return (mh_attr(15));
- case GF_DISENCHANT: return (0x05);
- case GF_NEXUS: return (0x0C);
- case GF_CONFUSION: return (mh_attr(4));
- case GF_SOUND: return (0x09);
- case GF_SHARDS: return (0x08);
- case GF_FORCE: return (0x09);
- case GF_INERTIAL: return (0x09);
- case GF_GRAVITY: return (0x09);
- case GF_TIME: return (0x09);
- case GF_LITE_WEAK: return (0x06);
- case GF_LITE: return (0x06);
- case GF_DARK_WEAK: return (0x07);
- case GF_DARK: return (0x07);
- case GF_PLASMA: return (0x0B);
- case GF_METEOR: return (0x00);
- case GF_ICE: return (0x01);
- case GF_ROCKET: return (0x0F);
- case GF_DEATH_RAY: return (0x07);
- case GF_NUKE: return (mh_attr(2));
- case GF_DISINTEGRATE: return (0x05);
- case GF_PSI:
- case GF_PSI_DRAIN:
- case GF_TELEKINESIS:
- case GF_DOMINATION:
- case GF_DRAIN_MANA:
- case GF_MIND_BLAST:
- case GF_BRAIN_SMASH:
- return (0x09);
- case GF_CAUSE_1:
- case GF_CAUSE_2:
- case GF_CAUSE_3:
- case GF_CAUSE_4: return (0x0E);
- case GF_HAND_DOOM: return (0x07);
- case GF_CAPTURE: return (0x0E);
- case GF_IDENTIFY: return (0x01);
- case GF_ATTACK: return (0x0F);
- case GF_PHOTO: return (0x06);
- }
- }
- /* Normal tiles or ASCII */
- else
- {
- TERM_COLOR a;
- SYMBOL_CODE c;
-
- /* Lookup the default colors for this type */
- concptr s = quark_str(gf_color[type]);
-
- if (!s) return (TERM_WHITE);
-
- /* Pick a random color */
- c = s[randint0(strlen(s))];
-
- /* Lookup this color */
- a = angband_strchr(color_char, c) - color_char;
-
- /* Invalid color (note check for < 0 removed, gave a silly
+ /* Check if A.B.'s new graphics should be used (rr9) */
+ if (streq(ANGBAND_GRAF, "new") || streq(ANGBAND_GRAF, "ne2")) {
+ /* Analyze */
+ switch (type) {
+ case AttributeType::PSY_SPEAR:
+ return (0x06);
+ case AttributeType::MISSILE:
+ return (0x0F);
+ case AttributeType::ACID:
+ return (0x04);
+ case AttributeType::ELEC:
+ return (0x02);
+ case AttributeType::FIRE:
+ return (0x00);
+ case AttributeType::COLD:
+ return (0x01);
+ case AttributeType::POIS:
+ return (0x03);
+ case AttributeType::HOLY_FIRE:
+ return (0x00);
+ case AttributeType::HELL_FIRE:
+ return (0x00);
+ case AttributeType::MANA:
+ return (0x0E);
+ /* by henkma */
+ case AttributeType::SEEKER:
+ return (0x0E);
+ case AttributeType::SUPER_RAY:
+ return (0x0E);
+
+ case AttributeType::ARROW:
+ return (0x0F);
+ case AttributeType::WATER:
+ return (0x04);
+ case AttributeType::NETHER:
+ return (0x07);
+ case AttributeType::CHAOS:
+ return (mh_attr(15));
+ case AttributeType::DISENCHANT:
+ return (0x05);
+ case AttributeType::NEXUS:
+ return (0x0C);
+ case AttributeType::CONFUSION:
+ return (mh_attr(4));
+ case AttributeType::SOUND:
+ return (0x09);
+ case AttributeType::SHARDS:
+ return (0x08);
+ case AttributeType::FORCE:
+ return (0x09);
+ case AttributeType::INERTIAL:
+ return (0x09);
+ case AttributeType::GRAVITY:
+ return (0x09);
+ case AttributeType::TIME:
+ return (0x09);
+ case AttributeType::LITE_WEAK:
+ return (0x06);
+ case AttributeType::LITE:
+ return (0x06);
+ case AttributeType::DARK_WEAK:
+ return (0x07);
+ case AttributeType::DARK:
+ return (0x07);
+ case AttributeType::PLASMA:
+ return (0x0B);
+ case AttributeType::METEOR:
+ return (0x00);
+ case AttributeType::ICE:
+ return (0x01);
+ case AttributeType::ROCKET:
+ return (0x0F);
+ case AttributeType::DEATH_RAY:
+ return (0x07);
+ case AttributeType::NUKE:
+ return (mh_attr(2));
+ case AttributeType::DISINTEGRATE:
+ return (0x05);
+ case AttributeType::PSI: /* fall through */
+ case AttributeType::PSI_DRAIN: /* fall through */
+ case AttributeType::TELEKINESIS: /* fall through */
+ case AttributeType::DOMINATION: /* fall through */
+ case AttributeType::DRAIN_MANA: /* fall through */
+ case AttributeType::MIND_BLAST: /* fall through */
+ case AttributeType::BRAIN_SMASH:
+ return (0x09);
+ case AttributeType::CAUSE_1: /* fall through */
+ case AttributeType::CAUSE_2: /* fall through */
+ case AttributeType::CAUSE_3: /* fall through */
+ case AttributeType::CAUSE_4:
+ return (0x0E);
+ case AttributeType::HAND_DOOM:
+ return (0x07);
+ case AttributeType::CAPTURE:
+ return (0x0E);
+ case AttributeType::IDENTIFY:
+ return (0x01);
+ case AttributeType::ATTACK:
+ return (0x0F);
+ case AttributeType::PHOTO:
+ return (0x06);
+ default:
+ break;
+ }
+ }
+ /* Normal tiles or ASCII */
+ else {
+ TERM_COLOR a;
+ SYMBOL_CODE c;
+
+ /* Lookup the default colors for this type */
+ concptr s = quark_str(gf_color[(int)type]);
+
+ if (!s)
+ return (TERM_WHITE);
+
+ /* Pick a random color */
+ c = s[randint0(strlen(s))];
+
+ /* Lookup this color */
+ a = angband_strchr(color_char, c) - color_char;
+
+ /* Invalid color (note check for < 0 removed, gave a silly
* warning because bytes are always >= 0 -- RG) */
- if (a > 15) return (TERM_WHITE);
+ if (a > 15)
+ return (TERM_WHITE);
- /* Use this color */
- return (a);
- }
+ /* Use this color */
+ return (a);
+ }
- /* Standard "color" */
- return (TERM_WHITE);
+ /* Standard "color" */
+ return (TERM_WHITE);
}
-
/*!
* @brief 始点から終点にかけた方向毎にボルトのキャラクタを返す /
* Find the attr/char pair to use for a spell effect
* If the distance is not "one", we (may) return "*".
* </pre>
*/
-uint16_t bolt_pict(POSITION y, POSITION x, POSITION ny, POSITION nx, EFFECT_ID typ)
+uint16_t bolt_pict(POSITION y, POSITION x, POSITION ny, POSITION nx, AttributeType typ)
{
- int base;
+ int base;
- byte k;
+ byte k;
- TERM_COLOR a;
- SYMBOL_CODE c;
+ TERM_COLOR a;
+ SYMBOL_CODE c;
- /* No motion (*) */
- if ((ny == y) && (nx == x)) base = 0x30;
+ /* No motion (*) */
+ if ((ny == y) && (nx == x))
+ base = 0x30;
- /* Vertical (|) */
- else if (nx == x) base = 0x40;
+ /* Vertical (|) */
+ else if (nx == x)
+ base = 0x40;
- /* Horizontal (-) */
- else if (ny == y) base = 0x50;
+ /* Horizontal (-) */
+ else if (ny == y)
+ base = 0x50;
- /* Diagonal (/) */
- else if ((ny - y) == (x - nx)) base = 0x60;
+ /* Diagonal (/) */
+ else if ((ny - y) == (x - nx))
+ base = 0x60;
- /* Diagonal (\) */
- else if ((ny - y) == (nx - x)) base = 0x70;
+ /* Diagonal (\) */
+ else if ((ny - y) == (nx - x))
+ base = 0x70;
- /* Weird (*) */
- else base = 0x30;
+ /* Weird (*) */
+ else
+ base = 0x30;
- /* Basic spell color */
- k = spell_color(typ);
+ /* Basic spell color */
+ k = spell_color(typ);
- /* Obtain attr/char */
- a = misc_to_attr[base + k];
- c = misc_to_char[base + k];
+ /* Obtain attr/char */
+ a = misc_to_attr[base + k];
+ c = misc_to_char[base + k];
- /* Create pict */
- return (PICT(a, c));
+ /* Create pict */
+ return (PICT(a, c));
}
-
-
-
/*!
* @brief シンボル1文字をカラーIDに変更する /
* Convert a "color letter" into an "actual" color
*/
TERM_COLOR color_char_to_attr(SYMBOL_CODE c)
{
- switch (c)
- {
- case 'd': return (TERM_DARK);
- case 'w': return (TERM_WHITE);
- case 's': return (TERM_SLATE);
- case 'o': return (TERM_ORANGE);
- case 'r': return (TERM_RED);
- case 'g': return (TERM_GREEN);
- case 'b': return (TERM_BLUE);
- case 'u': return (TERM_UMBER);
-
- case 'D': return (TERM_L_DARK);
- case 'W': return (TERM_L_WHITE);
- case 'v': return (TERM_VIOLET);
- case 'y': return (TERM_YELLOW);
- case 'R': return (TERM_L_RED);
- case 'G': return (TERM_L_GREEN);
- case 'B': return (TERM_L_BLUE);
- case 'U': return (TERM_L_UMBER);
- }
-
- return (255);
+ switch (c) {
+ case 'd':
+ return (TERM_DARK);
+ case 'w':
+ return (TERM_WHITE);
+ case 's':
+ return (TERM_SLATE);
+ case 'o':
+ return (TERM_ORANGE);
+ case 'r':
+ return (TERM_RED);
+ case 'g':
+ return (TERM_GREEN);
+ case 'b':
+ return (TERM_BLUE);
+ case 'u':
+ return (TERM_UMBER);
+
+ case 'D':
+ return (TERM_L_DARK);
+ case 'W':
+ return (TERM_L_WHITE);
+ case 'v':
+ return (TERM_VIOLET);
+ case 'y':
+ return (TERM_YELLOW);
+ case 'R':
+ return (TERM_L_RED);
+ case 'G':
+ return (TERM_L_GREEN);
+ case 'B':
+ return (TERM_L_BLUE);
+ case 'U':
+ return (TERM_L_UMBER);
+ }
+
+ return (255);
}
-
-
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
/*
* Convert a "pict" (P) into an "attr" (A)
extern const char angband_term_name[8][16];
extern byte angband_color_table[256][4];
-extern TERM_COLOR gf_color[MAX_GF];
+extern TERM_COLOR gf_color[(int)AttributeType::MAX];
extern TERM_COLOR color_char_to_attr(SYMBOL_CODE c);
-uint16_t bolt_pict(POSITION y, POSITION x, POSITION ny, POSITION nx, EFFECT_ID typ);
+uint16_t bolt_pict(POSITION y, POSITION x, POSITION ny, POSITION nx, AttributeType typ);
wiz_jump_to_dungeon(player_ptr);
break;
case 'k':
- wiz_kill_me(player_ptr, 0, command_arg);
+ wiz_kill_me(player_ptr, 0, (AttributeType)command_arg);
break;
case 'm':
map_area(player_ptr, DETECT_RAD_ALL * 3);
wiz_kill_enemy(player_ptr);
break;
case 'Y':
- wiz_kill_enemy(player_ptr, 0, command_arg);
+ wiz_kill_enemy(player_ptr, 0, (AttributeType)command_arg);
break;
case 'z':
wiz_zap_surrounding_monsters(player_ptr);
* @param effect_idx 属性ID
* @details デフォルトは100万・GF_ARROW(射撃)。RES_ALL持ちも一撃で殺せる。
*/
-void wiz_kill_enemy(player_type *player_ptr, HIT_POINT dam, EFFECT_ID effect_idx)
+void wiz_kill_enemy(player_type *player_ptr, HIT_POINT dam, AttributeType effect_idx)
{
if (dam <= 0) {
char tmp[80] = "";
dam = (HIT_POINT)atoi(tmp_val);
}
+ int max = (int)AttributeType::MAX;
+ int idx = (int)effect_idx;
- if (effect_idx <= GF_NONE) {
+ if (idx <= 0) {
char tmp[80] = "";
- sprintf(tmp, "Effect ID (1-%d): ", MAX_GF - 1);
+ sprintf(tmp, "Effect ID (1-%d): ", max - 1);
char tmp_val[10] = "";
if (!get_string(tmp, tmp_val, 3))
return;
- effect_idx = (EFFECT_ID)atoi(tmp_val);
+ effect_idx = (AttributeType)atoi(tmp_val);
}
- if (effect_idx <= GF_NONE || effect_idx >= MAX_GF) {
- msg_format(_("番号は1から%dの間で指定して下さい。", "ID must be between 1 to %d."), MAX_GF - 1);
+ if (idx <= 0 || idx >= max) {
+ msg_format(_("番号は1から%dの間で指定して下さい。", "ID must be between 1 to %d."), max - 1);
return;
}
* @param dam ダメージ量
* @param effect_idx 属性ID
*/
-void wiz_kill_me(player_type *player_ptr, HIT_POINT dam, EFFECT_ID effect_idx)
+void wiz_kill_me(player_type *player_ptr, HIT_POINT dam, AttributeType effect_idx)
{
if (dam <= 0) {
char tmp[80] = "";
dam = (HIT_POINT)atoi(tmp_val);
}
+ int max = (int)AttributeType::MAX;
+ int idx = (int)effect_idx;
- if (effect_idx <= GF_NONE) {
+ if (idx <= 0) {
char tmp[80] = "";
- sprintf(tmp, "Effect ID (1-%d): ", MAX_GF - 1);
+ sprintf(tmp, "Effect ID (1-%d): ", max - 1);
char tmp_val[10] = "1";
if (!get_string(tmp, tmp_val, 3))
return;
- effect_idx = (EFFECT_ID)atoi(tmp_val);
+ effect_idx = (AttributeType)atoi(tmp_val);
}
- if (effect_idx <= GF_NONE || effect_idx >= MAX_GF) {
- msg_format(_("番号は1から%dの間で指定して下さい。", "ID must be between 1 to %d."), MAX_GF - 1);
+ if (idx <= 0 || idx >= max) {
+ msg_format(_("番号は1から%dの間で指定して下さい。", "ID must be between 1 to %d."), max - 1);
return;
}
#pragma once
#include "system/angband.h"
-#include "spell/spell-types.h"
+#include "effect/attribute-types.h"
#define SPELL_MAX 5
void wiz_summon_random_enemy(player_type *player_ptr, int num);
void wiz_summon_specific_enemy(player_type *player_ptr, MONRACE_IDX r_idx);
void wiz_summon_pet(player_type *player_ptr, MONRACE_IDX r_idx);
-void wiz_kill_enemy(player_type *player_ptr, HIT_POINT dam = 1000000, EFFECT_ID effect_idx = GF_ARROW);
-void wiz_kill_me(player_type *player_ptr, HIT_POINT dam, EFFECT_ID effect_idx);
+void wiz_kill_enemy(player_type *player_ptr, HIT_POINT dam = 1000000, AttributeType effect_idx = AttributeType::ARROW);
+void wiz_kill_me(player_type *player_ptr, HIT_POINT dam, AttributeType effect_idx);
OSDN Git Service
