int Game_Battler::CalculateSkillCost(int skill_id) {
const RPG::Skill& skill = Data::skills[skill_id - 1];
return (Player::engine == Player::EngineRpg2k3 &&
skill.sp_type == RPG::Skill::SpType_percent)
? GetMaxSp() * skill.sp_percent / 100
: skill.sp_cost;
}
void Game_Actor::Init() {
const std::vector<RPG::Learning>& skills = Data::actors[data.ID - 1].skills;
for (int i = 0; i < (int) skills.size(); i++)
if (skills[i].level <= GetLevel())
LearnSkill(skills[i].skill_id);
SetHp(GetMaxHp());
SetSp(GetMaxSp());
SetExp(exp_list[GetLevel() - 1]);
}
void Game_Enemy::Setup(int enemy_id) {
Transform(enemy_id);
hp = GetMaxHp();
sp = GetMaxSp();
x = 0;
y = 0;
hidden = false;
cycle = Utils::GetRandomNumber(0, levitation_frame_count - 1) * levitation_frame_cycle;
flying_offset = 0;
}
int Game_Battler::CalculateSkillCost(int skill_id) const {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_id);
if (!skill) {
Output::Warning("CalculateSkillCost: Invalid skill ID %d", skill_id);
return 0;
}
return (Player::IsRPG2k3() && skill->sp_type == RPG::Skill::SpType_percent)
? GetMaxSp() * skill->sp_percent / 100
: skill->sp_cost;
}
bool Game_Enemy::IsActionValid(const RPG::EnemyAction& action) {
if (action.kind == action.Kind_skill) {
if (!IsSkillUsable(action.skill_id)) {
return false;
}
}
switch (action.condition_type) {
case RPG::EnemyAction::ConditionType_always:
return true;
case RPG::EnemyAction::ConditionType_switch:
return Game_Switches[action.switch_id];
case RPG::EnemyAction::ConditionType_turn:
{
int turns = Game_Battle::GetTurn();
return Game_Battle::CheckTurns(turns, action.condition_param2, action.condition_param1);
}
case RPG::EnemyAction::ConditionType_actors:
{
std::vector<Game_Battler*> battlers;
GetParty().GetActiveBattlers(battlers);
int count = (int)battlers.size();
return count >= action.condition_param1 && count <= action.condition_param2;
}
case RPG::EnemyAction::ConditionType_hp:
{
int hp_percent = GetHp() * 100 / GetMaxHp();
return hp_percent >= action.condition_param1 && hp_percent <= action.condition_param2;
}
case RPG::EnemyAction::ConditionType_sp:
{
int sp_percent = GetSp() * 100 / GetMaxSp();
return sp_percent >= action.condition_param1 && sp_percent <= action.condition_param2;
}
case RPG::EnemyAction::ConditionType_party_lvl:
{
int party_lvl = Main_Data::game_party->GetAverageLevel();
return party_lvl >= action.condition_param1 && party_lvl <= action.condition_param2;
}
case RPG::EnemyAction::ConditionType_party_fatigue:
{
int party_exh = Main_Data::game_party->GetFatigue();
return party_exh >= action.condition_param1 && party_exh <= action.condition_param2;
}
default:
return true;
}
}
void Game_Actor::Init() {
const std::vector<RPG::Learning>& skills = GetActor().skills;
for (int i = 0; i < (int)skills.size(); i++) {
if (skills[i].level <= GetLevel()) {
LearnSkill(skills[i].skill_id);
}
}
RemoveInvalidData();
if (GetLevel() > 0) {
SetHp(GetMaxHp());
SetSp(GetMaxSp());
SetExp(exp_list[GetLevel() - 1]);
}
AddEquipmentStates();
}
bool Game_Battler::UseItem(int item_id) {
const RPG::Item& item = Data::items[item_id - 1];
if (item.type == RPG::Item::Type_medicine) {
int hp_change = item.recover_hp_rate * GetMaxHp() / 100 + item.recover_hp;
int sp_change = item.recover_sp_rate * GetMaxSp() / 100 + item.recover_sp;
if (IsDead()) {
// Check if item can revive
if (item.state_set.empty() || !item.state_set[0]) {
return false;
}
// Revive gives at least 1 Hp
if (hp_change == 0) {
ChangeHp(1);
}
} else if (item.ko_only) {
// Must be dead
return false;
}
ChangeHp(hp_change);
SetSp(GetSp() + sp_change);
for (std::vector<bool>::const_iterator it = item.state_set.begin();
it != item.state_set.end(); ++it) {
if (*it) {
RemoveState(*it);
}
}
// TODO
return true;
} else if (item.type == RPG::Item::Type_material) {
// TODO
return false;
}
return false;
}
void Game_Actor::SetSp(int sp) {
data.current_sp = min(max(sp, 0), GetMaxSp());
}
bool Game_Battler::HasFullSp() const {
return GetMaxSp() == GetSp();
}
bool Game_Battler::UseItem(int item_id) {
const RPG::Item* item = ReaderUtil::GetElement(Data::items, item_id);
if (!item) {
Output::Warning("UseItem: Can't use item with invalid ID %d", item_id);
return false;
}
if (item->type == RPG::Item::Type_medicine) {
bool was_used = false;
int hp_change = item->recover_hp_rate * GetMaxHp() / 100 + item->recover_hp;
int sp_change = item->recover_sp_rate * GetMaxSp() / 100 + item->recover_sp;
if (IsDead()) {
// Check if item can revive
if (item->state_set.empty() || !item->state_set[0]) {
return false;
}
// Revive gives at least 1 Hp
if (hp_change == 0) {
ChangeHp(1);
was_used = true;
}
} else if (item->ko_only) {
// Must be dead
return false;
}
if (hp_change > 0 && !HasFullHp()) {
ChangeHp(hp_change);
was_used = true;
}
if (sp_change > 0 && !HasFullSp()) {
ChangeSp(sp_change);
was_used = true;
}
for (int i = 0; i < (int)item->state_set.size(); i++) {
if (item->state_set[i]) {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
return was_used;
}
if (item->type == RPG::Item::Type_switch) {
return true;
}
switch (item->type) {
case RPG::Item::Type_weapon:
case RPG::Item::Type_shield:
case RPG::Item::Type_armor:
case RPG::Item::Type_helmet:
case RPG::Item::Type_accessory:
return item->use_skill && UseSkill(item->skill_id);
case RPG::Item::Type_special:
return UseSkill(item->skill_id);
}
return false;
}
bool Game_Battler::UseItem(int item_id, const Game_Battler* source) {
const RPG::Item* item = ReaderUtil::GetElement(Data::items, item_id);
if (!item) {
Output::Warning("UseItem: Can't use item with invalid ID %d", item_id);
return false;
}
if (item->type == RPG::Item::Type_medicine) {
bool was_used = false;
int revived = 0;
int hp_change = item->recover_hp_rate * GetMaxHp() / 100 + item->recover_hp;
int sp_change = item->recover_sp_rate * GetMaxSp() / 100 + item->recover_sp;
if (IsDead()) {
// Check if item can revive
if (item->state_set.empty() || !item->state_set[0]) {
return false;
}
} else if (item->ko_only) {
// Must be dead
return false;
}
for (int i = 0; i < (int)item->state_set.size(); i++) {
if (item->state_set[i]) {
was_used |= HasState(Data::states[i].ID);
if (i == 0 && HasState(i + 1))
revived = 1;
RemoveState(Data::states[i].ID);
}
}
if (hp_change > 0 && !HasFullHp()) {
ChangeHp(hp_change - revived);
was_used = true;
}
if (sp_change > 0 && !HasFullSp()) {
ChangeSp(sp_change);
was_used = true;
}
return was_used;
}
if (item->type == RPG::Item::Type_switch) {
return true;
}
bool do_skill = (item->type == RPG::Item::Type_special)
|| (item->use_skill && (
item->type == RPG::Item::Type_weapon
|| item->type == RPG::Item::Type_shield
|| item->type == RPG::Item::Type_armor
|| item->type == RPG::Item::Type_helmet
|| item->type == RPG::Item::Type_accessory
)
);
if (do_skill) {
auto* skill = ReaderUtil::GetElement(Data::skills, item->skill_id);
if (skill == nullptr) {
Output::Warning("UseItem: Can't use item %d skill with invalid ID %d", item->ID, item->skill_id);
return false;
}
UseSkill(item->skill_id, source);
}
return false;
}
void Game_Enemy::SetSp(int _sp) {
sp = std::min(std::max(_sp, 0), GetMaxSp());
}