return true;
}
- if (is_shero(player_ptr) && (player_ptr->pclass != CLASS_BERSERKER)) {
+ if (is_shero(player_ptr) && (player_ptr->pclass != PlayerClassType::BERSERKER)) {
msg_format(_("狂戦士化していて頭が回らない！", "You cannot think directly!"));
return true;
}
static void decide_activation_success(player_type *player_ptr, ae_type *ae_ptr)
{
- if (player_ptr->pclass == CLASS_BERSERKER) {
+ if (player_ptr->pclass == PlayerClassType::BERSERKER) {
ae_ptr->success = false;
return;
}
health_track(player_ptr, g_ptr->m_idx);
}
- if ((stormbringer && (randint1(1000) > 666)) || (player_ptr->pclass == CLASS_BERSERKER)) {
+ if ((stormbringer && (randint1(1000) > 666)) || (player_ptr->pclass == PlayerClassType::BERSERKER)) {
do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
can_move = false;
} else if (monster_can_cross_terrain(player_ptr, floor_ptr->grid_array[player_ptr->y][player_ptr->x].feat, r_ptr, 0)) {
player_ptr->running = 0;
can_move = false;
} else if (f_ptr->flags.has(FF::TREE) && !p_can_kill_walls) {
- if ((player_ptr->pclass != CLASS_RANGER) && !player_ptr->levitation && (!player_ptr->riding || !(riding_r_ptr->flags8 & RF8_WILD_WOOD))) {
+ if ((player_ptr->pclass != PlayerClassType::RANGER) && !player_ptr->levitation && (!player_ptr->riding || !(riding_r_ptr->flags8 & RF8_WILD_WOOD))) {
energy.mul_player_turn_energy(2);
}
} else if ((do_pickup != easy_disarm) && f_ptr->flags.has(FF::DISARM) && !g_ptr->mimic) {
PlayerEnergy(player_ptr).set_player_turn_energy(100);
msg_format(_("%sに体当たりをした！", "You smash into the %s!"), name);
temp = (bash - (temp * 10));
- if (player_ptr->pclass == CLASS_BERSERKER)
+ if (player_ptr->pclass == PlayerClassType::BERSERKER)
temp *= 2;
if (temp < 1)
difficulty -= lev_adj;
}
- auto special_easy = player_ptr->pclass == CLASS_IMITATOR;
+ auto special_easy = player_ptr->pclass == PlayerClassType::IMITATOR;
special_easy &= player_ptr->inventory_list[INVEN_NECK].name1 == ART_GOGO_PENDANT;
special_easy &= rpi_ptr->racial_name.compare("倍返し") == 0;
if (special_easy) {
return false;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_ARCHER:
- case CLASS_CAVALRY:
- case CLASS_BERSERKER:
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::CAVALRY:
+ case PlayerClassType::BERSERKER:
return true;
default:
o_ptr->art_flags.set(TR_AGGRAVATE);
{
switch (o_ptr->name1) {
case ART_MURAMASA:
- if (player_ptr->pclass != CLASS_SAMURAI) {
+ if (player_ptr->pclass != PlayerClassType::SAMURAI) {
o_ptr->art_flags.set(TR_NO_MAGIC);
o_ptr->curse_flags.set(TRC::HEAVY_CURSE);
}
return;
case ART_ROBINTON:
- if (player_ptr->pclass == CLASS_BARD)
+ if (player_ptr->pclass == PlayerClassType::BARD)
o_ptr->art_flags.set(TR_DEC_MANA);
return;
case ART_XIAOLONG:
- if (player_ptr->pclass == CLASS_MONK)
+ if (player_ptr->pclass == PlayerClassType::MONK)
o_ptr->art_flags.set(TR_BLOWS);
return;
case ART_BLOOD:
o_ptr->curse_flags.set({ TRC::HEAVY_CURSE, TRC::CURSED });
o_ptr->art_flags.reset(TR_BLESSED);
add_negative_flags(o_ptr);
- if ((player_ptr->pclass != CLASS_WARRIOR) && (player_ptr->pclass != CLASS_ARCHER) && (player_ptr->pclass != CLASS_CAVALRY)
- && (player_ptr->pclass != CLASS_BERSERKER) && (player_ptr->pclass != CLASS_SMITH) && one_in_(3))
+ if ((player_ptr->pclass != PlayerClassType::WARRIOR) && (player_ptr->pclass != PlayerClassType::ARCHER) && (player_ptr->pclass != PlayerClassType::CAVALRY)
+ && (player_ptr->pclass != PlayerClassType::BERSERKER) && (player_ptr->pclass != PlayerClassType::SMITH) && one_in_(3))
o_ptr->art_flags.set(TR_NO_MAGIC);
}
static void set_artifact_bias(player_type *player_ptr, object_type *o_ptr, int *warrior_artifact_bias)
{
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_BERSERKER:
- case CLASS_ARCHER:
- case CLASS_SAMURAI:
- case CLASS_CAVALRY:
- case CLASS_SMITH:
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::BERSERKER:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::SAMURAI:
+ case PlayerClassType::CAVALRY:
+ case PlayerClassType::SMITH:
o_ptr->artifact_bias = BIAS_WARRIOR;
break;
- case CLASS_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_SORCERER:
- case CLASS_MAGIC_EATER:
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::SORCERER:
+ case PlayerClassType::MAGIC_EATER:
+ case PlayerClassType::BLUE_MAGE:
o_ptr->artifact_bias = BIAS_MAGE;
break;
- case CLASS_PRIEST:
+ case PlayerClassType::PRIEST:
o_ptr->artifact_bias = BIAS_PRIESTLY;
break;
- case CLASS_ROGUE:
- case CLASS_NINJA:
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::NINJA:
o_ptr->artifact_bias = BIAS_ROGUE;
*warrior_artifact_bias = 25;
break;
- case CLASS_RANGER:
- case CLASS_SNIPER:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::SNIPER:
o_ptr->artifact_bias = BIAS_RANGER;
*warrior_artifact_bias = 30;
break;
- case CLASS_PALADIN:
+ case PlayerClassType::PALADIN:
o_ptr->artifact_bias = BIAS_PRIESTLY;
*warrior_artifact_bias = 40;
break;
- case CLASS_WARRIOR_MAGE:
- case CLASS_RED_MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
+ case PlayerClassType::RED_MAGE:
o_ptr->artifact_bias = BIAS_MAGE;
*warrior_artifact_bias = 40;
break;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
o_ptr->artifact_bias = BIAS_CHAOS;
*warrior_artifact_bias = 40;
break;
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
o_ptr->artifact_bias = BIAS_PRIESTLY;
break;
- case CLASS_MINDCRAFTER:
- case CLASS_BARD:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::BARD:
if (randint1(5) > 2)
o_ptr->artifact_bias = BIAS_PRIESTLY;
break;
- case CLASS_TOURIST:
+ case PlayerClassType::TOURIST:
if (randint1(5) > 2)
o_ptr->artifact_bias = BIAS_WARRIOR;
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
if (randint1(2) > 1)
o_ptr->artifact_bias = BIAS_RANGER;
break;
- case CLASS_BEASTMASTER:
+ case PlayerClassType::BEASTMASTER:
o_ptr->artifact_bias = BIAS_CHR;
*warrior_artifact_bias = 50;
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
if (randint1(4) > 1)
o_ptr->artifact_bias = BIAS_MAGE;
else
o_ptr->artifact_bias = BIAS_ROGUE;
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
o_ptr->artifact_bias = one_in_(2) ? BIAS_MAGE : BIAS_INT;
break;
- case MAX_CLASS:
+ case PlayerClassType::MAX:
break;
}
}
if (player_ptr->prace == PlayerRaceType::BALROG) {
if (o_ptr->tval == ItemKindType::CORPSE && o_ptr->sval == SV_CORPSE && angband_strchr("pht", r_info[o_ptr->pval].d_char))
return false;
- } else if (player_ptr->pclass == CLASS_ARCHER) {
+ } else if (player_ptr->pclass == PlayerClassType::ARCHER) {
if (o_ptr->tval == ItemKindType::SKELETON || (o_ptr->tval == ItemKindType::CORPSE && o_ptr->sval == SV_SKELETON))
return false;
- } else if (player_ptr->pclass == CLASS_NINJA) {
+ } else if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->tval == ItemKindType::LITE && o_ptr->name2 == EGO_LITE_DARKNESS && o_ptr->is_known())
return false;
- } else if (player_ptr->pclass == CLASS_BEASTMASTER || player_ptr->pclass == CLASS_CAVALRY) {
+ } else if (player_ptr->pclass == PlayerClassType::BEASTMASTER || player_ptr->pclass == PlayerClassType::CAVALRY) {
if (o_ptr->tval == ItemKindType::WAND && o_ptr->sval == SV_WAND_HEAL_MONSTER && o_ptr->is_aware())
- return false;
+ return false;
}
return true;
name = false;
}
- bool realm_except_class = player_ptr->pclass == CLASS_SORCERER || player_ptr->pclass == CLASS_RED_MAGE;
+ bool realm_except_class = player_ptr->pclass == PlayerClassType::SORCERER || player_ptr->pclass == PlayerClassType::RED_MAGE;
if ((get_realm1_book(player_ptr) == o_ptr->tval) && !realm_except_class) {
ADD_FLG(FLG_REALM1);
if (IS_FLG(FLG_UNREADABLE) && (o_ptr->tval < ItemKindType::LIFE_BOOK || check_book_realm(player_ptr, o_ptr->tval, o_ptr->sval)))
return false;
- bool realm_except_class = player_ptr->pclass == CLASS_SORCERER || player_ptr->pclass == CLASS_RED_MAGE;
+ bool realm_except_class = player_ptr->pclass == PlayerClassType::SORCERER || player_ptr->pclass == PlayerClassType::RED_MAGE;
if (IS_FLG(FLG_REALM1) && ((get_realm1_book(player_ptr) != o_ptr->tval) || realm_except_class))
return false;
/* Get pre-defined types */
/* 1 or more virtues based on class */
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_SAMURAI:
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::SAMURAI:
player_ptr->vir_types[i++] = V_VALOUR;
player_ptr->vir_types[i++] = V_HONOUR;
break;
- case CLASS_MAGE:
+ case PlayerClassType::MAGE:
player_ptr->vir_types[i++] = V_KNOWLEDGE;
player_ptr->vir_types[i++] = V_ENCHANT;
break;
- case CLASS_PRIEST:
+ case PlayerClassType::PRIEST:
player_ptr->vir_types[i++] = V_FAITH;
player_ptr->vir_types[i++] = V_TEMPERANCE;
break;
- case CLASS_ROGUE:
- case CLASS_SNIPER:
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::SNIPER:
player_ptr->vir_types[i++] = V_HONOUR;
break;
- case CLASS_RANGER:
- case CLASS_ARCHER:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::ARCHER:
player_ptr->vir_types[i++] = V_NATURE;
player_ptr->vir_types[i++] = V_TEMPERANCE;
break;
- case CLASS_PALADIN:
+ case PlayerClassType::PALADIN:
player_ptr->vir_types[i++] = V_JUSTICE;
player_ptr->vir_types[i++] = V_VALOUR;
player_ptr->vir_types[i++] = V_HONOUR;
player_ptr->vir_types[i++] = V_FAITH;
break;
- case CLASS_WARRIOR_MAGE:
- case CLASS_RED_MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
+ case PlayerClassType::RED_MAGE:
player_ptr->vir_types[i++] = V_ENCHANT;
player_ptr->vir_types[i++] = V_VALOUR;
break;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
player_ptr->vir_types[i++] = V_CHANCE;
player_ptr->vir_types[i++] = V_INDIVIDUALISM;
break;
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
player_ptr->vir_types[i++] = V_FAITH;
player_ptr->vir_types[i++] = V_HARMONY;
player_ptr->vir_types[i++] = V_TEMPERANCE;
player_ptr->vir_types[i++] = V_PATIENCE;
break;
- case CLASS_MINDCRAFTER:
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::MIRROR_MASTER:
player_ptr->vir_types[i++] = V_HARMONY;
player_ptr->vir_types[i++] = V_ENLIGHTEN;
player_ptr->vir_types[i++] = V_PATIENCE;
break;
- case CLASS_HIGH_MAGE:
- case CLASS_SORCERER:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::SORCERER:
player_ptr->vir_types[i++] = V_ENLIGHTEN;
player_ptr->vir_types[i++] = V_ENCHANT;
player_ptr->vir_types[i++] = V_KNOWLEDGE;
break;
- case CLASS_TOURIST:
+ case PlayerClassType::TOURIST:
player_ptr->vir_types[i++] = V_ENLIGHTEN;
player_ptr->vir_types[i++] = V_CHANCE;
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
player_ptr->vir_types[i++] = V_CHANCE;
break;
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
player_ptr->vir_types[i++] = V_CHANCE;
player_ptr->vir_types[i++] = V_KNOWLEDGE;
break;
- case CLASS_BEASTMASTER:
+ case PlayerClassType::BEASTMASTER:
player_ptr->vir_types[i++] = V_NATURE;
player_ptr->vir_types[i++] = V_CHANCE;
player_ptr->vir_types[i++] = V_VITALITY;
break;
- case CLASS_MAGIC_EATER:
+ case PlayerClassType::MAGIC_EATER:
player_ptr->vir_types[i++] = V_ENCHANT;
player_ptr->vir_types[i++] = V_KNOWLEDGE;
break;
- case CLASS_BARD:
+ case PlayerClassType::BARD:
player_ptr->vir_types[i++] = V_HARMONY;
player_ptr->vir_types[i++] = V_COMPASSION;
break;
- case CLASS_CAVALRY:
+ case PlayerClassType::CAVALRY:
player_ptr->vir_types[i++] = V_VALOUR;
player_ptr->vir_types[i++] = V_HARMONY;
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
player_ptr->vir_types[i++] = V_VALOUR;
player_ptr->vir_types[i++] = V_INDIVIDUALISM;
break;
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
player_ptr->vir_types[i++] = V_HONOUR;
player_ptr->vir_types[i++] = V_KNOWLEDGE;
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
player_ptr->vir_types[i++] = V_PATIENCE;
player_ptr->vir_types[i++] = V_KNOWLEDGE;
player_ptr->vir_types[i++] = V_FAITH;
player_ptr->vir_types[i++] = V_UNLIFE;
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
player_ptr->vir_types[i++] = V_NATURE;
break;
- case MAX_CLASS:
+ case PlayerClassType::MAX:
break;
};
*/
static void decide_initial_stat(player_type *player_ptr, int *cval)
{
- auto &class_ptr = class_info[player_ptr->pclass];
- auto &magic_ptr = m_info[player_ptr->pclass];
+ auto pclass = enum2i(player_ptr->pclass);
+ auto &class_ptr = class_info[pclass];
+ auto &magic_ptr = m_info[pclass];
auto is_magic_user = magic_ptr.spell_stat == A_INT || magic_ptr.spell_stat == A_WIS || magic_ptr.spell_stat == A_CHR;
auto is_attacker = class_ptr.num > 3;
void get_money(player_type *player_ptr)
{
int gold = (player_ptr->sc * 6) + randint1(100) + 300;
- if (player_ptr->pclass == CLASS_TOURIST)
+ if (player_ptr->pclass == PlayerClassType::TOURIST)
gold += 2000;
for (int i = 0; i < A_MAX; i++) {
static TERM_COLOR birth_class_color(int cs)
{
- if (cs < MAX_CLASS) {
+ if (i2enum<PlayerClassType>(cs) < PlayerClassType::MAX) {
if (is_retired_class(i2enum<PlayerClassType>(cs)))
return TERM_L_DARK;
if (is_winner_class(i2enum<PlayerClassType>(cs)))
static void enumerate_class_list(char *sym)
{
- for (int n = 0; n < MAX_CLASS; n++) {
+ for (auto n = 0; i2enum<PlayerClassType>(n) < PlayerClassType::MAX; n++) {
cp_ptr = &class_info[n];
mp_ptr = &m_info[n];
concptr str = cp_ptr->title;
c_put_str(birth_class_color(*os), cur, 13 + (*os / 4), 2 + 19 * (*os % 4));
put_str(" ", 3, 40);
- if (cs == MAX_CLASS) {
+ if (i2enum<PlayerClassType>(cs) == PlayerClassType::MAX) {
sprintf(cur, "%c%c%s", '*', p2, _("ランダム", "Random"));
put_str(" ", 4, 40);
put_str(" ", 5, 40);
c_put_str(TERM_L_BLUE, buf, 6, 42);
put_str(_("隠密", "Stealth"), 6, 47);
- if (cs == CLASS_BERSERKER)
+ if (i2enum<PlayerClassType>(cs) == PlayerClassType::BERSERKER)
strcpy(buf, " xx");
else
sprintf(buf, " %+2d", cp_ptr->c_stl);
}
if (c == '6') {
- if (*cs < MAX_CLASS)
+ if (i2enum<PlayerClassType>(*cs) < PlayerClassType::MAX)
(*cs)++;
}
if (c == '2') {
- if ((*cs + 4) <= MAX_CLASS)
+ if (i2enum<PlayerClassType>(*cs + 4) <= PlayerClassType::MAX)
*cs += 4;
}
}
static bool select_class(player_type *player_ptr, char *cur, char *sym, int *k)
{
- int cs = player_ptr->pclass;
- int os = MAX_CLASS;
+ auto cs = player_ptr->pclass;
+ auto os = PlayerClassType::MAX;
while (true) {
- display_class_stat(cs, &os, cur, sym);
+ int int_os = enum2i(os);
+ display_class_stat(enum2i(cs), &int_os, cur, sym);
if (*k >= 0)
break;
char buf[80];
sprintf(buf, _("職業を選んで下さい (%c-%c) ('='初期オプション設定, 灰色:勝利済): ", "Choose a class (%c-%c) ('=' for options, Gray is winner): "),
- sym[0], sym[MAX_CLASS - 1]);
+ sym[0], sym[enum2i(PlayerClassType::MAX) - 1]);
put_str(buf, 10, 6);
char c = inkey();
return false;
if (c == ' ' || c == '\r' || c == '\n') {
- if (cs == MAX_CLASS) {
- *k = randint0(MAX_CLASS);
- cs = *k;
+ if (cs == PlayerClassType::MAX) {
+ *k = randint0(enum2i(PlayerClassType::MAX));
+ cs = i2enum<PlayerClassType>(*k);
continue;
} else {
- *k = cs;
+ *k = enum2i(cs);
break;
}
}
- interpret_class_select_key_move(c, &cs);
+ int int_cs = enum2i(cs);
+ interpret_class_select_key_move(c, &int_cs);
if (c == '*') {
- *k = randint0(MAX_CLASS);
- cs = *k;
+ *k = randint0(enum2i(PlayerClassType::MAX));
+ cs = i2enum<PlayerClassType>(*k);
continue;
}
*k = (islower(c) ? A2I(c) : -1);
- if ((*k >= 0) && (*k < MAX_CLASS)) {
- cs = *k;
+ if ((*k >= 0) && (i2enum<PlayerClassType>(*k) < PlayerClassType::MAX)) {
+ cs = i2enum<PlayerClassType>(*k);
continue;
}
*k = (isupper(c) ? (26 + c - 'A') : -1);
- if ((*k >= 26) && (*k < MAX_CLASS)) {
- cs = *k;
+ if ((*k >= 26) && (i2enum<PlayerClassType>(*k) < PlayerClassType::MAX)) {
+ cs = i2enum<PlayerClassType>(*k);
continue;
} else
*k = -1;
put_str(_("()で囲まれた選択肢はこの種族には似合わない職業です。", "Any entries in parentheses should only be used by advanced players."), 11, 5);
put_str(" ", 6, 40);
- char sym[MAX_CLASS];
+ char sym[enum2i(PlayerClassType::MAX)];
enumerate_class_list(sym);
char cur[80];
return false;
player_ptr->pclass = i2enum<PlayerClassType>(k);
- cp_ptr = &class_info[player_ptr->pclass];
- mp_ptr = &m_info[player_ptr->pclass];
+ cp_ptr = &class_info[enum2i(player_ptr->pclass)];
+ mp_ptr = &m_info[enum2i(player_ptr->pclass)];
c_put_str(TERM_L_BLUE, cp_ptr->title, 5, 15);
return true;
}
if (player_ptr->realm2 == REALM_SELECT_CANCEL)
return;
- if (player_ptr->pclass != CLASS_PRIEST)
+ if (player_ptr->pclass != PlayerClassType::PRIEST)
return;
if (is_good_realm(player_ptr->realm1)) {
player_ptr->realm1 = REALM_NONE;
player_ptr->realm2 = REALM_SELECT_CANCEL;
- if (player_ptr->pclass == CLASS_ELEMENTALIST) {
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST) {
player_ptr->element = select_element_realm(player_ptr);
if (player_ptr->element == REALM_SELECT_CANCEL)
return false;
while (true) {
char temp[80 * 10];
int count = 0;
- player_ptr->realm1 = select_realm(player_ptr, realm_choices1[player_ptr->pclass], &count);
+ player_ptr->realm1 = select_realm(player_ptr, realm_choices1[enum2i(player_ptr->pclass)], &count);
if (player_ptr->realm1 == REALM_SELECT_CANCEL)
return false;
if (!player_ptr->realm1)
while (true) {
char temp[80 * 8];
int count = 0;
- player_ptr->realm2 = select_realm(player_ptr, realm_choices2[player_ptr->pclass], &count);
+ player_ptr->realm2 = select_realm(player_ptr, realm_choices2[enum2i(player_ptr->pclass)], &count);
if (player_ptr->realm2 == REALM_SELECT_CANCEL)
return false;
if (player_ptr->prace != PlayerRaceType::ANDROID)
expfact += cp_ptr->c_exp;
- if (((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER) || (player_ptr->pclass == CLASS_NINJA))
+ if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || (player_ptr->pclass == PlayerClassType::NINJA))
&& ((player_ptr->prace == PlayerRaceType::KLACKON) || (player_ptr->prace == PlayerRaceType::SPRITE)))
expfact -= 15;
player_ptr->old_realm = 0;
for (int i = 0; i < 64; i++) {
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
player_ptr->spell_exp[i] = SPELL_EXP_MASTER;
- else if (player_ptr->pclass == CLASS_RED_MAGE)
+ else if (player_ptr->pclass == PlayerClassType::RED_MAGE)
player_ptr->spell_exp[i] = SPELL_EXP_SKILLED;
else
player_ptr->spell_exp[i] = SPELL_EXP_UNSKILLED;
}
+ auto pclass = enum2i(player_ptr->pclass);
for (int i = 0; i < 5; i++)
for (int j = 0; j < 64; j++)
- player_ptr->weapon_exp[i][j] = s_info[player_ptr->pclass].w_start[i][j];
+ player_ptr->weapon_exp[i][j] = s_info[pclass].w_start[i][j];
auto sexy_tval = ItemKindType::HAFTED - TV_WEAPON_BEGIN;
if ((player_ptr->ppersonality == PERSONALITY_SEXY) && (player_ptr->weapon_exp[sexy_tval][SV_WHIP] < WEAPON_EXP_BEGINNER)) {
}
for (int i = 0; i < MAX_SKILLS; i++)
- player_ptr->skill_exp[i] = s_info[player_ptr->pclass].s_start[i];
+ player_ptr->skill_exp[i] = s_info[pclass].s_start[i];
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
player_ptr->hitdie = rp_ptr->r_mhp / 2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
else
player_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
static bool let_player_select_class(player_type *player_ptr)
{
clear_from(10);
- player_ptr->pclass = CLASS_WARRIOR;
+ player_ptr->pclass = PlayerClassType::WARRIOR;
while (true) {
char temp[80 * 9];
if (!get_player_class(player_ptr))
return false;
clear_from(10);
- shape_buffer(class_explanations[player_ptr->pclass].data(), 74, temp, sizeof(temp));
+ shape_buffer(class_explanations[enum2i(player_ptr->pclass)].data(), 74, temp, sizeof(temp));
concptr t = temp;
for (int i = 0; i < 9; i++) {
if (t[0] == 0)
c_put_str(TERM_L_BLUE, buf, 6, 43);
put_str(_("隠密", "Stealth"), 6, 47);
- if (player_ptr->pclass == CLASS_BERSERKER)
+ if (player_ptr->pclass == PlayerClassType::BERSERKER)
strcpy(buf, "xx");
else
sprintf(buf, "%+2d", rp_ptr->r_stl + cp_ptr->c_stl + ap_ptr->a_stl);
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 1, buf);
sprintf(buf, _("%s種族に%sを選択した。", "%schose %s race."), indent, race_info[enum2i(player_ptr->prace)].title);
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 1, buf);
- sprintf(buf, _("%s職業に%sを選択した。", "%schose %s class."), indent, class_info[player_ptr->pclass].title);
+ sprintf(buf, _("%s職業に%sを選択した。", "%schose %s class."), indent, class_info[enum2i(player_ptr->pclass)].title);
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 1, buf);
if (player_ptr->realm1) {
sprintf(buf, _("%s魔法の領域に%s%sを選択した。", "%schose %s%s."), indent, realm_names[player_ptr->realm1],
}
sprintf(buf, _("%s性格に%sを選択した。", "%schose %s personality."), indent, personality_info[player_ptr->ppersonality].title);
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 1, buf);
- if (player_ptr->pclass == CLASS_CHAOS_WARRIOR) {
+ if (player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR) {
sprintf(buf, _("%s守護神%sと契約を交わした。", "%smade a contract with patron %s."), indent, patron_list[player_ptr->chaos_patron].name.c_str());
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 1, buf);
}
}
player_ptr->food = PY_FOOD_FULL - 1;
- if (player_ptr->pclass == CLASS_SORCERER) {
+ if (player_ptr->pclass == PlayerClassType::SORCERER) {
player_ptr->spell_learned1 = player_ptr->spell_learned2 = 0xffffffffL;
player_ptr->spell_worked1 = player_ptr->spell_worked2 = 0xffffffffL;
} else {
decide_initial_items(player_ptr, q_ptr);
q_ptr = &forge;
- if ((player_ptr->prace == PlayerRaceType::VAMPIRE) && (player_ptr->pclass != CLASS_NINJA)) {
+ if ((player_ptr->prace == PlayerRaceType::VAMPIRE) && (player_ptr->pclass != PlayerClassType::NINJA)) {
q_ptr->prep(lookup_kind(ItemKindType::SCROLL, SV_SCROLL_DARKNESS));
q_ptr->number = (ITEM_NUMBER)rand_range(2, 5);
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass != CLASS_NINJA) {
+ } else if (player_ptr->pclass != PlayerClassType::NINJA) {
q_ptr->prep(lookup_kind(ItemKindType::LITE, SV_LITE_TORCH));
q_ptr->number = (ITEM_NUMBER)rand_range(3, 7);
q_ptr->xtra4 = rand_range(3, 7) * 500;
add_outfit(player_ptr, q_ptr);
}
- if ((player_ptr->pclass == CLASS_RANGER) || (player_ptr->pclass == CLASS_CAVALRY)) {
+ if ((player_ptr->pclass == PlayerClassType::RANGER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
q_ptr->prep(lookup_kind(ItemKindType::ARROW, SV_AMMO_NORMAL));
q_ptr->number = (byte)rand_range(15, 20);
add_outfit(player_ptr, q_ptr);
}
- if (player_ptr->pclass == CLASS_RANGER) {
+ if (player_ptr->pclass == PlayerClassType::RANGER) {
q_ptr->prep(lookup_kind(ItemKindType::BOW, SV_SHORT_BOW));
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass == CLASS_ARCHER) {
+ } else if (player_ptr->pclass == PlayerClassType::ARCHER) {
q_ptr->prep(lookup_kind(ItemKindType::ARROW, SV_AMMO_NORMAL));
q_ptr->number = (ITEM_NUMBER)rand_range(15, 20);
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass == CLASS_HIGH_MAGE || player_ptr->pclass == CLASS_ELEMENTALIST) {
+ } else if (player_ptr->pclass == PlayerClassType::HIGH_MAGE || player_ptr->pclass == PlayerClassType::ELEMENTALIST) {
q_ptr->prep(lookup_kind(ItemKindType::WAND, SV_WAND_MAGIC_MISSILE));
q_ptr->number = 1;
q_ptr->pval = (PARAMETER_VALUE)rand_range(25, 30);
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass == CLASS_SORCERER) {
+ } else if (player_ptr->pclass == PlayerClassType::SORCERER) {
for (auto book_tval = enum2i(ItemKindType::LIFE_BOOK); book_tval <= enum2i(ItemKindType::LIFE_BOOK) + MAX_MAGIC - 1; book_tval++) {
q_ptr->prep(lookup_kind(i2enum<ItemKindType>(book_tval), 0));
q_ptr->number = 1;
add_outfit(player_ptr, q_ptr);
}
- } else if (player_ptr->pclass == CLASS_TOURIST) {
+ } else if (player_ptr->pclass == PlayerClassType::TOURIST) {
if (player_ptr->ppersonality != PERSONALITY_SEXY) {
q_ptr->prep(lookup_kind(ItemKindType::SHOT, SV_AMMO_LIGHT));
q_ptr->number = rand_range(15, 20);
q_ptr->number = rand_range(2, 4);
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass == CLASS_NINJA) {
+ } else if (player_ptr->pclass == PlayerClassType::NINJA) {
q_ptr->prep(lookup_kind(ItemKindType::SPIKE, 0));
q_ptr->number = rand_range(15, 20);
add_outfit(player_ptr, q_ptr);
- } else if (player_ptr->pclass == CLASS_SNIPER) {
+ } else if (player_ptr->pclass == PlayerClassType::SNIPER) {
q_ptr->prep(lookup_kind(ItemKindType::BOLT, SV_AMMO_NORMAL));
q_ptr->number = rand_range(15, 20);
add_outfit(player_ptr, q_ptr);
// @todo 本来read-onlyであるべきプリセットテーブルを書き換えている. 良くないパターン.
// 「状況によって特別に持たせたいアイテム」は別途定義すべき.
- if (player_ptr->pclass != CLASS_SORCERER) {
+ if (player_ptr->pclass != PlayerClassType::SORCERER) {
+ auto short_pclass = enum2i(player_ptr->pclass);
if (player_ptr->ppersonality == PERSONALITY_SEXY) {
- player_init[player_ptr->pclass][2] = std::make_tuple(ItemKindType::HAFTED, SV_WHIP);
+ player_init[short_pclass][2] = std::make_tuple(ItemKindType::HAFTED, SV_WHIP);
} else if (player_ptr->prace == PlayerRaceType::MERFOLK) {
- player_init[player_ptr->pclass][2] = std::make_tuple(ItemKindType::POLEARM, SV_TRIDENT);
+ player_init[short_pclass][2] = std::make_tuple(ItemKindType::POLEARM, SV_TRIDENT);
}
}
for (auto i = 0; i < 3; i++) {
- auto &[tv, sv] = player_init[player_ptr->pclass][i];
+ auto &[tv, sv] = player_init[enum2i(player_ptr->pclass)][i];
if ((player_ptr->prace == PlayerRaceType::ANDROID) && ((tv == ItemKindType::SOFT_ARMOR) || (tv == ItemKindType::HARD_ARMOR)))
continue;
q_ptr = &forge;
q_ptr->prep(lookup_kind(tv, sv));
- if ((tv == ItemKindType::SWORD || tv == ItemKindType::HAFTED)
- && (player_ptr->pclass == CLASS_ROGUE && player_ptr->realm1 == REALM_DEATH)) /* Only assassins get a poisoned weapon */
- q_ptr->name2 = EGO_BRAND_POIS;
+ /* Only assassins get a poisoned weapon */
+ if (((tv == ItemKindType::SWORD) || (tv == ItemKindType::HAFTED)) && ((player_ptr->pclass == PlayerClassType::ROGUE) && (player_ptr->realm1 == REALM_DEATH))) {
+ q_ptr->name2 = EGO_BRAND_POIS;
+ }
+
add_outfit(player_ptr, q_ptr);
}
sp_ptr = &sex_info[player_ptr->psex];
rp_ptr = &race_info[enum2i(player_ptr->prace)];
- cp_ptr = &class_info[player_ptr->pclass];
- mp_ptr = &m_info[player_ptr->pclass];
+ auto short_pclass = enum2i(player_ptr->pclass);
+ cp_ptr = &class_info[short_pclass];
+ mp_ptr = &m_info[short_pclass];
ap_ptr = &personality_info[player_ptr->ppersonality];
get_extra(player_ptr, false);
birther_ptr->pclass = player_ptr->pclass;
birther_ptr->ppersonality = player_ptr->ppersonality;
- if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
birther_ptr->realm1 = player_ptr->element;
else
birther_ptr->realm1 = player_ptr->realm1;
player_ptr->pclass = previous_char.pclass;
player_ptr->ppersonality = previous_char.ppersonality;
- if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
player_ptr->element = previous_char.realm1;
else
player_ptr->realm1 = previous_char.realm1;
chg_virtue(player_ptr, V_HONOUR, -1);
chg_virtue(player_ptr, V_JUSTICE, -1);
chg_virtue(player_ptr, V_COMPASSION, -1);
- } else if (player_ptr->pclass != CLASS_BERSERKER) {
+ } else if (player_ptr->pclass != PlayerClassType::BERSERKER) {
if (get_check(_("本当に攻撃しますか？", "Really hit it? "))) {
chg_virtue(player_ptr, V_INDIVIDUALISM, 1);
chg_virtue(player_ptr, V_HONOUR, -1);
}
if (can_attack_with_main_hand(player_ptr) && can_attack_with_sub_hand(player_ptr)) {
- if ((player_ptr->skill_exp[SKILL_TWO_WEAPON] < s_info[player_ptr->pclass].s_max[SKILL_TWO_WEAPON])
+ if ((player_ptr->skill_exp[SKILL_TWO_WEAPON] < s_info[enum2i(player_ptr->pclass)].s_max[SKILL_TWO_WEAPON])
&& ((player_ptr->skill_exp[SKILL_TWO_WEAPON] - 1000) / 200 < r_ptr->level)) {
if (player_ptr->skill_exp[SKILL_TWO_WEAPON] < WEAPON_EXP_BEGINNER)
player_ptr->skill_exp[SKILL_TWO_WEAPON] += 80;
if (player_ptr->riding) {
int cur = player_ptr->skill_exp[SKILL_RIDING];
- int max = s_info[player_ptr->pclass].s_max[SKILL_RIDING];
+ int max = s_info[enum2i(player_ptr->pclass)].s_max[SKILL_RIDING];
if (cur < max) {
DEPTH ridinglevel = r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level;
static void switch_mind_kind(player_type *player_ptr, cm_type *cm_ptr)
{
switch (player_ptr->pclass) {
- case CLASS_MINDCRAFTER:
+ case PlayerClassType::MINDCRAFTER:
cm_ptr->use_mind = mind_kind_type::MINDCRAFTER;
cm_ptr->mind_explanation = _("精神", "skill");
break;
- case CLASS_FORCETRAINER:
+ case PlayerClassType::FORCETRAINER:
cm_ptr->use_mind = mind_kind_type::KI;
cm_ptr->mind_explanation = _("気", "skill");
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
cm_ptr->use_mind = mind_kind_type::BERSERKER;
cm_ptr->mind_explanation = _("怒り", "skill");
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
cm_ptr->use_mind = mind_kind_type::MIRROR_MASTER;
cm_ptr->mind_explanation = _("鏡魔法", "skill");
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
cm_ptr->use_mind = mind_kind_type::NINJUTSU;
cm_ptr->mind_explanation = _("精神", "skill");
break;
static void mind_turn_passing(player_type *player_ptr, cm_type *cm_ptr)
{
PlayerEnergy energy(player_ptr);
- if (cm_ptr->on_mirror && (player_ptr->pclass == CLASS_MIRROR_MASTER)) {
+ if (cm_ptr->on_mirror && (player_ptr->pclass == PlayerClassType::MIRROR_MASTER)) {
if (cm_ptr->n == 3 || cm_ptr->n == 5 || cm_ptr->n == 7 || cm_ptr->n == 16) {
energy.set_player_turn_energy(50);
return;
static mind_kind_type decide_use_mind_browse(player_type *player_ptr)
{
switch (player_ptr->pclass) {
- case CLASS_MINDCRAFTER:
+ case PlayerClassType::MINDCRAFTER:
return mind_kind_type::MINDCRAFTER;
- case CLASS_FORCETRAINER:
+ case PlayerClassType::FORCETRAINER:
return mind_kind_type::KI;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
return mind_kind_type::BERSERKER;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
return mind_kind_type::NINJUTSU;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
return mind_kind_type::MIRROR_MASTER;
default:
- return (mind_kind_type)0; // 実質CLASS_MINDCRAFTERと同じ.
+ return (mind_kind_type)0; // 実質PlayerClassType::MINDCRAFTERと同じ.
}
}
void do_cmd_rest(player_type *player_ptr)
{
set_action(player_ptr, ACTION_NONE);
- if ((player_ptr->pclass == CLASS_BARD) && ((get_singing_song_effect(player_ptr) != 0) || (get_interrupting_song_effect(player_ptr) != 0)))
+ if ((player_ptr->pclass == PlayerClassType::BARD) && ((get_singing_song_effect(player_ptr) != 0) || (get_interrupting_song_effect(player_ptr) != 0)))
stop_singing(player_ptr);
SpellHex spell_hex(player_ptr);
powers[num++] = PET_TWO_HANDS;
} else {
switch (player_ptr->pclass) {
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
- case CLASS_BERSERKER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::BERSERKER:
if (empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB)) {
if (player_ptr->pet_extra_flags & PF_TWO_HANDS) {
power_desc[num] = _("片手で格闘する", "use one hand to control the pet you are riding");
}
exe_fire(player_ptr, item, j_ptr, snipe_type);
- if (!player_ptr->is_fired || player_ptr->pclass != CLASS_SNIPER)
+ if (!player_ptr->is_fired || player_ptr->pclass != PlayerClassType::SNIPER)
return;
if (snipe_type == SP_AWAY) {
return false;
}
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
return true;
- if (player_ptr->pclass == CLASS_RED_MAGE)
+ if (player_ptr->pclass == PlayerClassType::RED_MAGE)
return true;
/* Spell is learned */
/* No "okay" spells */
if (!okay)
return false;
- if (((use_realm) != player_ptr->realm1) && ((use_realm) != player_ptr->realm2) && (player_ptr->pclass != CLASS_SORCERER)
- && (player_ptr->pclass != CLASS_RED_MAGE))
+ if (((use_realm) != player_ptr->realm1) && ((use_realm) != player_ptr->realm2) && (player_ptr->pclass != PlayerClassType::SORCERER)
+ && (player_ptr->pclass != PlayerClassType::RED_MAGE))
return false;
- if (((player_ptr->pclass == CLASS_SORCERER) || (player_ptr->pclass == CLASS_RED_MAGE)) && !is_magic(use_realm))
+ if (((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE)) && !is_magic(use_realm))
return false;
- if ((player_ptr->pclass == CLASS_RED_MAGE) && ((use_realm) != REALM_ARCANE) && (sval > 1))
+ if ((player_ptr->pclass == PlayerClassType::RED_MAGE) && ((use_realm) != REALM_ARCANE) && (sval > 1))
return false;
/* Assume cancelled */
concptr q, s;
/* Warriors are illiterate */
- if (!(player_ptr->realm1 || player_ptr->realm2) && (player_ptr->pclass != CLASS_SORCERER) && (player_ptr->pclass != CLASS_RED_MAGE)) {
+ if (!(player_ptr->realm1 || player_ptr->realm2) && (player_ptr->pclass != PlayerClassType::SORCERER) && (player_ptr->pclass != PlayerClassType::RED_MAGE)) {
msg_print(_("本を読むことができない！", "You cannot read books!"));
return;
}
PlayerClass(player_ptr).break_samurai_stance({ SamuraiStance::MUSOU });
- if (player_ptr->pclass == CLASS_FORCETRAINER) {
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
if (player_has_no_spellbooks(player_ptr)) {
confirm_use_force(player_ptr, true);
return;
q = _("どの本を読みますか? ", "Browse which book? ");
s = _("読める本がない。", "You have no books that you can read.");
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | (player_ptr->pclass == CLASS_FORCETRAINER ? USE_FORCE : 0)), item_tester);
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | (player_ptr->pclass == PlayerClassType::FORCETRAINER ? USE_FORCE : 0)), item_tester);
if (!o_ptr) {
if (item == INVEN_FORCE) /* the_force */
bool over_exerted = false;
/* Require spell ability */
- if (!player_ptr->realm1 && (player_ptr->pclass != CLASS_SORCERER) && (player_ptr->pclass != CLASS_RED_MAGE)) {
+ if (!player_ptr->realm1 && (player_ptr->pclass != PlayerClassType::SORCERER) && (player_ptr->pclass != PlayerClassType::RED_MAGE)) {
msg_print(_("呪文を唱えられない！", "You cannot cast spells!"));
return false;
}
if (player_ptr->blind || no_lite(player_ptr)) {
- if (player_ptr->pclass == CLASS_FORCETRAINER)
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER)
confirm_use_force(player_ptr, false);
else {
msg_print(_("目が見えない！", "You cannot see!"));
}
}
- if (player_ptr->pclass == CLASS_FORCETRAINER) {
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
if (player_has_no_spellbooks(player_ptr)) {
confirm_use_force(player_ptr, false);
return true; //!< 錬気キャンセル時の処理がない
auto item_tester = get_castable_spellbook_tester(player_ptr);
- o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | (player_ptr->pclass == CLASS_FORCETRAINER ? USE_FORCE : 0)), item_tester);
+ o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR | (player_ptr->pclass == PlayerClassType::FORCETRAINER ? USE_FORCE : 0)), item_tester);
if (!o_ptr) {
if (item == INVEN_FORCE) /* the_force */
{
/* Access the item's sval */
sval = o_ptr->sval;
- if ((player_ptr->pclass != CLASS_SORCERER) && (player_ptr->pclass != CLASS_RED_MAGE) && (o_ptr->tval == get_realm2_book(player_ptr)))
+ if ((player_ptr->pclass != PlayerClassType::SORCERER) && (player_ptr->pclass != PlayerClassType::RED_MAGE) && (o_ptr->tval == get_realm2_book(player_ptr)))
increment = 32;
/* Track the object kind */
object_kind_track(player_ptr, o_ptr->k_idx);
handle_stuff(player_ptr);
- if ((player_ptr->pclass == CLASS_SORCERER) || (player_ptr->pclass == CLASS_RED_MAGE))
+ if ((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE))
realm = tval2realm(o_ptr->tval);
else if (increment)
realm = player_ptr->realm2;
chg_virtue(player_ptr, V_CHANCE, 1);
/* A spell was cast */
- if (!(increment ? (player_ptr->spell_worked2 & (1UL << spell)) : (player_ptr->spell_worked1 & (1UL << spell))) && (player_ptr->pclass != CLASS_SORCERER)
- && (player_ptr->pclass != CLASS_RED_MAGE)) {
+ if (!(increment ? (player_ptr->spell_worked2 & (1UL << spell)) : (player_ptr->spell_worked1 & (1UL << spell))) && (player_ptr->pclass != PlayerClassType::SORCERER)
+ && (player_ptr->pclass != PlayerClassType::RED_MAGE)) {
int e = s_ptr->sexp;
/* The spell worked */
sprintf(file_name, _("playrecord-%s.txt", "playrec-%s.txt"), savefile_base);
path_build(buf, sizeof(buf), ANGBAND_DIR_USER, file_name);
- if (player_ptr->pclass == CLASS_WARRIOR || player_ptr->pclass == CLASS_MONK || player_ptr->pclass == CLASS_SAMURAI
- || player_ptr->pclass == CLASS_BERSERKER)
+ if (player_ptr->pclass == PlayerClassType::WARRIOR || player_ptr->pclass == PlayerClassType::MONK || player_ptr->pclass == PlayerClassType::SAMURAI
+ || player_ptr->pclass == PlayerClassType::BERSERKER)
strcpy(tmp, subtitle[randint0(MAX_SUBTITLE - 1)]);
else if (PlayerClass(player_ptr).is_wizard())
strcpy(tmp, subtitle[randint0(MAX_SUBTITLE - 1) + 1]);
#include "cmd-io/cmd-menu-content-table.h"
#include "player-info/class-types.h"
+#include "util/enum-converter.h"
#include "util/int-char-converter.h"
+/*
+ * @todo 遅くともv2.2.1の頃には職業enumとboolとintが混じっているゴミ配列であった
+ * jouken_naiyou (フィールド名もゴミ)が複数目的に利用されているようである
+ * 後で何とかする
+ */
special_menu_content special_menu_info[MAX_SPECIAL_MENU_NUM] = {
- { _("超能力/特殊能力", "MindCraft/Special"), 0, 0, MENU_CLASS, CLASS_MINDCRAFTER },
- { _("ものまね/特殊能力", "Imitation/Special"), 0, 0, MENU_CLASS, CLASS_IMITATOR },
- { _("歌/特殊能力", "Song/Special"), 0, 0, MENU_CLASS, CLASS_BARD },
- { _("必殺技/特殊能力", "Technique/Special"), 0, 0, MENU_CLASS, CLASS_SAMURAI },
- { _("練気術/魔法/特殊能力", "Mind/Magic/Special"), 0, 0, MENU_CLASS, CLASS_FORCETRAINER },
- { _("技/特殊能力", "BrutalPower/Special"), 0, 0, MENU_CLASS, CLASS_BERSERKER },
- { _("技術/特殊能力", "Technique/Special"), 0, 0, MENU_CLASS, CLASS_SMITH },
- { _("鏡魔法/特殊能力", "MirrorMagic/Special"), 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER },
- { _("忍術/特殊能力", "Ninjutsu/Special"), 0, 0, MENU_CLASS, CLASS_NINJA },
- { _("広域マップ(<)", "Enter global map(<)"), 2, 6, MENU_WILD, false },
- { _("通常マップ(>)", "Enter local map(>)"), 2, 7, MENU_WILD, true },
- { "", 0, 0, 0, 0 },
+ { _("超能力/特殊能力", "MindCraft/Special"), 0, 0, MENU_CLASS, PlayerClassType::MINDCRAFTER },
+ { _("ものまね/特殊能力", "Imitation/Special"), 0, 0, MENU_CLASS, PlayerClassType::IMITATOR },
+ { _("歌/特殊能力", "Song/Special"), 0, 0, MENU_CLASS, PlayerClassType::BARD },
+ { _("必殺技/特殊能力", "Technique/Special"), 0, 0, MENU_CLASS, PlayerClassType::SAMURAI },
+ { _("練気術/魔法/特殊能力", "Mind/Magic/Special"), 0, 0, MENU_CLASS, PlayerClassType::FORCETRAINER },
+ { _("技/特殊能力", "BrutalPower/Special"), 0, 0, MENU_CLASS, PlayerClassType::BERSERKER },
+ { _("技術/特殊能力", "Technique/Special"), 0, 0, MENU_CLASS, PlayerClassType::SMITH },
+ { _("鏡魔法/特殊能力", "MirrorMagic/Special"), 0, 0, MENU_CLASS, PlayerClassType::MIRROR_MASTER },
+ { _("忍術/特殊能力", "Ninjutsu/Special"), 0, 0, MENU_CLASS, PlayerClassType::NINJA },
+ { _("広域マップ(<)", "Enter global map(<)"), 2, 6, MENU_WILD, i2enum<PlayerClassType>(0) },
+ { _("通常マップ(>)", "Enter local map(>)"), 2, 7, MENU_WILD, i2enum<PlayerClassType>(1) },
+ { "", 0, 0, 0, i2enum<PlayerClassType>(0) },
};
menu_content menu_info[MAX_COMMAND_MENU_NUM][MAX_COMMAND_PER_SCREEN] = {
#include "system/angband.h"
-typedef struct menu_content {
+struct menu_content {
concptr name;
byte cmd;
bool fin;
-} menu_content;
+};
-typedef struct special_menu_content {
+enum class PlayerClassType : short;
+struct special_menu_content {
concptr name;
byte window;
byte number;
byte jouken;
- byte jouken_naiyou;
-} special_menu_content;
+ PlayerClassType jouken_naiyou;
+};
#define MAX_COMMAND_PER_SCREEN 10
#define MAX_COMMAND_MENU_NUM 10
if (player_ptr->prace == PlayerRaceType::ANDROID)
return false;
- if ((player_ptr->pclass == CLASS_WARRIOR) || (player_ptr->pclass == CLASS_BERSERKER))
+ if ((player_ptr->pclass == PlayerClassType::WARRIOR) || (player_ptr->pclass == PlayerClassType::BERSERKER))
return true;
- if (player_ptr->pclass != CLASS_PALADIN)
+ if (player_ptr->pclass != PlayerClassType::PALADIN)
return false;
bool gain_expr = false;
PlayerEnergy energy(player_ptr);
if (o_ptr->is_cursed()) {
- if (o_ptr->curse_flags.has(TRC::PERMA_CURSE) || (player_ptr->pclass != CLASS_BERSERKER)) {
+ if (o_ptr->curse_flags.has(TRC::PERMA_CURSE) || (player_ptr->pclass != PlayerClassType::BERSERKER)) {
msg_print(_("ふーむ、どうやら呪われているようだ。", "Hmmm, it seems to be cursed."));
return;
}
torch_lost_fuel(ote.q_ptr);
}
- ote.corruption_possibility = ote.hit_body ? breakage_chance(this->player_ptr, ote.q_ptr, this->player_ptr->pclass == CLASS_ARCHER, 0) : 0;
+ ote.corruption_possibility = ote.hit_body ? breakage_chance(this->player_ptr, ote.q_ptr, this->player_ptr->pclass == PlayerClassType::ARCHER, 0) : 0;
ote.display_figurine_throw();
ote.display_potion_throw();
ote.check_boomerang_throw();
n *= 2;
success_hit = one_in_(n);
- } else if ((player_ptr->pclass == CLASS_NINJA) && ((pa_ptr->backstab || pa_ptr->surprise_attack) && !(r_ptr->flagsr & RFR_RES_ALL)))
+ } else if ((player_ptr->pclass == PlayerClassType::NINJA) && ((pa_ptr->backstab || pa_ptr->surprise_attack) && !(r_ptr->flagsr & RFR_RES_ALL)))
success_hit = true;
else
success_hit = test_hit_norm(player_ptr, chance, r_ptr->ac, pa_ptr->m_ptr->ml);
int i = (weight + (meichuu * 3 + plus * 5) + player_ptr->skill_thn);
/* Chance */
- auto pow = (player_ptr->pclass == CLASS_NINJA) ? 4444 : 5000;
+ auto pow = (player_ptr->pclass == PlayerClassType::NINJA) ? 4444 : 5000;
if (impact)
pow /= 2;
return;
}
- bool is_ninja_hit = (player_ptr->pclass == CLASS_NINJA) && has_melee_weapon(player_ptr, INVEN_MAIN_HAND + pa_ptr->hand)
+ bool is_ninja_hit = (player_ptr->pclass == PlayerClassType::NINJA) && has_melee_weapon(player_ptr, INVEN_MAIN_HAND + pa_ptr->hand)
&& !player_ptr->is_icky_wield[pa_ptr->hand] && ((player_ptr->cur_lite <= 0) || one_in_(7));
if (is_ninja_hit)
ninja_critical(player_ptr, pa_ptr);
if ((r_ptr->level + 10) > player_ptr->lev) {
int now_exp = player_ptr->weapon_exp[0][j_ptr->sval];
- if (now_exp < s_info[player_ptr->pclass].w_max[0][j_ptr->sval]) {
+ if (now_exp < s_info[enum2i(player_ptr->pclass)].w_max[0][j_ptr->sval]) {
SUB_EXP amount = 0;
if (now_exp < WEAPON_EXP_BEGINNER)
amount = 80;
}
if (player_ptr->riding) {
- if ((player_ptr->skill_exp[SKILL_RIDING] < s_info[player_ptr->pclass].s_max[SKILL_RIDING])
+ if ((player_ptr->skill_exp[SKILL_RIDING] < s_info[enum2i(player_ptr->pclass)].s_max[SKILL_RIDING])
&& ((player_ptr->skill_exp[SKILL_RIDING] - (RIDING_EXP_BEGINNER * 2)) / 200
< r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level)
&& one_in_(2)) {
}
/* Chance of breakage (during attacks) */
- j = (hit_body ? breakage_chance(player_ptr, q_ptr, player_ptr->pclass == CLASS_ARCHER, snipe_type) : 0);
+ j = (hit_body ? breakage_chance(player_ptr, q_ptr, player_ptr->pclass == PlayerClassType::ARCHER, snipe_type) : 0);
if (stick_to) {
MONSTER_IDX m_idx = player_ptr->current_floor_ptr->grid_array[y][x].m_idx;
/* Snipers can shot more critically with crossbows */
i += ((i * sniper_concent) / 5);
- if ((player_ptr->pclass == CLASS_SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT))
+ if ((player_ptr->pclass == PlayerClassType::SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT))
i *= 2;
/* Good bow makes more critical */
/* Snipers can shot more critically with crossbows */
i += ((i * sniper_concent) / 5);
- if ((player_ptr->pclass == CLASS_SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT))
+ if ((player_ptr->pclass == PlayerClassType::SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT))
i *= 2;
/* Good bow makes more critical */
num += calc_weight_expect_dam(dam, weight);
}
- int pow = (player_ptr->pclass == CLASS_NINJA) ? 4444 : 5000;
+ int pow = (player_ptr->pclass == PlayerClassType::NINJA) ? 4444 : 5000;
if (impact)
pow /= 2;
mult = mult_brand(player_ptr, mult, flgs, m_ptr);
- if (player_ptr->pclass == CLASS_SAMURAI) {
+ if (player_ptr->pclass == PlayerClassType::SAMURAI) {
mult = mult_hissatsu(player_ptr, mult, flgs, m_ptr, mode);
}
- if ((player_ptr->pclass != CLASS_SAMURAI) && (flgs.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
+ if ((player_ptr->pclass != PlayerClassType::SAMURAI) && (flgs.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
player_ptr->csp -= (1 + (o_ptr->dd * o_ptr->ds / 5));
player_ptr->redraw |= (PR_MANA);
mult = mult * 3 / 2 + 20;
panel_row_min = floor_ptr->height;
panel_col_min = floor_ptr->width;
- if (player_ptr->pclass != CLASS_SORCERER) {
+ if (player_ptr->pclass != PlayerClassType::SORCERER) {
auto begin = enum2i(TV_WEAPON_BEGIN);
if (player_ptr->ppersonality == PERSONALITY_SEXY)
- s_info[player_ptr->pclass].w_max[enum2i(ItemKindType::HAFTED) - begin][SV_WHIP] = WEAPON_EXP_MASTER;
+ s_info[enum2i(player_ptr->pclass)].w_max[enum2i(ItemKindType::HAFTED) - begin][SV_WHIP] = WEAPON_EXP_MASTER;
if (player_ptr->prace == PlayerRaceType::MERFOLK) {
- s_info[player_ptr->pclass].w_max[enum2i(ItemKindType::POLEARM) - begin][SV_TRIDENT] = WEAPON_EXP_MASTER;
- s_info[player_ptr->pclass].w_max[enum2i(ItemKindType::POLEARM) - begin][SV_TRIFURCATE_SPEAR] = WEAPON_EXP_MASTER;
+ s_info[enum2i(player_ptr->pclass)].w_max[enum2i(ItemKindType::POLEARM) - begin][SV_TRIDENT] = WEAPON_EXP_MASTER;
+ s_info[enum2i(player_ptr->pclass)].w_max[enum2i(ItemKindType::POLEARM) - begin][SV_TRIFURCATE_SPEAR] = WEAPON_EXP_MASTER;
}
}
static void init_riding_pet(player_type *player_ptr, bool new_game)
{
- if (!new_game || ((player_ptr->pclass != CLASS_CAVALRY) && (player_ptr->pclass != CLASS_BEASTMASTER)))
+ if (!new_game || ((player_ptr->pclass != PlayerClassType::CAVALRY) && (player_ptr->pclass != PlayerClassType::BEASTMASTER)))
return;
- MONRACE_IDX pet_r_idx = ((player_ptr->pclass == CLASS_CAVALRY) ? MON_HORSE : MON_YASE_HORSE);
+ MONRACE_IDX pet_r_idx = ((player_ptr->pclass == PlayerClassType::CAVALRY) ? MON_HORSE : MON_YASE_HORSE);
monster_race *r_ptr = &r_info[pet_r_idx];
place_monster_aux(player_ptr, 0, player_ptr->y, player_ptr->x - 1, pet_r_idx, (PM_FORCE_PET | PM_NO_KAGE));
monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[hack_m_idx_ii];
if (player_ptr->lightspeed)
set_lightspeed(player_ptr, player_ptr->lightspeed - 1, true);
- if ((player_ptr->pclass == CLASS_FORCETRAINER) && get_current_ki(player_ptr)) {
+ if ((player_ptr->pclass == PlayerClassType::FORCETRAINER) && get_current_ki(player_ptr)) {
if (get_current_ki(player_ptr) < 40)
set_current_ki(player_ptr, true, 0);
else
}
}
- if (player_ptr->pclass == CLASS_IMITATOR) {
+ if (player_ptr->pclass == PlayerClassType::IMITATOR) {
auto mane_data = PlayerClass(player_ptr).get_specific_data<mane_data_type>();
if (static_cast<int>(mane_data->mane_list.size()) > (player_ptr->lev > 44 ? 3 : player_ptr->lev > 29 ? 2 : 1)) {
mane_data->mane_list.pop_front();
sprintf(the_score.sex, "%c", (current_player_ptr->psex ? 'm' : 'f'));
snprintf(buf, sizeof(buf), "%2d", MIN(enum2i(current_player_ptr->prace), MAX_RACES));
memcpy(the_score.p_r, buf, 3);
- snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->pclass, MAX_CLASS));
+ snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->pclass, PlayerClassType::MAX));
memcpy(the_score.p_c, buf, 3);
snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->ppersonality, MAX_PERSONALITIES));
memcpy(the_score.p_a, buf, 3);
sprintf(the_score.sex, "%c", (current_player_ptr->psex ? 'm' : 'f'));
snprintf(buf, sizeof(buf), "%2d", MIN(enum2i(current_player_ptr->prace), MAX_RACES));
memcpy(the_score.p_r, buf, 3);
- snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->pclass, MAX_CLASS));
+ snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->pclass, PlayerClassType::MAX));
memcpy(the_score.p_c, buf, 3);
snprintf(buf, sizeof(buf), "%2d", MIN(current_player_ptr->ppersonality, MAX_PERSONALITIES));
memcpy(the_score.p_a, buf, 3);
print_speed(player_ptr);
}
- if (player_ptr->pclass == CLASS_IMITATOR) {
+ if (player_ptr->pclass == PlayerClassType::IMITATOR) {
if (player_ptr->redraw & (PR_IMITATION)) {
player_ptr->redraw &= ~(PR_IMITATION);
print_imitation(player_ptr);
}
}
- if ((player_ptr->pclass == CLASS_BARD) && (get_singing_song_effect(player_ptr) > MUSIC_DETECT))
+ if ((player_ptr->pclass == PlayerClassType::BARD) && (get_singing_song_effect(player_ptr) > MUSIC_DETECT))
set_singing_song_effect(player_ptr, MUSIC_DETECT);
if (!player_ptr->playing || player_ptr->is_dead)
if (is_pet(m_ptr))
return hp * 4L;
- if ((player_ptr->pclass == CLASS_BEASTMASTER) && monster_living(m_ptr->r_idx))
+ if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) && monster_living(m_ptr->r_idx))
return hp * 3 / 10;
return hp * 3 / 20;
static void effect_monster_psi_drain_change_power(player_type *player_ptr, effect_monster_type *em_ptr)
{
int b = damroll(5, em_ptr->dam) / 4;
- concptr str = (player_ptr->pclass == CLASS_MINDCRAFTER) ? _("超能力パワー", "psychic energy") : _("魔力", "mana");
+ concptr str = (player_ptr->pclass == PlayerClassType::MINDCRAFTER) ? _("超能力パワー", "psychic energy") : _("魔力", "mana");
concptr msg = _("あなたは%sの苦痛を%sに変換した！", (em_ptr->seen ? "You convert %s's pain into %s!" : "You convert %ss pain into %s!"));
msg_format(msg, em_ptr->m_name, str);
flavor_ptr->bow_ptr = &player_ptr->inventory_list[INVEN_BOW];
if ((flavor_ptr->bow_ptr->k_idx != 0) && (flavor_ptr->o_ptr->tval == bow_tval_ammo(flavor_ptr->bow_ptr)))
describe_bow_power(player_ptr, flavor_ptr);
- else if ((player_ptr->pclass == CLASS_NINJA) && (flavor_ptr->o_ptr->tval == ItemKindType::SPIKE))
+ else if ((player_ptr->pclass == PlayerClassType::NINJA) && (flavor_ptr->o_ptr->tval == ItemKindType::SPIKE))
describe_spike_power(player_ptr, flavor_ptr);
}
player_ptr->floor_id = new_floor_id;
w_ptr->character_dungeon = true;
if (player_ptr->ppersonality == PERSONALITY_MUNCHKIN)
- wiz_lite(player_ptr, (bool)(player_ptr->pclass == CLASS_NINJA));
+ wiz_lite(player_ptr, (bool)(player_ptr->pclass == PlayerClassType::NINJA));
player_ptr->current_floor_ptr->generated_turn = w_ptr->game_turn;
player_ptr->feeling_turn = player_ptr->current_floor_ptr->generated_turn;
}
regenmana(player_ptr, upkeep_factor, regen_amount);
- if (player_ptr->pclass == CLASS_MAGIC_EATER) {
+ if (player_ptr->pclass == PlayerClassType::MAGIC_EATER) {
regenmagic(player_ptr, regen_amount);
}
return (PARSE_ERROR_TOO_FEW_ARGUMENTS);
}
case 'C': {
- int n;
- n = tokenize(s + 2, MAX_CLASS, zz, 0);
- for (int i = 0; i < MAX_CLASS; i++) {
- building[index].member_class.push_back(i2enum<PlayerClassType>((i < n) ? atoi(zz[i]) : 1));
+ auto pct_max = enum2i(PlayerClassType::MAX);
+ auto n = tokenize(s + 2, pct_max, zz, 0);
+ for (int i = 0; i < pct_max; i++) {
+ building[index].member_class.push_back((i < n) ? atoi(zz[i]) : 1);
}
break;
}
case 'R': {
- int n;
- n = tokenize(s + 2, MAX_RACES, zz, 0);
+ auto n = tokenize(s + 2, MAX_RACES, zz, 0);
for (int i = 0; i < MAX_RACES; i++) {
building[index].member_race[i] = (i < n) ? atoi(zz[i]) : 1;
}
void dump_aux_class_special(player_type *player_ptr, FILE *fff)
{
switch (player_ptr->pclass) {
- case CLASS_MAGIC_EATER: {
+ case PlayerClassType::MAGIC_EATER: {
dump_magic_eater(player_ptr, fff);
return;
}
- case CLASS_SMITH: {
+ case PlayerClassType::SMITH: {
dump_smith(player_ptr, fff);
return;
}
- case CLASS_BLUE_MAGE: {
+ case PlayerClassType::BLUE_MAGE: {
dump_blue_mage(player_ptr, fff);
return;
}
break;
}
case 'G': {
- if (player_ptr->pclass == CLASS_SORCERER || player_ptr->pclass == CLASS_RED_MAGE || player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::SORCERER || player_ptr->pclass == PlayerClassType::RED_MAGE || player_ptr->pclass == PlayerClassType::ELEMENTALIST)
msg_print(_("呪文を学習する必要はない！", "You don't have to learn spells!"));
- else if (player_ptr->pclass == CLASS_SAMURAI)
+ else if (player_ptr->pclass == PlayerClassType::SAMURAI)
do_cmd_gain_hissatsu(player_ptr);
- else if (player_ptr->pclass == CLASS_MAGIC_EATER)
+ else if (player_ptr->pclass == PlayerClassType::MAGIC_EATER)
import_magic_device(player_ptr);
else
do_cmd_study(player_ptr);
break;
}
case 'b': {
- if ((player_ptr->pclass == CLASS_MINDCRAFTER) || (player_ptr->pclass == CLASS_BERSERKER) || (player_ptr->pclass == CLASS_NINJA)
- || (player_ptr->pclass == CLASS_MIRROR_MASTER))
+ if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::BERSERKER) || (player_ptr->pclass == PlayerClassType::NINJA)
+ || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER))
do_cmd_mind_browse(player_ptr);
- else if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ else if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
do_cmd_element_browse(player_ptr);
- else if (player_ptr->pclass == CLASS_SMITH)
+ else if (player_ptr->pclass == PlayerClassType::SMITH)
do_cmd_kaji(player_ptr, true);
- else if (player_ptr->pclass == CLASS_MAGIC_EATER)
+ else if (player_ptr->pclass == PlayerClassType::MAGIC_EATER)
do_cmd_magic_eater(player_ptr, true, false);
- else if (player_ptr->pclass == CLASS_SNIPER)
+ else if (player_ptr->pclass == PlayerClassType::SNIPER)
do_cmd_snipe_browse(player_ptr);
else
do_cmd_browse(player_ptr);
break;
}
- if ((player_ptr->pclass == CLASS_WARRIOR) || (player_ptr->pclass == CLASS_ARCHER) || (player_ptr->pclass == CLASS_CAVALRY)) {
+ if ((player_ptr->pclass == PlayerClassType::WARRIOR) || (player_ptr->pclass == PlayerClassType::ARCHER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
msg_print(_("呪文を唱えられない！", "You cannot cast spells!"));
break;
}
- if (floor_ptr->dun_level && d_info[player_ptr->dungeon_idx].flags.has(DF::NO_MAGIC) && (player_ptr->pclass != CLASS_BERSERKER)
- && (player_ptr->pclass != CLASS_SMITH)) {
+ if (floor_ptr->dun_level && d_info[player_ptr->dungeon_idx].flags.has(DF::NO_MAGIC) && (player_ptr->pclass != PlayerClassType::BERSERKER)
+ && (player_ptr->pclass != PlayerClassType::SMITH)) {
msg_print(_("ダンジョンが魔法を吸収した！", "The dungeon absorbs all attempted magic!"));
msg_print(nullptr);
break;
}
- if (player_ptr->anti_magic && (player_ptr->pclass != CLASS_BERSERKER) && (player_ptr->pclass != CLASS_SMITH)) {
+ if (player_ptr->anti_magic && (player_ptr->pclass != PlayerClassType::BERSERKER) && (player_ptr->pclass != PlayerClassType::SMITH)) {
concptr which_power = _("魔法", "magic");
switch (player_ptr->pclass) {
- case CLASS_MINDCRAFTER:
+ case PlayerClassType::MINDCRAFTER:
which_power = _("超能力", "psionic powers");
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
which_power = _("ものまね", "imitation");
break;
- case CLASS_SAMURAI:
+ case PlayerClassType::SAMURAI:
which_power = _("必殺剣", "hissatsu");
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
which_power = _("鏡魔法", "mirror magic");
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
which_power = _("忍術", "ninjutsu");
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
which_power = _("元素魔法", "magic");
break;
default:
break;
}
- if (is_shero(player_ptr) && (player_ptr->pclass != CLASS_BERSERKER)) {
+ if (is_shero(player_ptr) && (player_ptr->pclass != PlayerClassType::BERSERKER)) {
msg_format(_("狂戦士化していて頭が回らない！", "You cannot think directly!"));
PlayerEnergy(player_ptr).reset_player_turn();
break;
}
- if ((player_ptr->pclass == CLASS_MINDCRAFTER) || (player_ptr->pclass == CLASS_BERSERKER) || (player_ptr->pclass == CLASS_NINJA)
- || (player_ptr->pclass == CLASS_MIRROR_MASTER))
+ if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::BERSERKER) || (player_ptr->pclass == PlayerClassType::NINJA)
+ || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER))
do_cmd_mind(player_ptr);
- else if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ else if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
do_cmd_element(player_ptr);
- else if (player_ptr->pclass == CLASS_IMITATOR)
+ else if (player_ptr->pclass == PlayerClassType::IMITATOR)
do_cmd_mane(player_ptr, false);
- else if (player_ptr->pclass == CLASS_MAGIC_EATER)
+ else if (player_ptr->pclass == PlayerClassType::MAGIC_EATER)
do_cmd_magic_eater(player_ptr, false, false);
- else if (player_ptr->pclass == CLASS_SAMURAI)
+ else if (player_ptr->pclass == PlayerClassType::SAMURAI)
do_cmd_hissatsu(player_ptr);
- else if (player_ptr->pclass == CLASS_BLUE_MAGE)
+ else if (player_ptr->pclass == PlayerClassType::BLUE_MAGE)
do_cmd_cast_learned(player_ptr);
- else if (player_ptr->pclass == CLASS_SMITH)
+ else if (player_ptr->pclass == PlayerClassType::SMITH)
do_cmd_kaji(player_ptr, false);
- else if (player_ptr->pclass == CLASS_SNIPER)
+ else if (player_ptr->pclass == PlayerClassType::SNIPER)
do_cmd_snipe(player_ptr);
else
(void)do_cmd_cast(player_ptr);
break;
case MENU_WILD:
if (!floor_ptr->dun_level && !floor_ptr->inside_arena && !floor_ptr->inside_quest) {
- if ((byte)player_ptr->wild_mode == special_menu_info[hoge].jouken_naiyou)
+ auto can_do_in_wilderness = enum2i(special_menu_info[hoge].jouken_naiyou) > 0;
+ if (player_ptr->wild_mode == can_do_in_wilderness) {
menu_name = special_menu_info[hoge].name;
+ }
}
break;
default:
sprintf(personality_desc, "%s ", ap_ptr->title);
#endif
- auto realm1_name = player_ptr->pclass == CLASS_ELEMENTALIST ? get_element_title(player_ptr->element) : realm_names[player_ptr->realm1];
+ auto realm1_name = player_ptr->pclass == PlayerClassType::ELEMENTALIST ? get_element_title(player_ptr->element) : realm_names[player_ptr->realm1];
buf_sprintf(score, "name: %s\n", player_ptr->name);
buf_sprintf(score, "version: %s\n", title);
buf_sprintf(score, "score: %d\n", calc_score(player_ptr));
continue;
SUB_EXP weapon_exp = player_ptr->weapon_exp[4 - i][num];
- SUB_EXP weapon_max = s_info[player_ptr->pclass].w_max[4 - i][num];
+ SUB_EXP weapon_max = s_info[enum2i(player_ptr->pclass)].w_max[4 - i][num];
strip_name(tmp, k_ref.idx);
fprintf(fff, "%-25s ", tmp);
if (show_actual_value)
for (int i = 0; i < SKILL_MAX; i++) {
SUB_EXP skill_exp = player_ptr->skill_exp[i];
- SUB_EXP skill_max = s_info[player_ptr->pclass].s_max[i];
+ SUB_EXP skill_max = s_info[enum2i(player_ptr->pclass)].s_max[i];
fprintf(fff, "%-20s ", skill_name[i]);
if (show_actual_value)
fprintf(fff, "%4d/%4d ", MIN(skill_exp, skill_max), skill_max);
t += strlen(t) + 1;
}
- shape_buffer(class_explanations[player_ptr->pclass].data(), 78, temp, sizeof(temp));
+ auto short_pclass = enum2i(player_ptr->pclass);
+ shape_buffer(class_explanations[short_pclass].data(), 78, temp, sizeof(temp));
fprintf(fff, "\n");
- fprintf(fff, _("職業: %s\n", "Class: %s\n"), class_info[player_ptr->pclass].title);
+ fprintf(fff, _("職業: %s\n", "Class: %s\n"), class_info[short_pclass].title);
t = temp;
for (int i = 0; i < 10; i++) {
size_t max_len = 75;
std::string s = "";
std::string l = "";
- for (int c = 0; c < MAX_CLASS; c++) {
+ for (int c = 0; c < enum2i(PlayerClassType::MAX); c++) {
if (w_ptr->sf_winner.has_not(i2enum<PlayerClassType>(c)))
continue;
void set_zangband_skill(player_type *player_ptr)
{
- if (player_ptr->pclass != CLASS_BEASTMASTER)
+ if (player_ptr->pclass != PlayerClassType::BEASTMASTER)
player_ptr->skill_exp[SKILL_RIDING] /= 2;
- player_ptr->skill_exp[SKILL_RIDING] = MIN(player_ptr->skill_exp[SKILL_RIDING], s_info[player_ptr->pclass].s_max[SKILL_RIDING]);
+ player_ptr->skill_exp[SKILL_RIDING] = MIN(player_ptr->skill_exp[SKILL_RIDING], s_info[enum2i(player_ptr->pclass)].s_max[SKILL_RIDING]);
}
void set_zangband_race(player_type *player_ptr)
void set_zangband_class(player_type *player_ptr)
{
- if (h_older_than(0, 2, 2) && (player_ptr->pclass == CLASS_BEASTMASTER) && !player_ptr->is_dead) {
+ if (h_older_than(0, 2, 2) && (player_ptr->pclass == PlayerClassType::BEASTMASTER) && !player_ptr->is_dead) {
player_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
roll_hitdice(player_ptr, SPOP_NONE);
}
- if (h_older_than(0, 3, 2) && (player_ptr->pclass == CLASS_ARCHER) && !player_ptr->is_dead) {
+ if (h_older_than(0, 3, 2) && (player_ptr->pclass == PlayerClassType::ARCHER) && !player_ptr->is_dead) {
player_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
roll_hitdice(player_ptr, SPOP_NONE);
}
- if (h_older_than(0, 2, 6) && (player_ptr->pclass == CLASS_SORCERER) && !player_ptr->is_dead) {
+ if (h_older_than(0, 2, 6) && (player_ptr->pclass == PlayerClassType::SORCERER) && !player_ptr->is_dead) {
player_ptr->hitdie = rp_ptr->r_mhp / 2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
roll_hitdice(player_ptr, SPOP_NONE);
}
- if (h_older_than(0, 4, 7) && (player_ptr->pclass == CLASS_BLUE_MAGE) && !player_ptr->is_dead) {
+ if (h_older_than(0, 4, 7) && (player_ptr->pclass == PlayerClassType::BLUE_MAGE) && !player_ptr->is_dead) {
player_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
roll_hitdice(player_ptr, SPOP_NONE);
}
if (load_hp_result != 0)
return load_hp_result;
+ auto short_pclass = enum2i(player_ptr->pclass);
sp_ptr = &sex_info[player_ptr->psex];
rp_ptr = &race_info[enum2i(player_ptr->prace)];
- cp_ptr = &class_info[player_ptr->pclass];
+ cp_ptr = &class_info[short_pclass];
ap_ptr = &personality_info[player_ptr->ppersonality];
set_zangband_class(player_ptr);
- mp_ptr = &m_info[player_ptr->pclass];
+ mp_ptr = &m_info[short_pclass];
load_spells(player_ptr);
- if (player_ptr->pclass == CLASS_MINDCRAFTER)
+ if (player_ptr->pclass == PlayerClassType::MINDCRAFTER)
player_ptr->add_spells = 0;
errr load_inventory_result = load_inventory(player_ptr);
*/
static bool can_takeover_savefile(const player_type *player_ptr)
{
- if (loading_savefile_version_is_older_than(8) && player_ptr->pclass == CLASS_SMITH) {
+ if (loading_savefile_version_is_older_than(8) && player_ptr->pclass == PlayerClassType::SMITH) {
return false;
}
byte tmp8u;
rd_byte(&tmp8u);
- if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
player_ptr->element = (int16_t)tmp8u;
else
player_ptr->realm1 = (int16_t)tmp8u;
for (int i = 0; i < 64; i++)
rd_s16b(&player_ptr->spell_exp[i]);
- if ((player_ptr->pclass == CLASS_SORCERER) && h_older_than(0, 4, 2))
+ if ((player_ptr->pclass == PlayerClassType::SORCERER) && h_older_than(0, 4, 2))
for (int i = 0; i < 64; i++)
player_ptr->spell_exp[i] = SPELL_EXP_MASTER;
void set_floor_types(player_type *player_ptr, lore_type *lore_ptr)
{
if (lore_ptr->ability_flags.has(RF_ABILITY::DARKNESS)) {
- if ((player_ptr->pclass != CLASS_NINJA) || (lore_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) || (lore_ptr->r_ptr->flags7 & RF7_DARK_MASK)) {
+ if ((player_ptr->pclass != PlayerClassType::NINJA) || (lore_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) || (lore_ptr->r_ptr->flags7 & RF7_DARK_MASK)) {
lore_ptr->vp[lore_ptr->vn] = _("暗闇", "create darkness");
lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
} else {
*/
errr init_s_info()
{
- init_header(&s_head, MAX_CLASS);
+ init_header(&s_head, enum2i(PlayerClassType::MAX));
return init_info("s_info", s_head, s_info, parse_s_info, nullptr);
}
*/
errr init_m_info()
{
- init_header(&m_head, MAX_CLASS);
+ init_header(&m_head, enum2i(PlayerClassType::MAX));
return init_info("m_info", m_head, m_info, parse_m_info, nullptr);
}
if (battle_metal_babble(player_ptr))
return;
- if (player_ptr->riding && (player_ptr->pclass != CLASS_BEASTMASTER) && (player_ptr->pclass != CLASS_CAVALRY)) {
+ if (player_ptr->riding && (player_ptr->pclass != PlayerClassType::BEASTMASTER) && (player_ptr->pclass != PlayerClassType::CAVALRY)) {
msg_print(_("ペットに乗ったままではアリーナへ入れさせてもらえなかった。", "You don't have permission to enter with pet."));
msg_print(nullptr);
return;
show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("切れ味:", "Vorpal:"), TERM_L_RED);
}
- if ((player_ptr->pclass != CLASS_SAMURAI) && flgs.has(TR_FORCE_WEAPON) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
+ if ((player_ptr->pclass != PlayerClassType::SAMURAI) && flgs.has(TR_FORCE_WEAPON) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
force = true;
mindam = calc_expect_dice(player_ptr, mindice, 1, 1, force, o_ptr->weight, o_ptr->to_h, player_ptr->to_h[0], dokubari, impact, vorpal_mult, vorpal_div);
building[i].action_restr[j] = 0;
}
- for (int j = 0; j < MAX_CLASS; j++)
- building[i].member_class[j] = CLASS_WARRIOR;
+ for (int j = 0; j < enum2i(PlayerClassType::MAX); j++)
+ building[i].member_class[j] = static_cast<short>(PlayerClassType::WARRIOR);
for (int j = 0; j < MAX_RACES; j++)
building[i].member_race[j] = static_cast<short>(PlayerRaceType::HUMAN);
*/
bool is_owner(player_type *player_ptr, building_type *bldg)
{
- if (bldg->member_class[player_ptr->pclass] == BUILDING_OWNER) {
+ if (bldg->member_class[enum2i(player_ptr->pclass)] == BUILDING_OWNER) {
return true;
}
*/
bool is_member(player_type *player_ptr, building_type *bldg)
{
- if (bldg->member_class[player_ptr->pclass]) {
+ if (static_cast<bool>(bldg->member_class[enum2i(player_ptr->pclass)])) {
return true;
}
return true;
}
- if (player_ptr->pclass != CLASS_SORCERER)
+ if (player_ptr->pclass != PlayerClassType::SORCERER)
return false;
for (int i = 0; i < MAX_MAGIC; i++) {
if (ms_ptr->ability_flags.has_not(RF_ABILITY::DARKNESS))
return;
- bool vs_ninja = (player_ptr->pclass == CLASS_NINJA) && !is_hostile(ms_ptr->t_ptr);
+ bool vs_ninja = (player_ptr->pclass == PlayerClassType::NINJA) && !is_hostile(ms_ptr->t_ptr);
bool can_use_lite_area = vs_ninja && !(ms_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) && !(ms_ptr->r_ptr->flags7 & RF7_DARK_MASK);
if ((ms_ptr->r_ptr->flags2 & RF2_STUPID) != 0)
return;
is_special_magic &= ms_ptr->maneable;
is_special_magic &= w_ptr->timewalk_m_idx == 0;
is_special_magic &= !player_ptr->blind;
- is_special_magic &= player_ptr->pclass == CLASS_IMITATOR;
+ is_special_magic &= player_ptr->pclass == PlayerClassType::IMITATOR;
is_special_magic &= ms_ptr->thrown_spell != RF_ABILITY::SPECIAL;
if (!is_special_magic)
return;
*/
bool has_element_resist(player_type *player_ptr, ElementRealm realm, PLAYER_LEVEL lev)
{
- if (player_ptr->pclass != CLASS_ELEMENTALIST)
+ if (player_ptr->pclass != PlayerClassType::ELEMENTALIST)
return false;
auto prealm = i2enum<ElementRealm>(player_ptr->element);
void MindPowerGetter::select_mind_description()
{
switch (this->player_ptr->pclass)
- case CLASS_MINDCRAFTER: {
+ case PlayerClassType::MINDCRAFTER: {
this->use_mind = mind_kind_type::MINDCRAFTER;
this->mind_description = _("超能力", "mindcraft");
break;
- case CLASS_FORCETRAINER:
+ case PlayerClassType::FORCETRAINER:
this->use_mind = mind_kind_type::KI;
this->mind_description = _("練気術", "Force");
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
this->use_mind = mind_kind_type::BERSERKER;
this->mind_description = _("技", "brutal power");
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
this->use_mind = mind_kind_type::MIRROR_MASTER;
this->mind_description = _("鏡魔法", "magic");
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
this->use_mind = mind_kind_type::NINJUTSU;
this->mind_description = _("忍術", "ninjutsu");
break;
for (int times = 0; times < max_blow_selection_times; times++) {
do {
pa_ptr->ma_ptr = &ma_blows[randint0(MAX_MA)];
- if ((player_ptr->pclass == CLASS_FORCETRAINER) && (pa_ptr->ma_ptr->min_level > 1))
+ if ((player_ptr->pclass == PlayerClassType::FORCETRAINER) && (pa_ptr->ma_ptr->min_level > 1))
min_level = pa_ptr->ma_ptr->min_level + 3;
else
min_level = pa_ptr->ma_ptr->min_level;
msg_print(_("攻撃を再選択しました。", "Attack re-selected."));
}
- if (player_ptr->pclass == CLASS_FORCETRAINER)
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER)
min_level = MAX(1, pa_ptr->ma_ptr->min_level - 3);
else
min_level = pa_ptr->ma_ptr->min_level;
if (PlayerClass(player_ptr).monk_stance_is(MonkStance::SUZAKU))
weight = 4;
- if ((player_ptr->pclass == CLASS_FORCETRAINER) && (get_current_ki(player_ptr) != 0)) {
+ if ((player_ptr->pclass == PlayerClassType::FORCETRAINER) && (get_current_ki(player_ptr) != 0)) {
weight += (get_current_ki(player_ptr) / 30);
if (weight > 20)
weight = 20;
}
auto cur = player_ptr->skill_exp[SKILL_SHIELD];
- auto max = s_info[player_ptr->pclass].s_max[SKILL_SHIELD];
+ auto max = s_info[enum2i(player_ptr->pclass)].s_max[SKILL_SHIELD];
if (cur >= max) {
return;
}
{
bool seen = (!player_ptr->blind && msa_ptr->m_ptr->ml);
bool can_imitate = player_has_los_bold(player_ptr, msa_ptr->m_ptr->fy, msa_ptr->m_ptr->fx);
- if (!seen || !can_imitate || (w_ptr->timewalk_m_idx != 0) || (player_ptr->pclass != CLASS_IMITATOR))
+ if (!seen || !can_imitate || (w_ptr->timewalk_m_idx != 0) || (player_ptr->pclass != PlayerClassType::IMITATOR))
return;
/* Not RF_ABILITY::SPECIAL */
GAME_TEXT t_name[MAX_NLEN];
monster_name(player_ptr, t_idx, t_name);
- if ((player_ptr->pclass == CLASS_NINJA) && !(r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) && !(r_ptr->flags7 & RF7_DARK_MASK))
+ if ((player_ptr->pclass == PlayerClassType::NINJA) && !(r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) && !(r_ptr->flags7 & RF7_DARK_MASK))
can_use_lite_area = true;
if (monster_to_monster && !is_hostile(t_ptr))
if (player_ptr->dustrobe)
return true;
- if (player_ptr->shero && (player_ptr->pclass != CLASS_BERSERKER))
+ if (player_ptr->shero && (player_ptr->pclass != PlayerClassType::BERSERKER))
return true;
if (player_ptr->mimic_form == MIMIC_DEMON_LORD)
return true;
}
- if (r_ptr->ability_flags.has_any_of({ RF_ABILITY::BR_POIS, RF_ABILITY::BR_NUKE }) && !((player_ptr->pclass == CLASS_NINJA) && (player_ptr->lev > 44))) {
+ if (r_ptr->ability_flags.has_any_of({ RF_ABILITY::BR_POIS, RF_ABILITY::BR_NUKE }) && !((player_ptr->pclass == PlayerClassType::NINJA) && (player_ptr->lev > 44))) {
if (player_ptr->oppose_pois || music_singing(player_ptr, MUSIC_RESIST))
return true;
if (msa_ptr->ability_flags.has_not(RF_ABILITY::DARKNESS))
return;
- bool can_use_lite_area = (player_ptr->pclass == CLASS_NINJA) && ((msa_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) == 0)
+ bool can_use_lite_area = (player_ptr->pclass == PlayerClassType::NINJA) && ((msa_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) == 0)
&& ((msa_ptr->r_ptr->flags7 & RF7_DARK_MASK) == 0);
if ((msa_ptr->r_ptr->flags2 & RF2_STUPID) != 0)
return;
}
- if ((player_ptr->pclass == CLASS_NINJA) && !can_use_lite_area)
+ if ((player_ptr->pclass == PlayerClassType::NINJA) && !can_use_lite_area)
msa_ptr->ability_flags.reset(RF_ABILITY::DARKNESS);
}
void switch_gain_mutation(player_type *player_ptr, glm_type *glm_ptr)
{
- switch (glm_ptr->choose_mut ? glm_ptr->choose_mut : (player_ptr->pclass == CLASS_BERSERKER ? 74 + randint1(119) : randint1(193))) {
+ switch (glm_ptr->choose_mut ? glm_ptr->choose_mut : (player_ptr->pclass == PlayerClassType::BERSERKER ? 74 + randint1(119) : randint1(193))) {
case 1:
case 2:
case 3:
break;
case 110:
case 111:
- if (player_ptr->pclass == CLASS_CHAOS_WARRIOR)
+ if (player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR)
break;
glm_ptr->muta_which = MUTA::CHAOS_GIFT;
*/
bool item_tester_learn_spell(player_type *player_ptr, const object_type *o_ptr)
{
- int32_t choices = realm_choices2[player_ptr->pclass];
- if (player_ptr->pclass == CLASS_PRIEST) {
+ int32_t choices = realm_choices2[enum2i(player_ptr->pclass)];
+ if (player_ptr->pclass == PlayerClassType::PRIEST) {
if (is_good_realm(player_ptr->realm1)) {
choices &= ~(CH_DEATH | CH_DAEMON);
} else {
if ((o_ptr->tval < ItemKindType::LIFE_BOOK) || (o_ptr->tval > ItemKindType::HEX_BOOK))
return false;
- if ((o_ptr->tval == ItemKindType::MUSIC_BOOK) && (player_ptr->pclass == CLASS_BARD))
+ if ((o_ptr->tval == ItemKindType::MUSIC_BOOK) && (player_ptr->pclass == PlayerClassType::BARD))
return true;
else if (!is_magic(tval2realm(o_ptr->tval)))
return false;
}
/* Favorite weapons are varied depend on the class */
+ auto short_pclass = enum2i(player_ptr->pclass);
switch (player_ptr->pclass) {
- case CLASS_PRIEST: {
+ case PlayerClassType::PRIEST: {
auto flgs = object_flags_known(o_ptr);
if (flgs.has_not(TR_BLESSED) && !(o_ptr->tval == ItemKindType::HAFTED))
break;
}
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
/* Icky to wield? */
- if (!(s_info[player_ptr->pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval]))
+ if (!(s_info[short_pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval]))
return false;
break;
- case CLASS_BEASTMASTER:
- case CLASS_CAVALRY: {
+ case PlayerClassType::BEASTMASTER:
+ case PlayerClassType::CAVALRY: {
auto flgs = object_flags_known(o_ptr);
/* Is it known to be suitable to using while riding? */
break;
}
- case CLASS_SORCERER:
- if (s_info[player_ptr->pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval] < WEAPON_EXP_MASTER)
+ case PlayerClassType::SORCERER:
+ if (s_info[short_pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval] < WEAPON_EXP_MASTER)
return false;
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
/* Icky to wield? */
- if (s_info[player_ptr->pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval] <= WEAPON_EXP_BEGINNER)
+ if (s_info[short_pclass].w_max[o_ptr->tval - TV_WEAPON_BEGIN][o_ptr->sval] <= WEAPON_EXP_BEGINNER)
return false;
break;
bool ObjectQuaffEntity::booze()
{
bool ident = false;
- if (this->player_ptr->pclass != CLASS_MONK)
+ if (this->player_ptr->pclass != PlayerClassType::MONK)
chg_virtue(this->player_ptr, V_HARMONY, -1);
else if (!has_resist_conf(this->player_ptr))
this->player_ptr->special_attack |= ATTACK_SUIKEN;
ident = true;
}
- if (one_in_(13) && (this->player_ptr->pclass != CLASS_MONK)) {
+ if (one_in_(13) && (this->player_ptr->pclass != PlayerClassType::MONK)) {
ident = true;
if (one_in_(3))
lose_all_info(this->player_ptr);
break;
}
case SV_SCROLL_SPELL: {
- if ((this->player_ptr->pclass == CLASS_WARRIOR) || (this->player_ptr->pclass == CLASS_IMITATOR) || (this->player_ptr->pclass == CLASS_MINDCRAFTER)
- || (this->player_ptr->pclass == CLASS_SORCERER) || (this->player_ptr->pclass == CLASS_ARCHER) || (this->player_ptr->pclass == CLASS_MAGIC_EATER)
- || (this->player_ptr->pclass == CLASS_RED_MAGE) || (this->player_ptr->pclass == CLASS_SAMURAI) || (this->player_ptr->pclass == CLASS_BLUE_MAGE)
- || (this->player_ptr->pclass == CLASS_CAVALRY) || (this->player_ptr->pclass == CLASS_BERSERKER) || (this->player_ptr->pclass == CLASS_SMITH)
- || (this->player_ptr->pclass == CLASS_MIRROR_MASTER) || (this->player_ptr->pclass == CLASS_NINJA) || (this->player_ptr->pclass == CLASS_SNIPER))
+ if ((this->player_ptr->pclass == PlayerClassType::WARRIOR) || (this->player_ptr->pclass == PlayerClassType::IMITATOR) || (this->player_ptr->pclass == PlayerClassType::MINDCRAFTER)
+ || (this->player_ptr->pclass == PlayerClassType::SORCERER) || (this->player_ptr->pclass == PlayerClassType::ARCHER) || (this->player_ptr->pclass == PlayerClassType::MAGIC_EATER)
+ || (this->player_ptr->pclass == PlayerClassType::RED_MAGE) || (this->player_ptr->pclass == PlayerClassType::SAMURAI) || (this->player_ptr->pclass == PlayerClassType::BLUE_MAGE)
+ || (this->player_ptr->pclass == PlayerClassType::CAVALRY) || (this->player_ptr->pclass == PlayerClassType::BERSERKER) || (this->player_ptr->pclass == PlayerClassType::SMITH)
+ || (this->player_ptr->pclass == PlayerClassType::MIRROR_MASTER) || (this->player_ptr->pclass == PlayerClassType::NINJA) || (this->player_ptr->pclass == PlayerClassType::SNIPER))
break;
this->player_ptr->add_spells++;
return false;
}
- if (this->player_ptr->pclass == CLASS_BERSERKER) {
+ if (this->player_ptr->pclass == PlayerClassType::BERSERKER) {
msg_print(_("巻物なんて読めない。", "You cannot read."));
return false;
}
{
PlayerEnergy energy(this->player_ptr);
energy.set_player_turn_energy(100);
- if ((this->player_ptr->pclass == CLASS_ROGUE) || (this->player_ptr->pclass == CLASS_NINJA)) {
+ if ((this->player_ptr->pclass == PlayerClassType::ROGUE) || (this->player_ptr->pclass == PlayerClassType::NINJA)) {
energy.sub_player_turn_energy(this->player_ptr->lev);
}
this->y = this->player_ptr->y;
this->x = this->player_ptr->x;
handle_stuff(this->player_ptr);
- this->shuriken = (this->player_ptr->pclass == CLASS_NINJA)
+ this->shuriken = (this->player_ptr->pclass == PlayerClassType::NINJA)
&& ((this->q_ptr->tval == ItemKindType::SPIKE) || ((this->obj_flags.has(TR_THROW)) && (this->q_ptr->tval == ItemKindType::SWORD)));
}
chance = USE_DEVICE;
}
- if ((chance < USE_DEVICE) || (randint1(chance) < USE_DEVICE) || (this->player_ptr->pclass == CLASS_BERSERKER)) {
+ if ((chance < USE_DEVICE) || (randint1(chance) < USE_DEVICE) || (this->player_ptr->pclass == PlayerClassType::BERSERKER)) {
if (flush_failure) {
flush();
}
}
bool success;
- if (this->player_ptr->pclass == CLASS_BERSERKER) {
+ if (this->player_ptr->pclass == PlayerClassType::BERSERKER) {
success = false;
} else if (chance > fail) {
success = randint0(chance * 2) >= fail;
chance = USE_DEVICE;
}
- if ((chance < USE_DEVICE) || (randint1(chance) < USE_DEVICE) || (this->player_ptr->pclass == CLASS_BERSERKER)) {
+ if ((chance < USE_DEVICE) || (randint1(chance) < USE_DEVICE) || (this->player_ptr->pclass == PlayerClassType::BERSERKER)) {
if (flush_failure) {
flush();
}
{
if (book_tval < ItemKindType::LIFE_BOOK)
return false;
- if (player_ptr->pclass == CLASS_SORCERER) {
+ if (player_ptr->pclass == PlayerClassType::SORCERER) {
return is_magic(tval2realm(book_tval));
- } else if (player_ptr->pclass == CLASS_RED_MAGE) {
+ } else if (player_ptr->pclass == PlayerClassType::RED_MAGE) {
if (is_magic(tval2realm(book_tval)))
return ((book_tval == ItemKindType::ARCANE_BOOK) || (book_sval < 2));
}
return;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_ARCHER:
- case CLASS_SAMURAI:
- case CLASS_CAVALRY: {
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::SAMURAI:
+ case PlayerClassType::CAVALRY: {
if (0 != randint0(9000L / (plev * plev + 40)))
return;
heavy = true;
break;
}
- case CLASS_SMITH: {
+ case PlayerClassType::SMITH: {
if (0 != randint0(6000L / (plev * plev + 50)))
return;
heavy = true;
break;
}
- case CLASS_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_SORCERER:
- case CLASS_MAGIC_EATER:
- case CLASS_ELEMENTALIST: {
+ case PlayerClassType::MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::SORCERER:
+ case PlayerClassType::MAGIC_EATER:
+ case PlayerClassType::ELEMENTALIST: {
if (0 != randint0(240000L / (plev + 5)))
return;
break;
}
- case CLASS_PRIEST:
- case CLASS_BARD: {
+ case PlayerClassType::PRIEST:
+ case PlayerClassType::BARD: {
if (0 != randint0(10000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_ROGUE:
- case CLASS_NINJA: {
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::NINJA: {
if (0 != randint0(20000L / (plev * plev + 40)))
return;
heavy = true;
break;
}
- case CLASS_RANGER: {
+ case PlayerClassType::RANGER: {
if (0 != randint0(95000L / (plev * plev + 40)))
return;
heavy = true;
break;
}
- case CLASS_PALADIN:
- case CLASS_SNIPER: {
+ case PlayerClassType::PALADIN:
+ case PlayerClassType::SNIPER: {
if (0 != randint0(77777L / (plev * plev + 40)))
return;
heavy = true;
break;
}
- case CLASS_WARRIOR_MAGE:
- case CLASS_RED_MAGE: {
+ case PlayerClassType::WARRIOR_MAGE:
+ case PlayerClassType::RED_MAGE: {
if (0 != randint0(75000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_MINDCRAFTER:
- case CLASS_IMITATOR:
- case CLASS_BLUE_MAGE:
- case CLASS_MIRROR_MASTER: {
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::IMITATOR:
+ case PlayerClassType::BLUE_MAGE:
+ case PlayerClassType::MIRROR_MASTER: {
if (0 != randint0(55000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_CHAOS_WARRIOR: {
+ case PlayerClassType::CHAOS_WARRIOR: {
if (0 != randint0(80000L / (plev * plev + 40)))
return;
heavy = true;
break;
}
- case CLASS_MONK:
- case CLASS_FORCETRAINER: {
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER: {
if (0 != randint0(20000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_TOURIST: {
+ case PlayerClassType::TOURIST: {
if (0 != randint0(20000L / ((plev + 50) * (plev + 50))))
return;
heavy = true;
break;
}
- case CLASS_BEASTMASTER: {
+ case PlayerClassType::BEASTMASTER: {
if (0 != randint0(65000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_BERSERKER: {
+ case PlayerClassType::BERSERKER: {
heavy = true;
break;
}
- case MAX_CLASS:
+ case PlayerClassType::MAX:
break;
}
return;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_ARCHER:
- case CLASS_SAMURAI:
- case CLASS_CAVALRY:
- case CLASS_BERSERKER:
- case CLASS_SNIPER: {
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::SAMURAI:
+ case PlayerClassType::CAVALRY:
+ case PlayerClassType::BERSERKER:
+ case PlayerClassType::SNIPER: {
return;
}
- case CLASS_SMITH:
- case CLASS_PALADIN:
- case CLASS_CHAOS_WARRIOR:
- case CLASS_IMITATOR:
- case CLASS_BEASTMASTER:
- case CLASS_NINJA: {
+ case PlayerClassType::SMITH:
+ case PlayerClassType::PALADIN:
+ case PlayerClassType::CHAOS_WARRIOR:
+ case PlayerClassType::IMITATOR:
+ case PlayerClassType::BEASTMASTER:
+ case PlayerClassType::NINJA: {
if (0 != randint0(240000L / (plev + 5)))
return;
break;
}
- case CLASS_RANGER:
- case CLASS_WARRIOR_MAGE:
- case CLASS_RED_MAGE:
- case CLASS_MONK: {
+ case PlayerClassType::RANGER:
+ case PlayerClassType::WARRIOR_MAGE:
+ case PlayerClassType::RED_MAGE:
+ case PlayerClassType::MONK: {
if (0 != randint0(95000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_PRIEST:
- case CLASS_BARD:
- case CLASS_ROGUE:
- case CLASS_FORCETRAINER:
- case CLASS_MINDCRAFTER: {
+ case PlayerClassType::PRIEST:
+ case PlayerClassType::BARD:
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::MINDCRAFTER: {
if (0 != randint0(20000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_SORCERER:
- case CLASS_MAGIC_EATER:
- case CLASS_MIRROR_MASTER:
- case CLASS_BLUE_MAGE:
- case CLASS_ELEMENTALIST: {
+ case PlayerClassType::MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::SORCERER:
+ case PlayerClassType::MAGIC_EATER:
+ case PlayerClassType::MIRROR_MASTER:
+ case PlayerClassType::BLUE_MAGE:
+ case PlayerClassType::ELEMENTALIST: {
if (0 != randint0(9000L / (plev * plev + 40)))
return;
break;
}
- case CLASS_TOURIST: {
+ case PlayerClassType::TOURIST: {
if (0 != randint0(20000L / ((plev + 50) * (plev + 50))))
return;
break;
}
- case MAX_CLASS:
+ case PlayerClassType::MAX:
break;
}
return true;
int cur = player_ptr->skill_exp[SKILL_RIDING];
- int max = s_info[player_ptr->pclass].s_max[SKILL_RIDING];
+ int max = s_info[enum2i(player_ptr->pclass)].s_max[SKILL_RIDING];
int ridinglevel = r_ptr->level;
int fall_off_level = r_ptr->level;
if (randint0(dam / 2 + fall_off_level * 2) >= cur / 30 + 10)
return true;
- if ((((player_ptr->pclass == CLASS_BEASTMASTER) || (player_ptr->pclass == CLASS_CAVALRY)) && !player_ptr->riding_ryoute)
+ if ((((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) && !player_ptr->riding_ryoute)
|| !one_in_(player_ptr->lev * (player_ptr->riding_ryoute ? 2 : 3) + 30)) {
return false;
}
continue;
}
- if (player_ptr->pclass != CLASS_CAVALRY) {
+ if (player_ptr->pclass != PlayerClassType::CAVALRY) {
total_friend_levels += (r_ptr->level + 5) * 10;
continue;
}
static void attack_classify(player_type *player_ptr, player_attack_type *pa_ptr)
{
switch (player_ptr->pclass) {
- case CLASS_ROGUE:
- case CLASS_NINJA:
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::NINJA:
process_surprise_attack(player_ptr, pa_ptr);
return;
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
- case CLASS_BERSERKER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::BERSERKER:
if ((empty_hands(player_ptr, true) & EMPTY_HAND_MAIN) && !player_ptr->riding)
pa_ptr->monk_attack = true;
return;
static void get_bare_knuckle_exp(player_type *player_ptr, player_attack_type *pa_ptr)
{
monster_race *r_ptr = &r_info[pa_ptr->m_ptr->r_idx];
- if ((r_ptr->level + 10) <= player_ptr->lev || (player_ptr->skill_exp[SKILL_MARTIAL_ARTS] >= s_info[player_ptr->pclass].s_max[SKILL_MARTIAL_ARTS]))
+ if ((r_ptr->level + 10) <= player_ptr->lev || (player_ptr->skill_exp[SKILL_MARTIAL_ARTS] >= s_info[enum2i(player_ptr->pclass)].s_max[SKILL_MARTIAL_ARTS]))
return;
if (player_ptr->skill_exp[SKILL_MARTIAL_ARTS] < WEAPON_EXP_BEGINNER)
int tval = player_ptr->inventory_list[INVEN_MAIN_HAND + pa_ptr->hand].tval - TV_WEAPON_BEGIN;
OBJECT_SUBTYPE_VALUE sval = player_ptr->inventory_list[INVEN_MAIN_HAND + pa_ptr->hand].sval;
int now_exp = player_ptr->weapon_exp[tval][sval];
- if (now_exp >= s_info[player_ptr->pclass].w_max[tval][sval])
+ if (now_exp >= s_info[enum2i(player_ptr->pclass)].w_max[tval][sval])
return;
SUB_EXP amount = 0;
return false;
*(pa_ptr->mdeath) = true;
- if ((player_ptr->pclass == CLASS_BERSERKER) && player_ptr->energy_use) {
+ if ((player_ptr->pclass == PlayerClassType::BERSERKER) && player_ptr->energy_use) {
PlayerEnergy energy(player_ptr);
if (can_attack_with_main_hand(player_ptr) && can_attack_with_sub_hand(player_ptr)) {
ENERGY energy_use;
mineuchi(player_ptr, pa_ptr);
pa_ptr->attack_damage = mon_damage_mod(player_ptr, pa_ptr->m_ptr, pa_ptr->attack_damage,
- (bool)(((o_ptr->tval == ItemKindType::POLEARM) && (o_ptr->sval == SV_DEATH_SCYTHE)) || ((player_ptr->pclass == CLASS_BERSERKER) && one_in_(2))));
+ ((o_ptr->tval == ItemKindType::POLEARM) && (o_ptr->sval == SV_DEATH_SCYTHE)) || ((player_ptr->pclass == PlayerClassType::BERSERKER) && one_in_(2)));
critical_attack(player_ptr, pa_ptr);
msg_format_wizard(player_ptr, CHEAT_MONSTER, _("%dのダメージを与えた。(残りHP %d/%d(%d))", "You do %d damage. (left HP %d/%d(%d))"),
pa_ptr->attack_damage, pa_ptr->m_ptr->hp - pa_ptr->attack_damage, pa_ptr->m_ptr->maxhp, pa_ptr->m_ptr->max_maxhp);
const auto plev = this->player_ptr->lev;
switch (this->player_ptr->pclass) {
- case CLASS_WARRIOR: {
+ case PlayerClassType::WARRIOR: {
if (plev > 29)
flags.set(TR_RES_FEAR);
if (plev > 44)
break;
}
- case CLASS_SAMURAI: {
+ case PlayerClassType::SAMURAI: {
if (plev > 29)
flags.set(TR_RES_FEAR);
break;
}
- case CLASS_PALADIN: {
+ case PlayerClassType::PALADIN: {
if (plev > 39)
flags.set(TR_RES_FEAR);
break;
}
- case CLASS_CHAOS_WARRIOR: {
+ case PlayerClassType::CHAOS_WARRIOR: {
if (plev > 29)
flags.set(TR_RES_CHAOS);
if (plev > 39)
break;
}
- case CLASS_MONK:
- case CLASS_FORCETRAINER: {
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER: {
if ((plev > 9) && !heavy_armor(this->player_ptr))
flags.set(TR_SPEED);
if ((plev > 24) && !heavy_armor(this->player_ptr))
break;
}
- case CLASS_NINJA: {
+ case PlayerClassType::NINJA: {
if (heavy_armor(this->player_ptr)) {
flags.set(TR_SPEED);
} else {
break;
}
- case CLASS_MINDCRAFTER: {
+ case PlayerClassType::MINDCRAFTER: {
if (plev > 9)
flags.set(TR_RES_FEAR);
if (plev > 19)
break;
}
- case CLASS_BARD: {
+ case PlayerClassType::BARD: {
flags.set(TR_RES_SOUND);
break;
}
- case CLASS_BERSERKER: {
+ case PlayerClassType::BERSERKER: {
flags.set(TR_SUST_STR);
flags.set(TR_SUST_DEX);
flags.set(TR_SUST_CON);
break;
}
- case CLASS_MIRROR_MASTER: {
+ case PlayerClassType::MIRROR_MASTER: {
if (plev > 39)
flags.set(TR_REFLECT);
break;
}
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
if (has_element_resist(this->player_ptr, ElementRealm::FIRE, 1))
flags.set(TR_RES_FIRE);
if (has_element_resist(this->player_ptr, ElementRealm::FIRE, 30))
bool PlayerClass::can_resist_stun() const
{
- return (this->player_ptr->pclass == CLASS_BERSERKER) && (this->player_ptr->lev > 34);
+ return (this->player_ptr->pclass == PlayerClassType::BERSERKER) && (this->player_ptr->lev > 34);
}
bool PlayerClass::is_wizard() const
{
- auto is_wizard = this->player_ptr->pclass == CLASS_MAGE;
- is_wizard |= this->player_ptr->pclass == CLASS_HIGH_MAGE;
- is_wizard |= this->player_ptr->pclass == CLASS_SORCERER;
- is_wizard |= this->player_ptr->pclass == CLASS_MAGIC_EATER;
- is_wizard |= this->player_ptr->pclass == CLASS_BLUE_MAGE;
- is_wizard |= this->player_ptr->pclass == CLASS_ELEMENTALIST;
+ auto is_wizard = this->player_ptr->pclass == PlayerClassType::MAGE;
+ is_wizard |= this->player_ptr->pclass == PlayerClassType::HIGH_MAGE;
+ is_wizard |= this->player_ptr->pclass == PlayerClassType::SORCERER;
+ is_wizard |= this->player_ptr->pclass == PlayerClassType::MAGIC_EATER;
+ is_wizard |= this->player_ptr->pclass == PlayerClassType::BLUE_MAGE;
+ is_wizard |= this->player_ptr->pclass == PlayerClassType::ELEMENTALIST;
return is_wizard;
}
bool PlayerClass::lose_balance()
{
- if (this->player_ptr->pclass != CLASS_SAMURAI) {
+ if (this->player_ptr->pclass != PlayerClassType::SAMURAI) {
return false;
}
void PlayerClass::init_specific_data()
{
switch (this->player_ptr->pclass) {
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
this->player_ptr->class_specific_data = std::make_shared<smith_data_type>();
break;
- case CLASS_FORCETRAINER:
+ case PlayerClassType::FORCETRAINER:
this->player_ptr->class_specific_data = std::make_shared<force_trainer_data_type>();
break;
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
this->player_ptr->class_specific_data = std::make_shared<bluemage_data_type>();
break;
- case CLASS_MAGIC_EATER:
+ case PlayerClassType::MAGIC_EATER:
this->player_ptr->class_specific_data = std::make_shared<magic_eater_data_type>();
break;
- case CLASS_BARD:
+ case PlayerClassType::BARD:
this->player_ptr->class_specific_data = std::make_shared<bard_data_type>();
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
this->player_ptr->class_specific_data = std::make_shared<mane_data_type>();
break;
- case CLASS_SNIPER:
+ case PlayerClassType::SNIPER:
this->player_ptr->class_specific_data = std::make_shared<sniper_data_type>();
break;
- case CLASS_SAMURAI:
+ case PlayerClassType::SAMURAI:
this->player_ptr->class_specific_data = std::make_shared<samurai_data_type>();
break;
- case CLASS_MONK:
+ case PlayerClassType::MONK:
this->player_ptr->class_specific_data = std::make_shared<monk_data_type>();
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
this->player_ptr->class_specific_data = std::make_shared<ninja_data_type>();
break;
- case CLASS_HIGH_MAGE:
+ case PlayerClassType::HIGH_MAGE:
if (this->player_ptr->realm1 == REALM_HEX) {
this->player_ptr->class_specific_data = std::make_shared<spell_hex_data_type>();
} else {
void set_class_ability_info(player_type *player_ptr, self_info_type *self_ptr)
{
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
+ case PlayerClassType::WARRIOR:
if (player_ptr->lev > 39)
self_ptr->info[self_ptr->line++]
= _("あなたはランダムな方向に対して数回攻撃することができる。(75 HP)", "You can attack some random directions simultaneously (cost 75).");
break;
- case CLASS_HIGH_MAGE:
+ case PlayerClassType::HIGH_MAGE:
if (player_ptr->realm1 == REALM_HEX)
break;
/* Fall through */
- case CLASS_MAGE:
- case CLASS_SORCERER:
+ case PlayerClassType::MAGE:
+ case PlayerClassType::SORCERER:
if (player_ptr->lev > 24)
self_ptr->info[self_ptr->line++] = _("あなたはアイテムの魔力を吸収することができる。(1 MP)", "You can absorb charges from an item (cost 1).");
break;
- case CLASS_PRIEST:
+ case PlayerClassType::PRIEST:
if (is_good_realm(player_ptr->realm1)) {
if (player_ptr->lev > 34)
self_ptr->info[self_ptr->line++] = _("あなたは武器を祝福することができる。(70 MP)", "You can bless a weapon (cost 70).");
= _("あなたは周りのすべてのモンスターを攻撃することができる。(40 MP)", "You can damage all monsters in sight (cost 40).");
break;
- case CLASS_ROGUE:
+ case PlayerClassType::ROGUE:
if (player_ptr->lev > 7)
self_ptr->info[self_ptr->line++]
= _("あなたは攻撃して即座に逃げることができる。(12 MP)", "You can hit a monster and teleport away simultaneously (cost 12).");
break;
- case CLASS_RANGER:
+ case PlayerClassType::RANGER:
if (player_ptr->lev > 14)
self_ptr->info[self_ptr->line++] = _("あなたは怪物を調査することができる。(20 MP)", "You can probe monsters (cost 20).");
break;
- case CLASS_PALADIN:
+ case PlayerClassType::PALADIN:
if (is_good_realm(player_ptr->realm1)) {
if (player_ptr->lev > 29) {
self_ptr->info[self_ptr->line++] = _("あなたは聖なる槍を放つことができる。(30 MP)", "You can fire a holy spear (cost 30).");
= _("あなたは生命力を減少させる槍を放つことができる。(30 MP)", "You can fire a spear which drains vitality (cost 30).");
break;
- case CLASS_WARRIOR_MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
if (player_ptr->lev > 24) {
self_ptr->info[self_ptr->line++] = _("あなたはＨＰをＭＰに変換することができる。(消費なし)", "You can convert HP to SP (cost 0).");
self_ptr->info[self_ptr->line++] = _("あなたはＭＰをＨＰに変換することができる。(消費なし)", "You can convert SP to HP (cost 0).");
}
break;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
if (player_ptr->lev > 39) {
self_ptr->info[self_ptr->line++]
= _("あなたは周囲に怪物を惑わす光を発生させることができる。(50 MP)", "You can radiate light which confuses nearby monsters (cost 50).");
}
break;
- case CLASS_MONK:
+ case PlayerClassType::MONK:
if (player_ptr->lev > 24)
self_ptr->info[self_ptr->line++] = _("あなたは構えることができる。(消費なし)", "You can assume a special stance (cost 0).");
= _("あなたは通常の2倍の攻撃を行うことができる。(30 MP)", "You can perform two attacks at the same time (cost 30).");
break;
- case CLASS_MINDCRAFTER:
- case CLASS_FORCETRAINER:
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::ELEMENTALIST:
if (player_ptr->lev > 14)
self_ptr->info[self_ptr->line++]
= _("あなたは精神を集中してＭＰを回復させることができる。(消費なし)", "You can concentrate to regenerate your mana (cost 0).");
break;
- case CLASS_TOURIST:
+ case PlayerClassType::TOURIST:
self_ptr->info[self_ptr->line++] = _("あなたは写真を撮影することができる。(消費なし)", "You can take a photograph (cost 0).");
if (player_ptr->lev > 24)
self_ptr->info[self_ptr->line++] = _("あなたはアイテムを完全に鑑定することができる。(20 MP)", "You can *identify* items (cost 20).");
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
if (player_ptr->lev > 29)
self_ptr->info[self_ptr->line++] = _("あなたは怪物の特殊攻撃をダメージ2倍でまねることができる。(100 MP)",
"You can imitate monster's special attacks with double damage (cost 100).");
break;
- case CLASS_BEASTMASTER:
+ case PlayerClassType::BEASTMASTER:
self_ptr->info[self_ptr->line++]
= _("あなたは1体の生命のあるモンスターを支配することができる。((レベル+3)/4 MP)", "You can dominate a monster (cost (level+3)/4).");
"You can dominate living monsters in sight (cost (level+20)/2).");
break;
- case CLASS_MAGIC_EATER:
+ case PlayerClassType::MAGIC_EATER:
self_ptr->info[self_ptr->line++]
= _("あなたは杖/魔法棒/ロッドの魔力を自分のものにすることができる。(消費なし)", "You can absorb a staff, wand or rod itself (cost 0).");
"You can powerfully activate a staff, wand or rod (cost 10+(level-10)/2).");
break;
- case CLASS_RED_MAGE:
+ case PlayerClassType::RED_MAGE:
if (player_ptr->lev > 47)
self_ptr->info[self_ptr->line++] = _("あなたは1ターンに2回魔法を唱えることができる。(20 MP)", "You can cast two spells simultaneously (cost 20).");
break;
- case CLASS_SAMURAI:
+ case PlayerClassType::SAMURAI:
self_ptr->info[self_ptr->line++]
= _("あなたは精神を集中して気合いを溜めることができる。(消費なし)", "You can concentrate to regenerate your mana (cost 0).");
self_ptr->info[self_ptr->line++] = _("あなたは特殊な型で構えることができる。(消費なし)", "You can assume a special stance (cost 0).");
break;
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
self_ptr->info[self_ptr->line++]
= _("あなたは相手に使われた魔法を学ぶことができる。(消費なし)", "You can study spells which your enemy casts on you (cost 0).");
break;
- case CLASS_CAVALRY:
+ case PlayerClassType::CAVALRY:
if (player_ptr->lev > 9)
self_ptr->info[self_ptr->line++] = _("あなたはモンスターに乗って無理矢理ペットにすることができる。(消費なし)",
"You can ride on a hostile monster to forcibly turn it into a pet (cost 0).");
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
if (player_ptr->lev > 9)
self_ptr->info[self_ptr->line++]
= _("あなたは街とダンジョンの間を行き来することができる。(10 HP)", "You can travel between town and the depths (cost 10).");
break;
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
if (player_ptr->lev > 4)
self_ptr->info[self_ptr->line++] = _("あなたは武器や防具を鑑定することができる。(15 HP)", "You can identify weapons or armours (cost 15).");
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
self_ptr->info[self_ptr->line++] = _("あなたは鏡を作り出すことができる。(2 MP)", "You can create a Mirror (cost 2).");
self_ptr->info[self_ptr->line++] = _("あなたは鏡を割ることができる。(消費なし)", "You can break distant Mirrors (cost 0).");
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
if (player_ptr->lev > 19)
self_ptr->info[self_ptr->line++] = _("あなたは素早く移動することができる。(消費なし)", "You can walk extremely fast (cost 0).");
break;
- case CLASS_ARCHER:
- case CLASS_BARD:
- case CLASS_SNIPER:
- case MAX_CLASS:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::BARD:
+ case PlayerClassType::SNIPER:
+ case PlayerClassType::MAX:
break;
}
}
#pragma once
-enum PlayerClassType {
- CLASS_WARRIOR = 0,
- CLASS_MAGE = 1,
- CLASS_PRIEST = 2,
- CLASS_ROGUE = 3,
- CLASS_RANGER = 4,
- CLASS_PALADIN = 5,
- CLASS_WARRIOR_MAGE = 6,
- CLASS_CHAOS_WARRIOR = 7,
- CLASS_MONK = 8,
- CLASS_MINDCRAFTER = 9,
- CLASS_HIGH_MAGE = 10,
- CLASS_TOURIST = 11,
- CLASS_IMITATOR = 12,
- CLASS_BEASTMASTER = 13,
- CLASS_SORCERER = 14,
- CLASS_ARCHER = 15,
- CLASS_MAGIC_EATER = 16,
- CLASS_BARD = 17,
- CLASS_RED_MAGE = 18,
- CLASS_SAMURAI = 19,
- CLASS_FORCETRAINER = 20,
- CLASS_BLUE_MAGE = 21,
- CLASS_CAVALRY = 22,
- CLASS_BERSERKER = 23,
- CLASS_SMITH = 24,
- CLASS_MIRROR_MASTER = 25,
- CLASS_NINJA = 26,
- CLASS_SNIPER = 27,
- CLASS_ELEMENTALIST = 28,
- MAX_CLASS = 29, /*!< 職業の最大定義数 Maximum number of player "class" types (see "table.c", etc) */
+enum class PlayerClassType : short {
+ WARRIOR = 0,
+ MAGE = 1,
+ PRIEST = 2,
+ ROGUE = 3,
+ RANGER = 4,
+ PALADIN = 5,
+ WARRIOR_MAGE = 6,
+ CHAOS_WARRIOR = 7,
+ MONK = 8,
+ MINDCRAFTER = 9,
+ HIGH_MAGE = 10,
+ TOURIST = 11,
+ IMITATOR = 12,
+ BEASTMASTER = 13,
+ SORCERER = 14,
+ ARCHER = 15,
+ MAGIC_EATER = 16,
+ BARD = 17,
+ RED_MAGE = 18,
+ SAMURAI = 19,
+ FORCETRAINER = 20,
+ BLUE_MAGE = 21,
+ CAVALRY = 22,
+ BERSERKER = 23,
+ SMITH = 24,
+ MIRROR_MASTER = 25,
+ NINJA = 26,
+ SNIPER = 27,
+ ELEMENTALIST = 28,
+ MAX,
};
*/
bool heavy_armor(player_type *player_ptr)
{
- if ((player_ptr->pclass != CLASS_MONK) && (player_ptr->pclass != CLASS_FORCETRAINER) && (player_ptr->pclass != CLASS_NINJA))
+ if ((player_ptr->pclass != PlayerClassType::MONK) && (player_ptr->pclass != PlayerClassType::FORCETRAINER) && (player_ptr->pclass != PlayerClassType::NINJA))
return false;
WEIGHT monk_arm_wgt = 0;
{ TR_RES_NETHER },
{ TR_SEE_INVIS },
{ TR_HOLD_EXP },
- { TR_LITE_1, 1, CLASS_NINJA, true },
+ { TR_LITE_1, 1, PlayerClassType::NINJA, true },
{ TR_SPEED },
},
},
*/
int16_t PlayerBasicStatistics::class_value()
{
- const player_class_info *c_ptr = &class_info[this->player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(this->player_ptr->pclass)];
return c_ptr->c_adj[this->ability_type];
}
{
SPEED result = 0;
- if (this->player_ptr->pclass == CLASS_NINJA) {
+ if (this->player_ptr->pclass == PlayerClassType::NINJA) {
if (heavy_armor(this->player_ptr)) {
result -= (this->player_ptr->lev) / 10;
} else if ((!this->player_ptr->inventory_list[INVEN_MAIN_HAND].k_idx || can_attack_with_main_hand(this->player_ptr))
}
}
- if ((this->player_ptr->pclass == CLASS_MONK || this->player_ptr->pclass == CLASS_FORCETRAINER) && !(heavy_armor(this->player_ptr))) {
+ if ((this->player_ptr->pclass == PlayerClassType::MONK || this->player_ptr->pclass == PlayerClassType::FORCETRAINER) && !(heavy_armor(this->player_ptr))) {
if (!(PlayerRace(this->player_ptr).equals(PlayerRaceType::KLACKON) || PlayerRace(this->player_ptr).equals(PlayerRaceType::SPRITE)
|| (this->player_ptr->ppersonality == PERSONALITY_MUNCHKIN)))
result += (this->player_ptr->lev) / 10;
}
- if (this->player_ptr->pclass == CLASS_BERSERKER) {
+ if (this->player_ptr->pclass == PlayerClassType::BERSERKER) {
result += 2;
if (this->player_ptr->lev > 29)
result++;
*/
int16_t PlayerStealth::class_base_value()
{
- const player_class_info *c_ptr = &class_info[this->player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(this->player_ptr->pclass)];
return c_ptr->c_stl + (c_ptr->x_stl * this->player_ptr->lev / 10);
}
{
ACTION_SKILL_POWER result = 0;
- if (this->player_ptr->pclass == CLASS_NINJA) {
+ if (this->player_ptr->pclass == PlayerClassType::NINJA) {
if (heavy_armor(this->player_ptr)) {
result -= (this->player_ptr->lev) / 10;
} else if ((!this->player_ptr->inventory_list[INVEN_MAIN_HAND].k_idx || can_attack_with_main_hand(this->player_ptr))
void Patron::admire(player_type *player_ptr_)
{
this->player_ptr = player_ptr_;
- if ((this->player_ptr->pclass == CLASS_CHAOS_WARRIOR) || this->player_ptr->muta.has(MUTA::CHAOS_GIFT)) {
+ if ((this->player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR) || this->player_ptr->muta.has(MUTA::CHAOS_GIFT)) {
msg_format(_("%sからの声が響いた。", "The voice of %s booms out:"), this->name.c_str());
msg_print(_("『よくやった、定命の者よ！』", "'Thou art donst well, mortal!'"));
}
flags.set(TR_RES_BLIND);
flags.set(TR_RES_CONF);
flags.set(TR_HOLD_EXP);
- if (player_ptr->pclass != CLASS_NINJA)
+ if (player_ptr->pclass != PlayerClassType::NINJA)
flags.set(TR_LITE_1);
if (player_ptr->lev > 9)
flags.set(TR_SPEED);
if (mpe_mode & MPE_HANDLE_STUFF)
handle_stuff(player_ptr);
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (g_ptr->info & (CAVE_GLOW))
set_superstealth(player_ptr, false);
else if (player_ptr->cur_lite <= 0)
/*!
* 職業毎に選択可能な第一領域魔法テーブル
*/
-const uint32_t realm_choices1[MAX_CLASS] = {
+const std::vector<BIT_FLAGS> realm_choices1 = {
(CH_NONE), /* Warrior */
(CH_LIFE | CH_SORCERY | CH_NATURE | CH_CHAOS | CH_DEATH | CH_TRUMP | CH_ARCANE | CH_ENCHANT | CH_DAEMON | CH_CRUSADE), /* Mage */
(CH_LIFE | CH_DEATH | CH_DAEMON | CH_CRUSADE), /* Priest */
/*!
* 職業毎に選択可能な第二領域魔法テーブル
*/
-const uint32_t realm_choices2[MAX_CLASS] = {
+const std::vector<BIT_FLAGS> realm_choices2 = {
(CH_NONE), /* Warrior */
(CH_LIFE | CH_SORCERY | CH_NATURE | CH_CHAOS | CH_DEATH | CH_TRUMP | CH_ARCANE | CH_ENCHANT | CH_DAEMON | CH_CRUSADE), /* Mage */
(CH_LIFE | CH_SORCERY | CH_NATURE | CH_CHAOS | CH_DEATH | CH_TRUMP | CH_ARCANE | CH_ENCHANT | CH_DAEMON | CH_CRUSADE), /* Priest */
#pragma once
#include "system/angband.h"
+#include <vector>
/* 職業ごとの選択可能な魔法領域 / Possible realms that can be chosen. */
enum choosable_realm {
CH_HEX = 0x20000,
};
-extern const uint32_t realm_choices1[];
-extern const uint32_t realm_choices2[];
+extern const std::vector<BIT_FLAGS> realm_choices1;
+extern const std::vector<BIT_FLAGS> realm_choices2;
struct player_type;
enum class ItemKindType : short;
has_kabe = true;
}
- if (has_sw && ((player_ptr->realm1 == REALM_NATURE) || (player_ptr->realm2 == REALM_NATURE) || (player_ptr->pclass == CLASS_SORCERER))) {
+ if (has_sw && ((player_ptr->realm1 == REALM_NATURE) || (player_ptr->realm2 == REALM_NATURE) || (player_ptr->pclass == PlayerClassType::SORCERER))) {
const magic_type *s_ptr = &mp_ptr->info[REALM_NATURE - 1][SPELL_SW];
if (player_ptr->lev >= s_ptr->slevel)
player_ptr->no_flowed = true;
}
- if (has_kabe && ((player_ptr->realm1 == REALM_CRAFT) || (player_ptr->realm2 == REALM_CRAFT) || (player_ptr->pclass == CLASS_SORCERER))) {
+ if (has_kabe && ((player_ptr->realm1 == REALM_CRAFT) || (player_ptr->realm2 == REALM_CRAFT) || (player_ptr->pclass == PlayerClassType::SORCERER))) {
const magic_type *s_ptr = &mp_ptr->info[REALM_CRAFT - 1][SPELL_WALL];
if (player_ptr->lev >= s_ptr->slevel)
player_ptr->no_flowed = true;
BIT_FLAGS has_see_nocto(player_type *player_ptr)
{
- return (player_ptr->pclass == CLASS_NINJA) ? FLAG_CAUSE_CLASS : FLAG_CAUSE_NONE;
+ return (player_ptr->pclass == PlayerClassType::NINJA) ? FLAG_CAUSE_CLASS : FLAG_CAUSE_NONE;
}
BIT_FLAGS has_warning(player_type *player_ptr)
BIT_FLAGS has_lite(player_type *player_ptr)
{
BIT_FLAGS result = 0L;
- if (player_ptr->pclass == CLASS_NINJA)
+ if (player_ptr->pclass == PlayerClassType::NINJA)
return 0L;
if (player_ptr->ppersonality == PERSONALITY_MUNCHKIN) {
auto flgs = object_flags(o_ptr);
auto has_no_weapon = (o_ptr->tval == ItemKindType::NONE) || (o_ptr->tval == ItemKindType::SHIELD);
- if (player_ptr->pclass == CLASS_PRIEST) {
+ if (player_ptr->pclass == PlayerClassType::PRIEST) {
auto is_suitable_weapon = flgs.has(TR_BLESSED);
is_suitable_weapon |= (o_ptr->tval != ItemKindType::SWORD) && (o_ptr->tval != ItemKindType::POLEARM);
return !has_no_weapon && !is_suitable_weapon;
}
- if (player_ptr->pclass == CLASS_SORCERER) {
+ if (player_ptr->pclass == PlayerClassType::SORCERER) {
auto is_suitable_weapon = o_ptr->tval == ItemKindType::HAFTED;
is_suitable_weapon &= (o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER);
return !has_no_weapon && !is_suitable_weapon;
auto tval = player_ptr->inventory_list[INVEN_MAIN_HAND + i].tval - TV_WEAPON_BEGIN;
OBJECT_SUBTYPE_VALUE sval = player_ptr->inventory_list[INVEN_MAIN_HAND + i].sval;
- return player_ptr->pclass == CLASS_NINJA
- && !((s_info[CLASS_NINJA].w_max[tval][sval] > WEAPON_EXP_BEGINNER) && (player_ptr->inventory_list[INVEN_SUB_HAND - i].tval != ItemKindType::SHIELD));
+ return player_ptr->pclass == PlayerClassType::NINJA
+ && !((s_info[enum2i(PlayerClassType::NINJA)].w_max[tval][sval] > WEAPON_EXP_BEGINNER) && (player_ptr->inventory_list[INVEN_SUB_HAND - i].tval != ItemKindType::SHIELD));
}
bool has_not_monk_weapon(player_type *player_ptr, int i)
auto tval = player_ptr->inventory_list[INVEN_MAIN_HAND + i].tval - TV_WEAPON_BEGIN;
OBJECT_SUBTYPE_VALUE sval = player_ptr->inventory_list[INVEN_MAIN_HAND + i].sval;
- return ((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER)) && !(s_info[player_ptr->pclass].w_max[tval][sval]);
+ return ((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER)) && !(s_info[enum2i(player_ptr->pclass)].w_max[tval][sval]);
}
bool has_good_luck(player_type *player_ptr)
byte tmp_hitdie;
if (player_ptr->mimic_form) {
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
tmp_hitdie = mimic_info[player_ptr->mimic_form].r_mhp / 2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
else
tmp_hitdie = mimic_info[player_ptr->mimic_form].r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
mhp = mhp * tmp_hitdie / player_ptr->hitdie;
}
- if (player_ptr->pclass == CLASS_SORCERER) {
+ if (player_ptr->pclass == PlayerClassType::SORCERER) {
if (player_ptr->lev < 30)
mhp = (mhp * (45 + player_ptr->lev) / 100);
else
mhp += bonus;
- if (player_ptr->pclass == CLASS_BERSERKER) {
+ if (player_ptr->pclass == PlayerClassType::BERSERKER) {
mhp = mhp * (110 + (((player_ptr->lev + 40) * (player_ptr->lev + 40) - 1550) / 110)) / 100;
}
return;
if (w_ptr->character_xtra)
return;
- if ((player_ptr->pclass == CLASS_SORCERER) || (player_ptr->pclass == CLASS_RED_MAGE)) {
+ if ((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE)) {
player_ptr->new_spells = 0;
return;
}
int num_allowed = (adj_mag_study[player_ptr->stat_index[mp_ptr->spell_stat]] * levels / 2);
int bonus = 0;
- if ((player_ptr->pclass != CLASS_SAMURAI) && (mp_ptr->spell_book != ItemKindType::LIFE_BOOK)) {
+ if ((player_ptr->pclass != PlayerClassType::SAMURAI) && (mp_ptr->spell_book != ItemKindType::LIFE_BOOK)) {
bonus = 4;
}
- if (player_ptr->pclass == CLASS_SAMURAI) {
+ if (player_ptr->pclass == PlayerClassType::SAMURAI) {
num_allowed = 32;
} else if (player_ptr->realm2 == REALM_NONE) {
num_allowed = (num_allowed + 1) / 2;
if (num_allowed > (32 + bonus))
num_allowed = 32 + bonus;
- } else if ((player_ptr->pclass == CLASS_MAGE) || (player_ptr->pclass == CLASS_PRIEST)) {
+ } else if ((player_ptr->pclass == PlayerClassType::MAGE) || (player_ptr->pclass == PlayerClassType::PRIEST)) {
if (num_allowed > (96 + bonus))
num_allowed = 96 + bonus;
} else {
return;
int levels;
- if ((player_ptr->pclass == CLASS_MINDCRAFTER) || (player_ptr->pclass == CLASS_MIRROR_MASTER) || (player_ptr->pclass == CLASS_BLUE_MAGE)
- || player_ptr->pclass == CLASS_ELEMENTALIST) {
+ if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER) || (player_ptr->pclass == PlayerClassType::BLUE_MAGE)
+ || player_ptr->pclass == PlayerClassType::ELEMENTALIST) {
levels = player_ptr->lev;
} else {
if (mp_ptr->spell_first > player_ptr->lev) {
}
int msp;
- if (player_ptr->pclass == CLASS_SAMURAI) {
+ if (player_ptr->pclass == PlayerClassType::SAMURAI) {
msp = (adj_mag_mana[player_ptr->stat_index[mp_ptr->spell_stat]] + 10) * 2;
if (msp)
msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
if (msp && (player_ptr->ppersonality == PERSONALITY_MUNCHKIN))
msp += msp / 2;
- if (msp && (player_ptr->pclass == CLASS_HIGH_MAGE))
+ if (msp && (player_ptr->pclass == PlayerClassType::HIGH_MAGE))
msp += msp / 4;
- if (msp && (player_ptr->pclass == CLASS_SORCERER))
+ if (msp && (player_ptr->pclass == PlayerClassType::SORCERER))
msp += msp * (25 + player_ptr->lev) / 100;
}
cur_wgt += player_ptr->inventory_list[INVEN_FEET].weight;
switch (player_ptr->pclass) {
- case CLASS_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_BLUE_MAGE:
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
- case CLASS_SORCERER:
- case CLASS_ELEMENTALIST: {
+ case PlayerClassType::MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::BLUE_MAGE:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::SORCERER:
+ case PlayerClassType::ELEMENTALIST: {
if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight;
if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight;
break;
}
- case CLASS_PRIEST:
- case CLASS_BARD:
- case CLASS_TOURIST: {
+ case PlayerClassType::PRIEST:
+ case PlayerClassType::BARD:
+ case PlayerClassType::TOURIST: {
if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight * 2 / 3;
if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight * 2 / 3;
break;
}
- case CLASS_MINDCRAFTER:
- case CLASS_BEASTMASTER:
- case CLASS_MIRROR_MASTER: {
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::BEASTMASTER:
+ case PlayerClassType::MIRROR_MASTER: {
if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 2;
if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight / 2;
break;
}
- case CLASS_ROGUE:
- case CLASS_RANGER:
- case CLASS_RED_MAGE:
- case CLASS_WARRIOR_MAGE: {
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::RED_MAGE:
+ case PlayerClassType::WARRIOR_MAGE: {
if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 3;
if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight / 3;
break;
}
- case CLASS_PALADIN:
- case CLASS_CHAOS_WARRIOR: {
+ case PlayerClassType::PALADIN:
+ case PlayerClassType::CHAOS_WARRIOR: {
if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 5;
if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
if ((cur_wgt - max_wgt) > 0) {
player_ptr->cumber_armor = true;
switch (player_ptr->pclass) {
- case CLASS_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_BLUE_MAGE:
- case CLASS_ELEMENTALIST: {
+ case PlayerClassType::MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::BLUE_MAGE:
+ case PlayerClassType::ELEMENTALIST: {
msp -= msp * (cur_wgt - max_wgt) / 600;
break;
}
- case CLASS_PRIEST:
- case CLASS_MINDCRAFTER:
- case CLASS_BEASTMASTER:
- case CLASS_BARD:
- case CLASS_FORCETRAINER:
- case CLASS_TOURIST:
- case CLASS_MIRROR_MASTER: {
+ case PlayerClassType::PRIEST:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::BEASTMASTER:
+ case PlayerClassType::BARD:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::TOURIST:
+ case PlayerClassType::MIRROR_MASTER: {
msp -= msp * (cur_wgt - max_wgt) / 800;
break;
}
- case CLASS_SORCERER: {
+ case PlayerClassType::SORCERER: {
msp -= msp * (cur_wgt - max_wgt) / 900;
break;
}
- case CLASS_ROGUE:
- case CLASS_RANGER:
- case CLASS_MONK:
- case CLASS_RED_MAGE: {
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::RED_MAGE: {
msp -= msp * (cur_wgt - max_wgt) / 1000;
break;
}
- case CLASS_PALADIN:
- case CLASS_CHAOS_WARRIOR:
- case CLASS_WARRIOR_MAGE: {
+ case PlayerClassType::PALADIN:
+ case PlayerClassType::CHAOS_WARRIOR:
+ case PlayerClassType::WARRIOR_MAGE: {
msp -= msp * (cur_wgt - max_wgt) / 1200;
break;
}
- case CLASS_SAMURAI: {
+ case PlayerClassType::SAMURAI: {
player_ptr->cumber_armor = false;
break;
}
msp = 0;
if (player_ptr->msp != msp) {
- if ((player_ptr->csp >= msp) && (player_ptr->pclass != CLASS_SAMURAI)) {
+ if ((player_ptr->csp >= msp) && (player_ptr->pclass != PlayerClassType::SAMURAI)) {
player_ptr->csp = msp;
player_ptr->csp_frac = 0;
}
return (int16_t)num;
ItemKindType tval_ammo = bow_tval_ammo(o_ptr);
- if ((player_ptr->pclass == CLASS_RANGER) && (tval_ammo == ItemKindType::ARROW)) {
+ if ((player_ptr->pclass == PlayerClassType::RANGER) && (tval_ammo == ItemKindType::ARROW)) {
num += (player_ptr->lev * 4);
}
- if ((player_ptr->pclass == CLASS_CAVALRY) && (tval_ammo == ItemKindType::ARROW)) {
+ if ((player_ptr->pclass == PlayerClassType::CAVALRY) && (tval_ammo == ItemKindType::ARROW)) {
num += (player_ptr->lev * 3);
}
- if (player_ptr->pclass == CLASS_ARCHER) {
+ if (player_ptr->pclass == PlayerClassType::ARCHER) {
if (tval_ammo == ItemKindType::ARROW)
num += ((player_ptr->lev * 5) + 50);
else if ((tval_ammo == ItemKindType::BOLT) || (tval_ammo == ItemKindType::SHOT))
num += (player_ptr->lev * 4);
}
- if (player_ptr->pclass == CLASS_WARRIOR && (tval_ammo <= ItemKindType::BOLT) && (tval_ammo >= ItemKindType::SHOT)) {
+ if (player_ptr->pclass == PlayerClassType::WARRIOR && (tval_ammo <= ItemKindType::BOLT) && (tval_ammo >= ItemKindType::SHOT)) {
num += (player_ptr->lev * 2);
}
- if ((player_ptr->pclass == CLASS_ROGUE) && (tval_ammo == ItemKindType::SHOT)) {
+ if ((player_ptr->pclass == PlayerClassType::ROGUE) && (tval_ammo == ItemKindType::SHOT)) {
num += (player_ptr->lev * 4);
}
tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
else
tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
pow = tmp_rp_ptr->r_dis + c_ptr->c_dis + a_ptr->a_dis;
tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
else
tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
pow = tmp_rp_ptr->r_dev + c_ptr->c_dev + a_ptr->a_dev;
tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
else
tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
pow = tmp_rp_ptr->r_sav + c_ptr->c_sav + a_ptr->a_sav;
tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
else
tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
pow = tmp_rp_ptr->r_srh + c_ptr->c_srh + a_ptr->a_srh;
tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
else
tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
pow = tmp_rp_ptr->r_fos + c_ptr->c_fos + a_ptr->a_fos;
{
ACTION_SKILL_POWER pow;
const player_race_info *tmp_rp_ptr;
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
if (player_ptr->mimic_form)
{
ACTION_SKILL_POWER pow;
const player_race_info *tmp_rp_ptr;
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
if (player_ptr->mimic_form)
{
ACTION_SKILL_POWER pow;
const player_race_info *tmp_rp_ptr;
- const player_class_info *c_ptr = &class_info[player_ptr->pclass];
+ const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
if (player_ptr->mimic_form)
pow += adj_str_dig[player_ptr->stat_index[A_STR]];
- if (player_ptr->pclass == CLASS_BERSERKER)
+ if (player_ptr->pclass == PlayerClassType::BERSERKER)
pow += (100 + player_ptr->lev * 8);
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
static bool is_martial_arts_mode(player_type *player_ptr)
{
- return ((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER) || (player_ptr->pclass == CLASS_BERSERKER))
+ return ((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || (player_ptr->pclass == PlayerClassType::BERSERKER))
&& (any_bits(empty_hands(player_ptr, true), EMPTY_HAND_MAIN)) && !can_attack_with_sub_hand(player_ptr);
}
int str_index, dex_index;
int num = 0, wgt = 0, mul = 0, div = 0;
- num = class_info[player_ptr->pclass].num;
- wgt = class_info[player_ptr->pclass].wgt;
- mul = class_info[player_ptr->pclass].mul;
+ auto info = class_info[enum2i(player_ptr->pclass)];
+ num = info.num;
+ wgt = info.wgt;
+ mul = info.mul;
- if (player_ptr->pclass == CLASS_CAVALRY && (player_ptr->riding) && (flgs.has(TR_RIDING))) {
+ if (player_ptr->pclass == PlayerClassType::CAVALRY && (player_ptr->riding) && (flgs.has(TR_RIDING))) {
num = 5;
wgt = 70;
mul = 4;
str_index = (adj_str_blow[player_ptr->stat_index[A_STR]] * mul / div);
if (has_two_handed_weapons(player_ptr) && !has_disable_two_handed_bonus(player_ptr, 0))
- str_index += (player_ptr->pclass == CLASS_WARRIOR || player_ptr->pclass == CLASS_BERSERKER) ? (player_ptr->lev / 23 + 1) : 1;
- if (player_ptr->pclass == CLASS_NINJA)
+ str_index += (player_ptr->pclass == PlayerClassType::WARRIOR || player_ptr->pclass == PlayerClassType::BERSERKER) ? (player_ptr->lev / 23 + 1) : 1;
+ if (player_ptr->pclass == PlayerClassType::NINJA)
str_index = MAX(0, str_index - 1);
if (str_index > 11)
str_index = 11;
num_blow = (int16_t)num;
num_blow += (int16_t)player_ptr->extra_blows[i];
- if (player_ptr->pclass == CLASS_WARRIOR)
+ if (player_ptr->pclass == PlayerClassType::WARRIOR)
num_blow += (player_ptr->lev / 40);
- else if (player_ptr->pclass == CLASS_BERSERKER)
+ else if (player_ptr->pclass == PlayerClassType::BERSERKER)
num_blow += (player_ptr->lev / 23);
- else if ((player_ptr->pclass == CLASS_ROGUE) && (o_ptr->weight < 50) && (player_ptr->stat_index[A_DEX] >= 30))
+ else if ((player_ptr->pclass == PlayerClassType::ROGUE) && (o_ptr->weight < 50) && (player_ptr->stat_index[A_DEX] >= 30))
num_blow++;
if (PlayerClass(player_ptr).samurai_stance_is(SamuraiStance::FUUJIN))
int blow_base = player_ptr->lev + adj_dex_blow[player_ptr->stat_index[A_DEX]];
num_blow = 0;
- if (player_ptr->pclass == CLASS_FORCETRAINER) {
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
if (blow_base > 18)
num_blow++;
if (blow_base > 31)
num_blow++;
}
- if (heavy_armor(player_ptr) && (player_ptr->pclass != CLASS_BERSERKER))
+ if (heavy_armor(player_ptr) && (player_ptr->pclass != PlayerClassType::BERSERKER))
num_blow /= 2;
PlayerClass pc(player_ptr);
if (pc.monk_stance_is(MonkStance::GENBU)) {
num_blow -= 2;
- if ((player_ptr->pclass == CLASS_MONK) && (player_ptr->lev > 42))
+ if ((player_ptr->pclass == PlayerClassType::MONK) && (player_ptr->lev > 42))
num_blow--;
if (num_blow < 0)
num_blow = 0;
}
}
- if (player_ptr->pclass == CLASS_BERSERKER) {
+ if (player_ptr->pclass == PlayerClassType::BERSERKER) {
ac += 10 + player_ptr->lev / 2;
}
- if (player_ptr->pclass == CLASS_SORCERER) {
+ if (player_ptr->pclass == PlayerClassType::SORCERER) {
ac -= 50;
}
ac += 25;
}
- if (((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER)) && !heavy_armor(player_ptr)) {
+ if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER)) && !heavy_armor(player_ptr)) {
if (!(player_ptr->inventory_list[INVEN_BODY].k_idx)) {
ac += (player_ptr->lev * 3) / 2;
}
ac -= 10;
}
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if ((!player_ptr->inventory_list[INVEN_MAIN_HAND].k_idx || can_attack_with_main_hand(player_ptr))
&& (!player_ptr->inventory_list[INVEN_SUB_HAND].k_idx || can_attack_with_sub_hand(player_ptr))) {
ac += player_ptr->lev / 2 + 5;
return true;
else if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
switch (player_ptr->pclass) {
- case CLASS_MONK:
- case CLASS_FORCETRAINER:
- case CLASS_BERSERKER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::FORCETRAINER:
+ case PlayerClassType::BERSERKER:
if ((empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND)
&& !has_melee_weapon(player_ptr, INVEN_SUB_HAND))
return true;
int16_t penalty = 0;
- if ((player_ptr->pclass == CLASS_BEASTMASTER) || (player_ptr->pclass == CLASS_CAVALRY)) {
+ if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
if (player_ptr->tval_ammo != ItemKindType::ARROW)
penalty = 5;
} else {
player_ptr->old_riding_ryoute = player_ptr->riding_ryoute;
}
- if (((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER) || (player_ptr->pclass == CLASS_NINJA))
+ if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || (player_ptr->pclass == PlayerClassType::NINJA))
&& (heavy_armor(player_ptr) != player_ptr->monk_notify_aux)) {
if (heavy_armor(player_ptr)) {
msg_print(_("装備が重くてバランスを取れない。", "The weight of your armor disrupts your balance."));
auto player_stun = player_ptr->effects()->stun();
damage -= player_stun->get_damage_penalty();
- if ((player_ptr->pclass == CLASS_PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
+ if ((player_ptr->pclass == PlayerClassType::PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
damage -= 2;
- } else if (player_ptr->pclass == CLASS_BERSERKER) {
+ } else if (player_ptr->pclass == PlayerClassType::BERSERKER) {
damage += player_ptr->lev / 6;
if (((calc_hand == PLAYER_HAND_MAIN) && !can_attack_with_sub_hand(player_ptr)) || has_two_handed_weapons(player_ptr)) {
damage += player_ptr->lev / 6;
}
- } else if (player_ptr->pclass == CLASS_SORCERER) {
+ } else if (player_ptr->pclass == PlayerClassType::SORCERER) {
if (!((o_ptr->tval == ItemKindType::HAFTED) && ((o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER)))) {
damage -= 200;
} else {
damage -= 10;
}
- } else if (player_ptr->pclass == CLASS_FORCETRAINER) {
+ } else if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
// 練気術師は格闘ダメージに (気)/5 の修正を得る。
if (is_martial_arts_mode(player_ptr) && calc_hand == PLAYER_HAND_MAIN) {
damage += get_current_ki(player_ptr) / 5;
continue;
bonus_to_d = o_ptr->to_d;
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->to_d > 0)
bonus_to_d = (o_ptr->to_d + 1) / 2;
}
}
}
- if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != CLASS_BERSERKER)) {
+ if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != PlayerClassType::BERSERKER)) {
damage += (player_ptr->lev / 6);
}
hit += 15;
} else if (flgs.has_not(TR_RIDING)) {
short penalty;
- if ((player_ptr->pclass == CLASS_BEASTMASTER) || (player_ptr->pclass == CLASS_CAVALRY)) {
+ if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
penalty = 5;
} else {
penalty = r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[SKILL_RIDING] / 80;
}
/* Class penalties */
- if ((player_ptr->pclass == CLASS_PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
+ if ((player_ptr->pclass == PlayerClassType::PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
hit -= 2;
- } else if (player_ptr->pclass == CLASS_BERSERKER) {
+ } else if (player_ptr->pclass == PlayerClassType::BERSERKER) {
hit += player_ptr->lev / 5;
if (((calc_hand == PLAYER_HAND_MAIN) && !can_attack_with_sub_hand(player_ptr)) || has_two_handed_weapons(player_ptr)) {
hit += player_ptr->lev / 5;
}
- } else if (player_ptr->pclass == CLASS_SORCERER) {
+ } else if (player_ptr->pclass == PlayerClassType::SORCERER) {
if (!((o_ptr->tval == ItemKindType::HAFTED) && ((o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER)))) {
hit -= 200;
} else {
int bonus_to_h = o_ptr->to_h;
/* When wields only a weapon */
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->to_h > 0)
bonus_to_h = (o_ptr->to_h + 1) / 2;
}
}
/* Martial arts bonus */
- if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != CLASS_BERSERKER)) {
+ if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != PlayerClassType::BERSERKER)) {
hit += (player_ptr->lev / 3);
}
if (o_ptr->k_idx) {
if (o_ptr->k_idx && !is_heavy_shoot(player_ptr, &player_ptr->inventory_list[INVEN_BOW])) {
- if ((player_ptr->pclass == CLASS_SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT)) {
+ if ((player_ptr->pclass == PlayerClassType::SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT)) {
pow += (10 + (player_ptr->lev / 5));
}
}
bonus_to_h = o_ptr->to_h;
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->to_h > 0)
bonus_to_h = (o_ptr->to_h + 1) / 2;
}
continue;
int bonus_to_d = o_ptr->to_d;
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->to_d > 0)
bonus_to_d = (o_ptr->to_d + 1) / 2;
}
continue;
int bonus_to_h = o_ptr->to_h;
- if (player_ptr->pclass == CLASS_NINJA) {
+ if (player_ptr->pclass == PlayerClassType::NINJA) {
if (o_ptr->to_h > 0)
bonus_to_h = (o_ptr->to_h + 1) / 2;
}
WEIGHT calc_weight_limit(player_type *player_ptr)
{
WEIGHT i = (WEIGHT)adj_str_wgt[player_ptr->stat_index[A_STR]] * 50;
- if (player_ptr->pclass == CLASS_BERSERKER)
+ if (player_ptr->pclass == PlayerClassType::BERSERKER)
i = i * 3 / 2;
return i;
}
if (player_ptr->lev > player_ptr->max_plv) {
player_ptr->max_plv = player_ptr->lev;
- if ((player_ptr->pclass == CLASS_CHAOS_WARRIOR) || player_ptr->muta.has(MUTA::CHAOS_GIFT)) {
+ if ((player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR) || player_ptr->muta.has(MUTA::CHAOS_GIFT)) {
level_reward = true;
}
if (player_ptr->prace == PlayerRaceType::BEASTMAN) {
if (ironman_downward)
point *= 2;
- if (player_ptr->pclass == CLASS_BERSERKER) {
+ if (player_ptr->pclass == PlayerClassType::BERSERKER) {
if (player_ptr->prace == PlayerRaceType::SPECTRE)
point = point / 5;
}
bool is_shero(player_type *player_ptr)
{
- return player_ptr->shero || player_ptr->pclass == CLASS_BERSERKER;
+ return player_ptr->shero || player_ptr->pclass == PlayerClassType::BERSERKER;
}
bool is_echizen(player_type *player_ptr)
char buf[1024];
read_dead_file(buf, sizeof(buf));
concptr p = (w_ptr->total_winner || (player_ptr->lev > PY_MAX_LEVEL)) ? _("偉大なる者", "Magnificent")
- : player_titles[player_ptr->pclass][(player_ptr->lev - 1) / 5].data();
+ : player_titles[enum2i(player_ptr->pclass)][(player_ptr->lev - 1) / 5].data();
center_string(buf, player_ptr->name);
put_str(buf, 6, 11);
{
{ TR_SUST_STR },
{ TR_REGEN, 15 },
- { TR_SLOW_DIGEST, 15, CLASS_WARRIOR },
- { TR_SLOW_DIGEST, 15, CLASS_BERSERKER },
+ { TR_SLOW_DIGEST, 15, PlayerClassType::WARRIOR },
+ { TR_SLOW_DIGEST, 15, PlayerClassType::BERSERKER },
},
},
{
{ TR_IM_DARK },
{ TR_RES_NETHER },
{ TR_HOLD_EXP },
- { TR_LITE_1, 1, CLASS_NINJA, true },
+ { TR_LITE_1, 1, PlayerClassType::NINJA, true },
},
},
{
{
rpi_type rpi;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
+ case PlayerClassType::WARRIOR:
rpi = rpi_type(_("剣の舞い", "Sword Dancing"));
rpi.text = _("ランダムな方向に数回攻撃する。", "Attacks some times to random directions.");
rpi.min_level = 40;
rpi.fail = 35;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_HIGH_MAGE:
+ case PlayerClassType::HIGH_MAGE:
if (player_ptr->realm1 == REALM_HEX) {
rpi = rpi_type(_("詠唱をやめる", "Stop spell casting"));
rpi.text = _("呪術の詠唱を全てやめる。", "Stops all casting hex spells.");
break;
}
/* Fall through */
- case CLASS_MAGE:
- case CLASS_SORCERER:
+ case PlayerClassType::MAGE:
+ case PlayerClassType::SORCERER:
rpi = rpi_type(_("魔力食い", "Eat Magic"));
rpi.info = format("%s%d", KWD_POWER, rc_ptr->lvl * 2);
rpi.text = _("魔法道具から魔力を吸収してMPを回復する。", "Absorbs mana from a magic device to heal your SP.");
rpi.fail = 25;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_PRIEST:
+ case PlayerClassType::PRIEST:
if (is_good_realm(player_ptr->realm1)) {
rpi = rpi_type(_("武器祝福", "Bless Weapon"));
rpi.text = _("武器を祝福する。抵抗されることがある。", "Blesses a weapon. Some weapons can resist it.");
}
break;
- case CLASS_ROGUE:
+ case PlayerClassType::ROGUE:
rpi = rpi_type(_("ヒット＆アウェイ", "Hit and Away"));
rpi.info = format("%s%d", KWD_SPHERE, 30);
rpi.text = _("対象のモンスターを攻撃したあと短距離テレポートする。", "Attacks a monster then tereports you a short range.");
rpi.fail = 14;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_RANGER:
- case CLASS_SNIPER:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::SNIPER:
rpi = rpi_type(_("モンスター調査", "Probe Monster"));
rpi.text = _("モンスターの属性、残り体力、最大体力、スピード、正体を知る。", "Probes all monsters' alignment, HP, speed and their true character.");
rpi.min_level = 15;
rpi.fail = 12;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_PALADIN:
+ case PlayerClassType::PALADIN:
if (is_good_realm(player_ptr->realm1)) {
rpi = rpi_type(_("ホーリー・ランス", "Holy Lance"));
rpi.info = format("%s%d", KWD_DAM, rc_ptr->lvl * 3);
}
break;
- case CLASS_WARRIOR_MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
rpi = rpi_type(_("変換: ＨＰ→ＭＰ", "Convert HP to SP"));
rpi.text = _("HPを少しMPに変換する。", "Transfers a few HP to SP.");
rpi.min_level = 25;
rpi.fail = 10;
rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
break;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
rpi = rpi_type(_("幻惑の光", "Confusing Light"));
rpi.info = format("%s%d", KWD_POWER, rc_ptr->lvl * 4);
rpi.text = _("周辺のモンスターを減速・朦朧・混乱・朦朧・恐怖・睡眠させようとする。抵抗されると無効。",
rpi.fail = 25;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_MONK:
+ case PlayerClassType::MONK:
rpi = rpi_type(_("構える", "Assume a Stance"));
rpi.text = _("型に構えて特殊な能力を得る。", "Gains extra abilities with posing a 'kata'.");
rpi.min_level = 25;
rpi.fail = 20;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_MINDCRAFTER:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::FORCETRAINER:
rpi = rpi_type(_("明鏡止水", "Clear Mind"));
rpi.info = format("%s%d", KWD_MANA, 3 + rc_ptr->lvl / 20);
rpi.text = _("精神を集中してMPを少し回復する。", "Concentrates deeply to heal your SP a little.");
rpi.fail = 10;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_TOURIST:
+ case PlayerClassType::TOURIST:
rpi = rpi_type(_("写真撮影", "Take a Photograph"));
rpi.text = _("対象のモンスター1体の写真を撮影する。", "Takes a picture of a monster.");
rpi.min_level = 1;
rpi.fail = 20;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
rpi = rpi_type(_("倍返し", "Double Revenge"));
rpi.text = _("威力を倍にしてものまねを行う。", "Fires an imitation a damage of which you makes doubled.");
rpi.min_level = 30;
rpi.fail = 30;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_BEASTMASTER:
+ case PlayerClassType::BEASTMASTER:
rpi = rpi_type(_("生物支配", "Dominate a Living Thing"));
rpi.info = format("%s%d", KWD_POWER, rc_ptr->lvl);
rpi.text = _("1体のモンスターをペットにする。抵抗されると無効。", "Attempts to charm a monster.");
rpi.fail = 10;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_ARCHER:
+ case PlayerClassType::ARCHER:
rpi = rpi_type(_("弾/矢の製造", "Create Ammo"));
rpi.text = _("弾または矢を製造する。原料となるアイテムが必要。", "Creates ammos from materials.");
rpi.min_level = 1;
rpi.fail = 0;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_MAGIC_EATER:
+ case PlayerClassType::MAGIC_EATER:
rpi = rpi_type(_("魔力の取り込み", "Absorb Magic"));
rpi.text = _("魔法道具を取りこんで魔力とする。取りこんだ魔法道具は取り出せない。",
"Absorbs a magic device as your mana. Cannot take out it from your mana later.");
rpi.fail = 0;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_BARD:
+ case PlayerClassType::BARD:
rpi = rpi_type(_("歌を止める", "Stop Singing"));
rpi.text = _("現在詠唱中の歌をやめる。", "Stops singing a song.");
rpi.min_level = 1;
rpi.fail = 0;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_RED_MAGE:
+ case PlayerClassType::RED_MAGE:
rpi = rpi_type(_("連続魔", "Double Magic"));
rpi.text = _("1回の行動で2つの呪文を詠唱する。", "Casts two spells in an action.");
rpi.min_level = 48;
rpi.fail = 0;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_SAMURAI:
+ case PlayerClassType::SAMURAI:
rpi = rpi_type(_("気合いため", "Concentration"));
rpi.text = _("気合を溜めてMPを増やす。上限値をある程度超えられる。", "Increases SP for Kendo over SP limit.");
rpi.min_level = 1;
rpi.fail = 0;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
rpi = rpi_type(_("ラーニング", "Learning"));
rpi.text = _("青魔法の学習を開始または終了する。学習中はMPを消費する。", "Starts or ends to learn blue magics. Pays SP for upkeep costs during it.");
rpi.min_level = 1;
rpi.fail = 0;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_CAVALRY:
+ case PlayerClassType::CAVALRY:
rpi = rpi_type(_("荒馬ならし", "Rodeo"));
rpi.text = _("対象のモンスターの無理やり乗馬しペットにする。", "Rides to target monster and tame it focibly.");
rpi.min_level = 10;
rpi.fail = 10;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
rpi = rpi_type(_("帰還", "Recall"));
rpi.text = _("地上にいるときはダンジョンの最深階へ、ダンジョンにいるときは地上へと移動する。",
"Recalls player from dungeon to town or from town to the deepest level of dungeon.");
rpi.fail = 20;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
rpi = rpi_type(_("鏡割り", "Break Mirrors"));
rpi.text = _("現在の階に設置した鏡を全て割る。割られた鏡はなくなり、破片属性のボールが発生する。", "Destroys all mirrors located in current level. They are deleted from the level.");
rpi.min_level = 1;
rpi.fail = 20;
rc_ptr->add_power(rpi, -4);
break;
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
rpi = rpi_type(_("目利き", "Judgment"));
rpi.text = _("武器・矢弾・防具を鑑定する。", "Identifies an equipment or an ammo object.");
rpi.min_level = 5;
rpi.fail = 20;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
rpi = rpi_type(_("速駆け", "Quick Walk"));
rpi.text = _("身体を酷使して素早く移動する。", "Moves quickly but cannot regenerate HP naturally.");
rpi.min_level = 20;
rpi.fail = 0;
rc_ptr->add_power(rpi, RC_IDX_CLASS_0);
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
rpi = rpi_type(_("明鏡止水", "Clear Mind"));
rpi.info = format("%s%d", KWD_MANA, 3 + rc_ptr->lvl / 20);
rpi.text = _("精神を集中してMPを少し回復する。", "Concentrates deeply to heal your SP a little.");
return;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
- case CLASS_BERSERKER:
- case CLASS_RANGER:
- case CLASS_TOURIST:
- case CLASS_IMITATOR:
- case CLASS_ARCHER:
- case CLASS_SMITH:
+ case PlayerClassType::WARRIOR:
+ case PlayerClassType::BERSERKER:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::TOURIST:
+ case PlayerClassType::IMITATOR:
+ case PlayerClassType::ARCHER:
+ case PlayerClassType::SMITH:
if (one_in_(3)) {
*breath_type = GF_MISSILE;
*breath_type_description = _("エレメント", "the elements");
}
break;
- case CLASS_MAGE:
- case CLASS_WARRIOR_MAGE:
- case CLASS_HIGH_MAGE:
- case CLASS_SORCERER:
- case CLASS_MAGIC_EATER:
- case CLASS_RED_MAGE:
- case CLASS_BLUE_MAGE:
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
+ case PlayerClassType::HIGH_MAGE:
+ case PlayerClassType::SORCERER:
+ case PlayerClassType::MAGIC_EATER:
+ case PlayerClassType::RED_MAGE:
+ case PlayerClassType::BLUE_MAGE:
+ case PlayerClassType::MIRROR_MASTER:
if (one_in_(3)) {
*breath_type = GF_MANA;
*breath_type_description = _("魔力", "mana");
}
break;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
if (!one_in_(3)) {
*breath_type = GF_CONFUSION;
*breath_type_description = _("混乱", "confusion");
}
break;
- case CLASS_MONK:
- case CLASS_SAMURAI:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MONK:
+ case PlayerClassType::SAMURAI:
+ case PlayerClassType::FORCETRAINER:
if (!one_in_(3)) {
*breath_type = GF_CONFUSION;
*breath_type_description = _("混乱", "confusion");
}
break;
- case CLASS_MINDCRAFTER:
+ case PlayerClassType::MINDCRAFTER:
if (!one_in_(3)) {
*breath_type = GF_CONFUSION;
*breath_type_description = _("混乱", "confusion");
}
break;
- case CLASS_PRIEST:
- case CLASS_PALADIN:
+ case PlayerClassType::PRIEST:
+ case PlayerClassType::PALADIN:
if (one_in_(3)) {
*breath_type = GF_HELL_FIRE;
*breath_type_description = _("地獄の劫火", "hellfire");
}
break;
- case CLASS_ROGUE:
- case CLASS_NINJA:
+ case PlayerClassType::ROGUE:
+ case PlayerClassType::NINJA:
if (one_in_(3)) {
*breath_type = GF_DARK;
*breath_type_description = _("暗黒", "darkness");
}
break;
- case CLASS_BARD:
+ case PlayerClassType::BARD:
if (!one_in_(3)) {
*breath_type = GF_SOUND;
*breath_type_description = _("轟音", "sound");
}
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
*breath_type = get_element_type(player_ptr->element, 0);
*breath_type_description = get_element_name(player_ptr->element, 0);
break;
{
DIRECTION dir = 0;
switch (player_ptr->pclass) {
- case CLASS_WARRIOR:
+ case PlayerClassType::WARRIOR:
return sword_dancing(player_ptr);
- case CLASS_HIGH_MAGE:
+ case PlayerClassType::HIGH_MAGE:
if (player_ptr->realm1 == REALM_HEX) {
auto retval = SpellHex(player_ptr).stop_spells_with_selection();
if (retval) {
}
/* Fall through */
- case CLASS_MAGE:
- case CLASS_SORCERER:
+ case PlayerClassType::MAGE:
+ case PlayerClassType::SORCERER:
return eat_magic(player_ptr, player_ptr->lev * 2);
- case CLASS_PRIEST:
+ case PlayerClassType::PRIEST:
if (!is_good_realm(player_ptr->realm1)) {
(void)dispel_monsters(player_ptr, player_ptr->lev * 4);
turn_monsters(player_ptr, player_ptr->lev * 4);
}
return bless_weapon(player_ptr);
- case CLASS_ROGUE:
+ case PlayerClassType::ROGUE:
return hit_and_away(player_ptr);
- case CLASS_RANGER:
- case CLASS_SNIPER:
+ case PlayerClassType::RANGER:
+ case PlayerClassType::SNIPER:
msg_print(_("敵を調査した...", "You examine your foes..."));
probing(player_ptr);
return true;
- case CLASS_PALADIN:
+ case PlayerClassType::PALADIN:
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);
return true;
- case CLASS_WARRIOR_MAGE:
+ case PlayerClassType::WARRIOR_MAGE:
if (command == -3)
return comvert_hp_to_mp(player_ptr);
else if (command == -4)
return comvert_mp_to_hp(player_ptr);
return true;
- case CLASS_CHAOS_WARRIOR:
+ case PlayerClassType::CHAOS_WARRIOR:
return confusing_light(player_ptr);
- case CLASS_MONK:
+ case PlayerClassType::MONK:
if (none_bits(empty_hands(player_ptr, true), EMPTY_HAND_MAIN)) {
msg_print(_("素手じゃないとできません。", "You need to be barehanded."));
return false;
return double_attack(player_ptr);
return true;
- case CLASS_MINDCRAFTER:
- case CLASS_FORCETRAINER:
+ case PlayerClassType::MINDCRAFTER:
+ case PlayerClassType::FORCETRAINER:
return clear_mind(player_ptr);
- case CLASS_TOURIST:
+ case PlayerClassType::TOURIST:
if (command == -3) {
if (!get_aim_dir(player_ptr, &dir))
return false;
}
return (command != -4) || identify_fully(player_ptr, false);
- case CLASS_IMITATOR:
+ case PlayerClassType::IMITATOR:
handle_stuff(player_ptr);
return do_cmd_mane(player_ptr, true);
- case CLASS_BEASTMASTER:
+ case PlayerClassType::BEASTMASTER:
if (command == -3) {
if (!get_aim_dir(player_ptr, &dir))
return false;
project_all_los(player_ptr, GF_CHARM_LIVING, player_ptr->lev);
return true;
- case CLASS_ARCHER:
+ case PlayerClassType::ARCHER:
return create_ammo(player_ptr);
- case CLASS_MAGIC_EATER:
+ case PlayerClassType::MAGIC_EATER:
if (command == -3)
return import_magic_device(player_ptr);
return (command != -4) || (!cmd_limit_cast(player_ptr) && do_cmd_magic_eater(player_ptr, false, true));
- case CLASS_BARD:
+ case PlayerClassType::BARD:
if ((get_singing_song_effect(player_ptr) == 0) && (get_interrupting_song_effect(player_ptr) == 0))
return false;
stop_singing(player_ptr);
PlayerEnergy(player_ptr).set_player_turn_energy(10);
return true;
- case CLASS_RED_MAGE:
+ case PlayerClassType::RED_MAGE:
if (cmd_limit_cast(player_ptr))
return false;
(void)do_cmd_cast(player_ptr);
}
return true;
- case CLASS_SAMURAI:
+ case PlayerClassType::SAMURAI:
if (command == -3) {
concentration(player_ptr);
return true;
set_bits(player_ptr->update, PU_BONUS);
return true;
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
set_action(player_ptr, player_ptr->action == ACTION_LEARN ? ACTION_NONE : ACTION_LEARN);
PlayerEnergy(player_ptr).reset_player_turn();
return true;
- case CLASS_CAVALRY:
+ case PlayerClassType::CAVALRY:
return rodeo(player_ptr);
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
return recall_player(player_ptr, randint0(21) + 15);
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
if (player_ptr->lev <= 29)
return ident_spell(player_ptr, true);
return identify_fully(player_ptr, true);
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
if (command == -3) {
remove_all_mirrors(player_ptr, true);
return true;
return mirror_concentration(player_ptr);
return true;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
return hayagake(player_ptr);
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
if (command == -3)
return clear_mind(player_ptr);
if (command == -4)
{
this->ask = true;
this->lvl = player_ptr->lev;
- this->is_warrior = (player_ptr->pclass == CLASS_WARRIOR || player_ptr->pclass == CLASS_BERSERKER);
+ this->is_warrior = (player_ptr->pclass == PlayerClassType::WARRIOR || player_ptr->pclass == PlayerClassType::BERSERKER);
}
void rc_type::add_power(rpi_type& rpi, int number)
DICE_SID sides = 6;
POSITION rad = (plev < 30) ? 2 : 3;
int base;
- if (player_ptr->pclass == CLASS_PRIEST || player_ptr->pclass == CLASS_HIGH_MAGE || player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::PRIEST || player_ptr->pclass == PlayerClassType::HIGH_MAGE || player_ptr->pclass == PlayerClassType::SORCERER)
base = plev + plev / 2;
else
base = plev + plev / 4;
y = player_ptr->y;
}
- if (player_ptr->pclass == CLASS_BEASTMASTER)
+ if (player_ptr->pclass == PlayerClassType::BEASTMASTER)
type = SUMMON_KAMIKAZE_LIVING;
else
type = SUMMON_KAMIKAZE;
if (cast || fail) {
summon_type type;
msg_print(_("あなたはモンスターのカードに集中する...", "You concentrate on several trumps at once..."));
- if (player_ptr->pclass == CLASS_BEASTMASTER)
+ if (player_ptr->pclass == PlayerClassType::BEASTMASTER)
type = SUMMON_LIVING;
else
type = SUMMON_NONE;
if (cast) {
summon_type type;
- if (player_ptr->pclass == CLASS_BEASTMASTER)
+ if (player_ptr->pclass == PlayerClassType::BEASTMASTER)
type = SUMMON_HI_DRAGON_LIVING;
else
type = SUMMON_HI_DRAGON;
*/
static void wr_relams(player_type *player_ptr)
{
- if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
wr_byte((byte)player_ptr->element);
else
wr_byte((byte)player_ptr->realm1);
}
int num = 1;
- if (player_ptr->pclass == CLASS_ARCHER) {
+ if (player_ptr->pclass == PlayerClassType::ARCHER) {
if (player_ptr->lev >= 10)
num++;
if (!(has_resist_pois(player_ptr) || is_oppose_pois(player_ptr)) && (*magnification < 25))
*magnification = 25;
- if ((player_ptr->pclass != CLASS_SAMURAI) && (death_scythe_flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (player_ptr->msp / 30))) {
+ if ((player_ptr->pclass != PlayerClassType::SAMURAI) && (death_scythe_flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (player_ptr->msp / 30))) {
player_ptr->csp -= (1 + (player_ptr->msp / 30));
player_ptr->redraw |= (PR_MANA);
*magnification = *magnification * 3 / 2 + 20;
case 20: {
auto is_statue = stop_ty;
is_statue |= player_ptr->free_act && (randint1(125) < player_ptr->skill_sav);
- is_statue |= player_ptr->pclass == CLASS_BERSERKER;
+ is_statue |= player_ptr->pclass == PlayerClassType::BERSERKER;
if (!is_statue) {
msg_print(_("彫像になった気分だ！", "You feel like a statue!"));
TIME_EFFECT turns = player_ptr->free_act ? randint1(3) : randint1(13);
return;
bool follow = false;
- if (player_ptr->muta.has(MUTA::VTELEPORT) || (player_ptr->pclass == CLASS_IMITATOR))
+ if (player_ptr->muta.has(MUTA::VTELEPORT) || (player_ptr->pclass == PlayerClassType::IMITATOR))
follow = true;
else {
object_type *o_ptr;
*/
void check_music(player_type *player_ptr)
{
- if (player_ptr->pclass != CLASS_BARD)
+ if (player_ptr->pclass != PlayerClassType::BARD)
return;
auto interupting_song_effect = get_interrupting_song_effect(player_ptr);
*/
void stop_singing(player_type *player_ptr)
{
- if (player_ptr->pclass != CLASS_BARD)
+ if (player_ptr->pclass != PlayerClassType::BARD)
return;
if (get_interrupting_song_effect(player_ptr) != 0) {
int vir = virtue_number(player_ptr, V_CHANCE);
int i;
- if ((player_ptr->pclass == CLASS_ROGUE) || (player_ptr->pclass == CLASS_HIGH_MAGE) || (player_ptr->pclass == CLASS_SORCERER))
+ if ((player_ptr->pclass == PlayerClassType::ROGUE) || (player_ptr->pclass == PlayerClassType::HIGH_MAGE) || (player_ptr->pclass == PlayerClassType::SORCERER))
die = (randint1(110)) + plev / 5;
else
die = randint1(120);
*/
EXP experience_of_spell(player_type *player_ptr, SPELL_IDX spell, int16_t use_realm)
{
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
return SPELL_EXP_MASTER;
- else if (player_ptr->pclass == CLASS_RED_MAGE)
+ else if (player_ptr->pclass == PlayerClassType::RED_MAGE)
return SPELL_EXP_SKILLED;
else if (use_realm == player_ptr->realm1)
return player_ptr->spell_exp[spell];
chance += 5 * (need_mana - player_ptr->csp);
}
- if ((use_realm != player_ptr->realm1) && ((player_ptr->pclass == CLASS_MAGE) || (player_ptr->pclass == CLASS_PRIEST)))
+ if ((use_realm != player_ptr->realm1) && ((player_ptr->pclass == PlayerClassType::MAGE) || (player_ptr->pclass == PlayerClassType::PRIEST)))
chance += 5;
PERCENTAGE minfail = adj_mag_fail[player_ptr->stat_index[mp_ptr->spell_stat]];
minfail = 5;
}
- if (((player_ptr->pclass == CLASS_PRIEST) || (player_ptr->pclass == CLASS_SORCERER)) && player_ptr->is_icky_wield[0])
+ if (((player_ptr->pclass == PlayerClassType::PRIEST) || (player_ptr->pclass == PlayerClassType::SORCERER)) && player_ptr->is_icky_wield[0])
chance += 25;
- if (((player_ptr->pclass == CLASS_PRIEST) || (player_ptr->pclass == CLASS_SORCERER)) && player_ptr->is_icky_wield[1])
+ if (((player_ptr->pclass == PlayerClassType::PRIEST) || (player_ptr->pclass == PlayerClassType::SORCERER)) && player_ptr->is_icky_wield[1])
chance += 25;
chance = mod_spell_chance_1(player_ptr, chance);
chance = 95;
}
- if ((use_realm == player_ptr->realm1) || (use_realm == player_ptr->realm2) || (player_ptr->pclass == CLASS_SORCERER)
- || (player_ptr->pclass == CLASS_RED_MAGE)) {
+ if ((use_realm == player_ptr->realm1) || (use_realm == player_ptr->realm2) || (player_ptr->pclass == PlayerClassType::SORCERER)
+ || (player_ptr->pclass == PlayerClassType::RED_MAGE)) {
EXP exp = experience_of_spell(player_ptr, spell, use_realm);
if (exp >= SPELL_EXP_EXPERT)
chance--;
put_str(buf, y, x + 29);
int increment = 64;
- if ((player_ptr->pclass == CLASS_SORCERER) || (player_ptr->pclass == CLASS_RED_MAGE))
+ if ((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE))
increment = 0;
else if (use_realm == player_ptr->realm1)
increment = 0;
max = true;
else if (s_ptr->slevel >= 99)
max = true;
- else if ((player_ptr->pclass == CLASS_RED_MAGE) && (exp_level >= EXP_LEVEL_SKILLED))
+ else if ((player_ptr->pclass == PlayerClassType::RED_MAGE) && (exp_level >= EXP_LEVEL_SKILLED))
max = true;
strncpy(ryakuji, exp_level_str[exp_level], 4);
strcpy(info, exe_spell(player_ptr, use_realm, spell, SPELL_INFO));
concptr comment = info;
byte line_attr = TERM_WHITE;
- if ((player_ptr->pclass == CLASS_SORCERER) || (player_ptr->pclass == CLASS_RED_MAGE)) {
+ if ((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE)) {
if (s_ptr->slevel > player_ptr->max_plv) {
comment = _("未知", "unknown");
line_attr = TERM_L_BLUE;
*/
PERCENTAGE beam_chance(player_type *player_ptr)
{
- if (player_ptr->pclass == CLASS_MAGE)
+ if (player_ptr->pclass == PlayerClassType::MAGE)
return (PERCENTAGE)(player_ptr->lev);
- if (player_ptr->pclass == CLASS_HIGH_MAGE || player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::HIGH_MAGE || player_ptr->pclass == PlayerClassType::SORCERER)
return (PERCENTAGE)(player_ptr->lev + 10);
return (PERCENTAGE)(player_ptr->lev / 2);
project(player_ptr, 0, (powerful ? 7 : 5), player_ptr->y, player_ptr->x, (randint1(200) + (powerful ? 500 : 300)) * 2, GF_MANA,
PROJECT_KILL | PROJECT_ITEM | PROJECT_GRID);
- bool is_special_class = player_ptr->pclass != CLASS_MAGE;
- is_special_class &= player_ptr->pclass != CLASS_HIGH_MAGE;
- is_special_class &= player_ptr->pclass != CLASS_SORCERER;
- is_special_class &= player_ptr->pclass != CLASS_MAGIC_EATER;
- is_special_class &= player_ptr->pclass != CLASS_BLUE_MAGE;
- is_special_class &= player_ptr->pclass != CLASS_ELEMENTALIST;
+ bool is_special_class = player_ptr->pclass != PlayerClassType::MAGE;
+ is_special_class &= player_ptr->pclass != PlayerClassType::HIGH_MAGE;
+ is_special_class &= player_ptr->pclass != PlayerClassType::SORCERER;
+ is_special_class &= player_ptr->pclass != PlayerClassType::MAGIC_EATER;
+ is_special_class &= player_ptr->pclass != PlayerClassType::BLUE_MAGE;
+ is_special_class &= player_ptr->pclass != PlayerClassType::ELEMENTALIST;
if (is_special_class)
(void)take_hit(player_ptr, DAMAGE_NOESCAPE, 50, _("コントロールし難い強力な魔力の解放", "unleashing magics too mighty to control"));
bool restore_mana(player_type *player_ptr, bool magic_eater)
{
- if (player_ptr->pclass == CLASS_MAGIC_EATER && magic_eater) {
+ if (player_ptr->pclass == PlayerClassType::MAGIC_EATER && magic_eater) {
// 魔力復活による、魔道具術師の取り込んだ魔法の回復量
// 取り込み数が10回未満: 3 回分回復
// 取り込み数が10回以上: 取り込み回数/3 回分回復
(void)set_blessed(player_ptr, player_ptr->blessed + t, false);
(void)set_fast(player_ptr, player_ptr->fast + t, false);
(void)set_shero(player_ptr, player_ptr->shero + t, false);
- if (player_ptr->pclass == CLASS_FORCETRAINER) {
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
set_current_ki(player_ptr, true, player_ptr->lev * 5 + 190);
msg_print(_("気が爆発寸前になった。", "Your force absorbs the explosion."));
}
(void)set_monster_invulner(player_ptr, player_ptr->riding, 0, false);
}
- if (player_ptr->pclass == CLASS_BARD) {
+ if (player_ptr->pclass == PlayerClassType::BARD) {
set_singing_song_effect(player_ptr, MUSIC_NONE);
set_singing_song_id(player_ptr, 0);
}
if (player_ptr->is_dead)
return false;
- if (player_ptr->pclass == CLASS_BERSERKER) {
+ if (player_ptr->pclass == PlayerClassType::BERSERKER) {
v = 1;
return false;
}
{
bool notice = false;
v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
- if ((player_ptr->pclass == CLASS_NINJA) && (player_ptr->lev > 44))
+ if ((player_ptr->pclass == PlayerClassType::NINJA) && (player_ptr->lev > 44))
v = 1;
if (player_ptr->is_dead)
return false;
bool is_oppose_pois(player_type *player_ptr)
{
return player_ptr->oppose_pois || music_singing(player_ptr, MUSIC_RESIST)
- || (PlayerClass(player_ptr).samurai_stance_is(SamuraiStance::MUSOU) || (player_ptr->pclass == CLASS_NINJA && player_ptr->lev > 44));
+ || (PlayerClass(player_ptr).samurai_stance_is(SamuraiStance::MUSOU) || (player_ptr->pclass == PlayerClassType::NINJA && player_ptr->lev > 44));
}
rp_ptr = &race_info[enum2i(player_ptr->prace)];
player_ptr->expfact = rp_ptr->r_exp + cp_ptr->c_exp;
- bool is_special_class = player_ptr->pclass == CLASS_MONK;
- is_special_class |= player_ptr->pclass == CLASS_FORCETRAINER;
- is_special_class |= player_ptr->pclass == CLASS_NINJA;
+ bool is_special_class = player_ptr->pclass == PlayerClassType::MONK;
+ is_special_class |= player_ptr->pclass == PlayerClassType::FORCETRAINER;
+ is_special_class |= player_ptr->pclass == PlayerClassType::NINJA;
bool is_special_race = player_ptr->prace == PlayerRaceType::KLACKON;
is_special_race |= player_ptr->prace == PlayerRaceType::SPRITE;
if (is_special_class && is_special_race)
get_height_weight(player_ptr);
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
player_ptr->hitdie = rp_ptr->r_mhp / 2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
else
player_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
break;
}
case 'b': {
- if ((player_ptr->pclass == CLASS_MINDCRAFTER) || (player_ptr->pclass == CLASS_BERSERKER) || (player_ptr->pclass == CLASS_NINJA)
- || (player_ptr->pclass == CLASS_MIRROR_MASTER))
+ if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::BERSERKER) || (player_ptr->pclass == PlayerClassType::NINJA)
+ || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER))
do_cmd_mind_browse(player_ptr);
- else if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ else if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
do_cmd_element_browse(player_ptr);
- else if (player_ptr->pclass == CLASS_SMITH)
+ else if (player_ptr->pclass == PlayerClassType::SMITH)
do_cmd_kaji(player_ptr, true);
- else if (player_ptr->pclass == CLASS_MAGIC_EATER)
+ else if (player_ptr->pclass == PlayerClassType::MAGIC_EATER)
do_cmd_magic_eater(player_ptr, true, false);
- else if (player_ptr->pclass == CLASS_SNIPER)
+ else if (player_ptr->pclass == PlayerClassType::SNIPER)
do_cmd_snipe_browse(player_ptr);
else
do_cmd_browse(player_ptr);
return;
}
- if ((player_ptr->pclass != CLASS_MONK) || ((empty_hands(player_ptr, true) & EMPTY_HAND_MAIN) == 0))
+ if ((player_ptr->pclass != PlayerClassType::MONK) || ((empty_hands(player_ptr, true) & EMPTY_HAND_MAIN) == 0))
return;
PlayerClass pc(player_ptr);
return;
char tmp[64];
- if (player_ptr->pclass == CLASS_ELEMENTALIST)
+ if (player_ptr->pclass == PlayerClassType::ELEMENTALIST)
sprintf(tmp, "%s", get_element_title(player_ptr->element));
else if (player_ptr->realm2)
sprintf(tmp, "%s, %s", realm_names[player_ptr->realm1], realm_names[player_ptr->realm2]);
display_player_basic_info(player_ptr);
display_magic_realms(player_ptr);
- if ((player_ptr->pclass == CLASS_CHAOS_WARRIOR) || (player_ptr->muta.has(MUTA::CHAOS_GIFT)))
+ if ((player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR) || (player_ptr->muta.has(MUTA::CHAOS_GIFT)))
display_player_one_line(ENTRY_PATRON, patron_list[player_ptr->chaos_patron].name.c_str(), TERM_L_BLUE);
display_phisique(player_ptr);
if ((use_realm != player_ptr->realm1) && (use_realm != player_ptr->realm2))
return;
} else {
- if ((player_ptr->pclass != CLASS_SORCERER) && (player_ptr->pclass != CLASS_RED_MAGE))
+ if ((player_ptr->pclass != PlayerClassType::SORCERER) && (player_ptr->pclass != PlayerClassType::RED_MAGE))
return;
if (!is_magic(use_realm))
return;
- if ((player_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1))
+ if ((player_ptr->pclass == PlayerClassType::RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1))
return;
}
*shots = 1;
*shot_frac = 0;
- if (player_ptr->pclass != CLASS_ARCHER)
+ if (player_ptr->pclass != PlayerClassType::ARCHER)
return;
if (player_ptr->lev >= 10)
return false;
}
- if (player_ptr->pclass == CLASS_FORCETRAINER)
+ if (player_ptr->pclass == PlayerClassType::FORCETRAINER)
level = MAX(1, level - 3);
PlayerClass pc(player_ptr);
if (pc.monk_stance_is(MonkStance::BYAKKO))
}
// 理力
- bool is_force = player_ptr->pclass != CLASS_SAMURAI;
+ bool is_force = player_ptr->pclass != PlayerClassType::SAMURAI;
is_force &= flgs.has(TR_FORCE_WEAPON);
is_force &= player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5);
if (is_force)
for (int i = 0; i < 2; i++) {
int basedam;
damage[i] = player_ptr->dis_to_d[i] * 100;
- if (((player_ptr->pclass == CLASS_MONK) || (player_ptr->pclass == CLASS_FORCETRAINER)) && (empty_hands(player_ptr, true) & EMPTY_HAND_MAIN)) {
+ if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER)) && (empty_hands(player_ptr, true) & EMPTY_HAND_MAIN)) {
if (!calc_weapon_damage_limit(player_ptr, i, damage, &basedam, o_ptr))
break;
clear_from(0);
- if (player_ptr->pclass == CLASS_SORCERER)
+ if (player_ptr->pclass == PlayerClassType::SORCERER)
return;
- if (player_ptr->pclass == CLASS_RED_MAGE)
+ if (player_ptr->pclass == PlayerClassType::RED_MAGE)
return;
- if (player_ptr->pclass == CLASS_SNIPER) {
+ if (player_ptr->pclass == PlayerClassType::SNIPER) {
display_snipe_list(player_ptr);
return;
}
- if ((player_ptr->pclass == CLASS_MINDCRAFTER) || (player_ptr->pclass == CLASS_BERSERKER) || (player_ptr->pclass == CLASS_NINJA)
- || (player_ptr->pclass == CLASS_MIRROR_MASTER) || (player_ptr->pclass == CLASS_FORCETRAINER) || player_ptr->pclass == CLASS_ELEMENTALIST) {
+ if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::BERSERKER) || (player_ptr->pclass == PlayerClassType::NINJA)
+ || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || player_ptr->pclass == PlayerClassType::ELEMENTALIST) {
PERCENTAGE minfail = 0;
PLAYER_LEVEL plev = player_ptr->lev;
PERCENTAGE chance = 0;
put_str(_("Lv MP 失率 効果", "Lv Mana Fail Info"), y, x + 35);
switch (player_ptr->pclass) {
- case CLASS_MINDCRAFTER:
+ case PlayerClassType::MINDCRAFTER:
use_mind = mind_kind_type::MINDCRAFTER;
break;
- case CLASS_FORCETRAINER:
+ case PlayerClassType::FORCETRAINER:
use_mind = mind_kind_type::KI;
break;
- case CLASS_BERSERKER:
+ case PlayerClassType::BERSERKER:
use_mind = mind_kind_type::BERSERKER;
use_hp = true;
break;
- case CLASS_MIRROR_MASTER:
+ case PlayerClassType::MIRROR_MASTER:
use_mind = mind_kind_type::MIRROR_MASTER;
break;
- case CLASS_NINJA:
+ case PlayerClassType::NINJA:
use_mind = mind_kind_type::NINJUTSU;
use_hp = true;
break;
- case CLASS_ELEMENTALIST:
+ case PlayerClassType::ELEMENTALIST:
use_mind = mind_kind_type::ELEMENTAL;
break;
default:
p = _("***勝利者***", "***WINNER***");
}
} else {
- angband_strcpy(str, player_titles[player_ptr->pclass][(player_ptr->lev - 1) / 5].data(), sizeof(str));
+ angband_strcpy(str, player_titles[enum2i(player_ptr->pclass)][(player_ptr->lev - 1) / 5].data(), sizeof(str));
p = str;
}
TERM_LEN col_study = wid + COL_STUDY;
TERM_LEN row_study = hgt + ROW_STUDY;
- if (player_ptr->pclass != CLASS_IMITATOR)
+ if (player_ptr->pclass != PlayerClassType::IMITATOR)
return;
auto mane_data = PlayerClass(player_ptr).get_specific_data<mane_data_type>();
break;
case 'E':
switch (player_ptr->pclass) {
- case CLASS_BLUE_MAGE:
+ case PlayerClassType::BLUE_MAGE:
wiz_learn_blue_magic_all(player_ptr);
break;
- case CLASS_SMITH:
+ case PlayerClassType::SMITH:
wiz_fillup_all_smith_essences(player_ptr);
break;
default:
wiz_lite(player_ptr, false);
break;
case 'w':
- wiz_lite(player_ptr, (bool)(player_ptr->pclass == CLASS_NINJA));
+ wiz_lite(player_ptr, (bool)(player_ptr->pclass == PlayerClassType::NINJA));
break;
case 'x':
gain_exp(player_ptr, command_arg ? command_arg : (player_ptr->exp + 1));
for (auto j = 0; j <= TV_WEAPON_END - TV_WEAPON_BEGIN; j++) {
for (int i = 0; i < 64; i++) {
player_ptr->weapon_exp[j][i] = tmp_s16b;
- if (player_ptr->weapon_exp[j][i] > s_info[player_ptr->pclass].w_max[j][i])
- player_ptr->weapon_exp[j][i] = s_info[player_ptr->pclass].w_max[j][i];
+ auto short_pclass = enum2i(player_ptr->pclass);
+ if (player_ptr->weapon_exp[j][i] > s_info[short_pclass].w_max[j][i])
+ player_ptr->weapon_exp[j][i] = s_info[short_pclass].w_max[j][i];
}
}
for (int j = 0; j < 10; j++) {
player_ptr->skill_exp[j] = tmp_s16b;
- if (player_ptr->skill_exp[j] > s_info[player_ptr->pclass].s_max[j])
- player_ptr->skill_exp[j] = s_info[player_ptr->pclass].s_max[j];
+ auto short_pclass = enum2i(player_ptr->pclass);
+ if (player_ptr->skill_exp[j] > s_info[short_pclass].s_max[j])
+ player_ptr->skill_exp[j] = s_info[short_pclass].s_max[j];
}
int k;
void wiz_reset_class(player_type *player_ptr)
{
char ppp[80];
- sprintf(ppp, "Class (0-%d): ", MAX_CLASS - 1);
+ sprintf(ppp, "Class (0-%d): ", enum2i(PlayerClassType::MAX) - 1);
char tmp_val[160];
sprintf(tmp_val, "%d", player_ptr->pclass);
return;
int tmp_int = atoi(tmp_val);
- if (tmp_int < 0 || tmp_int >= MAX_CLASS)
+ if (tmp_int < 0 || tmp_int >= enum2i(PlayerClassType::MAX))
return;
player_ptr->pclass = i2enum<PlayerClassType>(tmp_int);
- cp_ptr = &class_info[player_ptr->pclass];
- mp_ptr = &m_info[player_ptr->pclass];
+ auto short_pclass = enum2i(player_ptr->pclass);
+ cp_ptr = &class_info[short_pclass];
+ mp_ptr = &m_info[short_pclass];
PlayerClass(player_ptr).init_specific_data();
player_ptr->window_flags |= PW_PLAYER;
player_ptr->update |= PU_BONUS | PU_HP | PU_MANA | PU_SPELLS;
player_type dummy_p;
dummy_p.lev = 1;
- for (int c = 0; c < MAX_CLASS; c++) {
+ for (int c = 0; c < enum2i(PlayerClassType::MAX); c++) {
auto class_ptr = &class_info[c];
sprintf(buf, "[[Class: %s]]\n", class_ptr->title);
spoil_out(buf);
*/
bool is_winner_class(PlayerClassType c)
{
- if (c == MAX_CLASS)
+ if (c == PlayerClassType::MAX)
return false;
return w_ptr->sf_winner.has(c);
}
*/
bool is_retired_class(PlayerClassType c)
{
- if (c == MAX_CLASS)
+ if (c == PlayerClassType::MAX)
return false;
return w_ptr->sf_retired.has(c);
}
uint16_t sf_lives{}; //!< このセーブファイルで何人プレイしたか / Number of past "lives" with this file
uint16_t sf_saves{}; //!< 現在のプレイで何回セーブしたか / Number of "saves" during this life
uint32_t sf_play_time{}; //!< このセーブファイルで遊んだ合計のプレイ時間
- FlagGroup<PlayerClassType, MAX_CLASS> sf_winner{}; //!< このセーブファイルで*勝利*した職業
- FlagGroup<PlayerClassType, MAX_CLASS> sf_retired{}; //!< このセーブファイルで引退した職業
+ FlagGroup<PlayerClassType, PlayerClassType::MAX> sf_winner{}; //!< このセーブファイルで*勝利*した職業
+ FlagGroup<PlayerClassType, PlayerClassType::MAX> sf_retired{}; //!< このセーブファイルで引退した職業
bool character_generated{}; /* The character exists */
bool character_dungeon{}; /* The character has a dungeon */
OSDN Git Service
