bool Game_Battler::UseSkill(int skill_id) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_id);
if (!skill) {
Output::Warning("UseSkill: Can't use skill with invalid ID %d", skill_id);
return false;
}
bool was_used = false;
if (skill->type == RPG::Skill::Type_normal || skill->type >= RPG::Skill::Type_subskill) {
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill->scope == RPG::Skill::Scope_ally ||
skill->scope == RPG::Skill::Scope_party ||
skill->scope == RPG::Skill::Scope_self)) {
return false;
}
// Skills only increase hp and sp outside of battle
if (skill->power > 0 && skill->affect_hp && !HasFullHp()) {
was_used = true;
ChangeHp(skill->power);
}
if (skill->power > 0 && skill->affect_sp && !HasFullSp()) {
was_used = true;
ChangeSp(skill->power);
}
for (int i = 0; i < (int) skill->state_effects.size(); i++) {
if (skill->state_effects[i]) {
if (skill->state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
} else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
}
} else if (skill->type == RPG::Skill::Type_teleport || skill->type == RPG::Skill::Type_escape) {
was_used = true;
} else if (skill->type == RPG::Skill::Type_switch) {
Game_Switches[skill->switch_id] = true;
was_used = true;
}
return was_used;
}
bool Game_Battler::UseSkill(int skill_id) {
const RPG::Skill& skill = Data::skills[skill_id - 1];
bool was_used = false;
switch (skill.type) {
case RPG::Skill::Type_normal:
case RPG::Skill::Type_subskill:
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill.scope == RPG::Skill::Scope_ally ||
skill.scope == RPG::Skill::Scope_party ||
skill.scope == RPG::Skill::Scope_self)) {
return false;
}
// Skills only increase hp and sp outside of battle
if (skill.power > 0 && skill.affect_hp && !HasFullHp()) {
was_used = true;
ChangeHp(skill.power);
}
if (skill.power > 0 && skill.affect_sp && !HasFullSp()) {
was_used = true;
ChangeSp(skill.power);
}
for (int i = 0; i < (int)skill.state_effects.size(); i++) {
if (skill.state_effects[i]) {
if (skill.state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
} else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
}
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
// ToDo: Show Teleport/Escape target menu
break;
case RPG::Skill::Type_switch:
Game_Switches[skill.switch_id] = true;
return true;
}
return was_used;
}
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::UseSkill(int skill_id, const Game_Battler* source) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_id);
if (!skill) {
Output::Warning("UseSkill: Can't use skill with invalid ID %d", skill_id);
return false;
}
bool cure_hp_percentage = false;
bool was_used = false;
if (skill->type == RPG::Skill::Type_normal || skill->type >= RPG::Skill::Type_subskill) {
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill->scope == RPG::Skill::Scope_ally ||
skill->scope == RPG::Skill::Scope_party ||
skill->scope == RPG::Skill::Scope_self)) {
return false;
}
// Calculate effect:
float mul = GetAttributeMultiplier(skill->attribute_effects);
int effect = skill->power;
if (source != nullptr) {
effect += source->GetAtk() * skill->physical_rate / 20 +
source->GetSpi() * skill->magical_rate / 40;
}
effect *= mul;
effect += (effect * Utils::GetRandomNumber(-skill->variance * 10, skill->variance * 10) / 100);
if (effect < 0)
effect = 0;
// Cure states
for (int i = 0; i < (int)skill->state_effects.size(); i++) {
if (skill->state_effects[i]) {
if (skill->reverse_state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
}
else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
// If Death is cured and HP is not selected, we set a bool so it later heals HP percentage
if (i == 0 && !skill->affect_hp) {
cure_hp_percentage = true;
}
}
}
}
// Skills only increase hp and sp outside of battle
if (effect > 0 && skill->affect_hp && !HasFullHp() && !IsDead()) {
was_used = true;
ChangeHp(effect);
}
else if (effect > 0 && cure_hp_percentage) {
was_used = true;
ChangeHp(GetMaxHp() * effect / 100);
}
if (effect > 0 && skill->affect_sp && !HasFullSp() && !IsDead()) {
was_used = true;
ChangeSp(effect);
}
} else if (skill->type == RPG::Skill::Type_teleport || skill->type == RPG::Skill::Type_escape) {
Game_System::SePlay(skill->sound_effect);
was_used = true;
} else if (skill->type == RPG::Skill::Type_switch) {
Game_System::SePlay(skill->sound_effect);
Game_Switches.Set(skill->switch_id, true);
was_used = true;
}
return was_used;
}
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;
}
