void Scene_Battle::ItemSelected() {
const RPG::Item* item = item_window->GetItem();
skill_item = NULL;
if (!item || !Main_Data::game_party->IsItemUsable(item->ID)) {
Game_System::SePlay(Data::system.buzzer_se);
return;
}
Game_System::SePlay(Data::system.decision_se);
if (item->entire_party) {
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Item>(active_actor, Main_Data::game_party.get(), *item_window->GetItem()));
ActionSelectedCallback(active_actor);
}
else {
if (item->type == RPG::Item::Type_switch) {
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Item>(active_actor, *item_window->GetItem()));
ActionSelectedCallback(active_actor);
}
else if (item->type == RPG::Item::Type_special) {
skill_item = item;
AssignSkill(&Data::skills[item->skill_id - 1]);
}
else {
SetState(State_SelectAllyTarget);
status_window->SetChoiceMode(Window_BattleStatus::ChoiceMode_All);
}
}
}
void Scene_Battle::AssignSkill(const RPG::Skill* skill) {
switch (skill->type) {
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
case RPG::Skill::Type_switch:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
return;
case RPG::Skill::Type_normal:
default:
break;
}
switch (skill->scope) {
case RPG::Skill::Scope_enemy:
SetState(State_SelectEnemyTarget);
break;
case RPG::Skill::Scope_ally:
SetState(State_SelectAllyTarget);
status_window->SetChoiceMode(Window_BattleStatus::ChoiceMode_All);
break;
case RPG::Skill::Scope_enemies:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, Main_Data::game_enemyparty.get(), skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
case RPG::Skill::Scope_self:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, active_actor, skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
case RPG::Skill::Scope_party:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, Main_Data::game_party.get(), skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
}
}
void Scene_Battle::ItemSelected() {
const RPG::Item* item = item_window->GetItem();
skill_item = nullptr;
if (!item || !item_window->CheckEnable(item->ID)) {
Game_System::SePlay(Game_System::GetSystemSE(Game_System::SFX_Buzzer));
return;
}
Game_System::SePlay(Game_System::GetSystemSE(Game_System::SFX_Decision));
switch (item->type) {
case RPG::Item::Type_normal:
case RPG::Item::Type_book:
case RPG::Item::Type_material:
assert(false);
return;
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:
case RPG::Item::Type_special: {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, item->skill_id);
if (!skill) {
Output::Warning("ItemSelected: Item %d references invalid skill %d", item->ID, item->skill_id);
return;
}
skill_item = item;
AssignSkill(skill);
break;
}
case RPG::Item::Type_medicine:
if (item->entire_party) {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Item>(active_actor, Main_Data::game_party.get(), *item_window->GetItem()));
ActionSelectedCallback(active_actor);
} else {
SetState(State_SelectAllyTarget);
status_window->SetChoiceMode(Window_BattleStatus::ChoiceMode_All);
}
break;
case RPG::Item::Type_switch:
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Item>(active_actor, *item_window->GetItem()));
ActionSelectedCallback(active_actor);
break;
}
}
void Scene_Battle::DefendSelected() {
Game_System::SePlay(Game_System::GetSystemSE(Game_System::SFX_Decision));
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Defend>(active_actor));
ActionSelectedCallback(active_actor);
}
void Scene_Battle::DefendSelected() {
Game_System::SePlay(Game_System::GetSystemSE(Game_System::SFX_Decision));
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Defend>(active_actor));
ActionSelectedCallback(active_actor);
}
void Scene_Battle::EnemySelected() {
std::vector<Game_Battler*> enemies;
Main_Data::game_enemyparty->GetActiveBattlers(enemies);
Game_Enemy* target = static_cast<Game_Enemy*>(enemies[target_window->GetIndex()]);
if (previous_state == State_SelectCommand) {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Normal>(active_actor, target));
} else if (previous_state == State_SelectSkill || (previous_state == State_SelectItem && skill_item)) {
if (skill_item) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_item->skill_id);
if (!skill) {
Output::Warning("EnemySelected: Item %d references invalid skill %d", skill_item->ID, skill_item->skill_id);
return;
}
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(active_actor, target, *skill, skill_item));
} else {
active_actor->SetBattleAlgorithm(
std::make_shared<Game_BattleAlgorithm::Skill>(active_actor, target, *skill_window->GetSkill()));
}
} else if (previous_state == State_SelectItem) {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Item>(active_actor, target, *item_window->GetItem()));
} else {
assert("Invalid previous state for enemy selection" && false);
}
for (int i = 0; i < Main_Data::game_enemyparty->GetBattlerCount(); ++i) {
if (&(*Main_Data::game_enemyparty)[i] == target) {
Game_Battle::SetEnemyTargetIndex(i);
}
}
ActionSelectedCallback(active_actor);
}
void Scene_Battle::DefendSelected() {
Game_System::SePlay(Data::system.decision_se);
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Defend>(active_actor));
ActionSelectedCallback(active_actor);
}
void Scene_Battle::AttackSelected() {
Game_System::SePlay(Game_System::GetSystemSE(Game_System::SFX_Decision));
const RPG::Item* item = active_actor->GetEquipment(RPG::Item::Type_weapon);
if (item && item->attack_all) {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Normal>(active_actor, Main_Data::game_enemyparty.get()));
ActionSelectedCallback(active_actor);
} else {
SetState(State_SelectEnemyTarget);
}
}
void Scene_Battle::CreateEnemyActionSkill(Game_Enemy* enemy, const RPG::EnemyAction* action) {
if (action->kind != RPG::EnemyAction::Kind_skill) {
return;
}
const RPG::Skill& skill = Data::skills[action->skill_id - 1];
switch (skill.type) {
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
case RPG::Skill::Type_switch:
//BeginSkill();
return;
case RPG::Skill::Type_normal:
default:
break;
}
switch (skill.scope) {
case RPG::Skill::Scope_enemy:
// ToDo
break;
case RPG::Skill::Scope_ally:
// ToDo
break;
case RPG::Skill::Scope_enemies:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_party.get(), skill));
ActionSelectedCallback(enemy);
break;
case RPG::Skill::Scope_self:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(enemy, enemy, skill));
ActionSelectedCallback(enemy);
break;
case RPG::Skill::Scope_party: {
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_enemyparty.get(), *skill_window->GetSkill()));
ActionSelectedCallback(enemy);
break;
}
}
}
void Scene_Battle::CreateEnemyAction(Game_Enemy* enemy, const RPG::EnemyAction* action) {
switch (action->kind) {
case RPG::EnemyAction::Kind_basic:
CreateEnemyActionBasic(enemy, action);
break;
case RPG::EnemyAction::Kind_skill:
CreateEnemyActionSkill(enemy, action);
break;
case RPG::EnemyAction::Kind_transformation:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Transform>(enemy, action->enemy_id));
ActionSelectedCallback(enemy);
}
}
void Scene_Battle::CreateEnemyActionSkill(Game_Enemy* enemy, const RPG::EnemyAction* action) {
if (action->kind != RPG::EnemyAction::Kind_skill) {
return;
}
RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, action->skill_id);
if (!skill) {
Output::Warning("CreateEnemyAction: Enemy can't use invalid skill %d", action->skill_id);
return;
}
switch (skill->type) {
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
// FIXME: Can enemy use this?
return;
case RPG::Skill::Type_switch:
case RPG::Skill::Type_normal:
case RPG::Skill::Type_subskill:
default:
break;
}
switch (skill->scope) {
case RPG::Skill::Scope_enemy:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_party->GetRandomActiveBattler(), *skill));
break;
case RPG::Skill::Scope_ally:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_enemyparty->GetRandomActiveBattler(), *skill));
break;
case RPG::Skill::Scope_enemies:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_party.get(), *skill));
break;
case RPG::Skill::Scope_self:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(enemy, enemy, *skill));
break;
case RPG::Skill::Scope_party:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(enemy, Main_Data::game_enemyparty.get(), *skill));
break;
}
if (action->switch_on) {
enemy->GetBattleAlgorithm()->SetSwitchEnable(action->switch_on_id);
}
if (action->switch_off) {
enemy->GetBattleAlgorithm()->SetSwitchDisable(action->switch_off_id);
}
ActionSelectedCallback(enemy);
}
void Scene_Battle::AllySelected() {
Game_Actor& target = (*Main_Data::game_party)[status_window->GetIndex()];
switch (previous_state) {
case State_SelectSkill:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, &target, skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
break;
case State_SelectItem:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Item>(active_actor, &target, *item_window->GetItem()));
break;
default:
assert("Invalid previous state for ally selection" && false);
}
ActionSelectedCallback(active_actor);
}
void Scene_Battle::CreateEnemyAction(Game_Enemy* enemy, const RPG::EnemyAction* action) {
switch (action->kind) {
case RPG::EnemyAction::Kind_basic:
CreateEnemyActionBasic(enemy, action);
break;
case RPG::EnemyAction::Kind_skill:
CreateEnemyActionSkill(enemy, action);
break;
case RPG::EnemyAction::Kind_transformation:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Transform>(enemy, action->enemy_id));
if (action->switch_on) {
enemy->GetBattleAlgorithm()->SetSwitchEnable(action->switch_on_id);
}
if (action->switch_off) {
enemy->GetBattleAlgorithm()->SetSwitchEnable(action->switch_off_id);
}
ActionSelectedCallback(enemy);
}
}
void Scene_Battle::CreateEnemyActionBasic(Game_Enemy* enemy, const RPG::EnemyAction* action) {
if (action->kind != RPG::EnemyAction::Kind_basic) {
return;
}
switch (action->basic) {
case RPG::EnemyAction::Basic_attack:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Normal>(enemy, Main_Data::game_party->GetRandomActiveBattler()));
break;
case RPG::EnemyAction::Basic_dual_attack:
// ToDo: Must be NormalDual, not implemented
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Normal>(enemy, Main_Data::game_party->GetRandomActiveBattler()));
break;
case RPG::EnemyAction::Basic_defense:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Defend>(enemy));
break;
case RPG::EnemyAction::Basic_observe:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Observe>(enemy));
break;
case RPG::EnemyAction::Basic_charge:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Charge>(enemy));
break;
case RPG::EnemyAction::Basic_autodestruction:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::SelfDestruct>(enemy, Main_Data::game_party.get()));
break;
case RPG::EnemyAction::Basic_escape:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Escape>(enemy));
break;
case RPG::EnemyAction::Basic_nothing:
enemy->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::NoMove>(enemy));
break;
}
if (action->switch_on) {
enemy->GetBattleAlgorithm()->SetSwitchEnable(action->switch_on_id);
}
if (action->switch_off) {
enemy->GetBattleAlgorithm()->SetSwitchEnable(action->switch_off_id);
}
ActionSelectedCallback(enemy);
}
void Scene_Battle::EnemySelected() {
Game_Enemy* target = static_cast<Game_Enemy*>(Main_Data::game_enemyparty->GetAliveEnemies()[target_window->GetIndex()]);
switch (previous_state) {
case State_SelectCommand:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Normal>(active_actor, target));
break;
case State_SelectSkill:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Skill>(active_actor, target, skill_item ? Data::skills[skill_item->skill_id - 1] : *skill_window->GetSkill(), skill_item));
break;
case State_SelectItem:
active_actor->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Item>(active_actor, target, *item_window->GetItem()));
break;
default:
assert("Invalid previous state for enemy selection" && false);
}
ActionSelectedCallback(active_actor);
}
void Scene_Battle::AllySelected() {
Game_Actor& target = (*Main_Data::game_party)[status_window->GetIndex()];
if (previous_state == State_SelectSkill || (previous_state == State_SelectItem && skill_item)) {
if (skill_item) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_item->skill_id);
if (!skill) {
Output::Warning("AllySelected: Item %d references invalid skill %d", skill_item->ID, skill_item->skill_id);
return;
}
}
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(active_actor, &target,
skill_item ? *ReaderUtil::GetElement(Data::skills, skill_item->skill_id) : *skill_window->GetSkill(), skill_item));
} else if (previous_state == State_SelectItem) {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Item>(active_actor, &target, *item_window->GetItem()));
} else {
assert("Invalid previous state for ally selection" && false);
}
ActionSelectedCallback(active_actor);
}
void Scene_Battle::CreateEnemyActionBasic(Game_Enemy* enemy, const RPG::EnemyAction* action) {
if (action->kind != RPG::EnemyAction::Kind_basic) {
return;
}
switch (action->basic) {
case RPG::EnemyAction::Basic_attack:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Normal>(enemy, Main_Data::game_party->GetRandomAliveBattler()));
break;
case RPG::EnemyAction::Basic_dual_attack:
// ToDo: Must be NormalDual, not implemented
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Normal>(enemy, Main_Data::game_party->GetRandomAliveBattler()));
break;
case RPG::EnemyAction::Basic_defense:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Defend>(enemy));
break;
case RPG::EnemyAction::Basic_observe:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Observe>(enemy));
break;
case RPG::EnemyAction::Basic_charge:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Charge>(enemy));
break;
case RPG::EnemyAction::Basic_autodestruction:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::SelfDestruct>(enemy));
break;
case RPG::EnemyAction::Basic_escape:
enemy->SetBattleAlgorithm(EASYRPG_MAKE_SHARED<Game_BattleAlgorithm::Escape>(enemy));
break;
case RPG::EnemyAction::Basic_nothing:
// no-op
break;
}
if (action->basic != RPG::EnemyAction::Basic_nothing) {
ActionSelectedCallback(enemy);
}
}
void Scene_Battle::AssignSkill(const RPG::Skill* skill) {
switch (skill->type) {
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
case RPG::Skill::Type_switch: {
if (skill_item) {
const RPG::Skill *skill = ReaderUtil::GetElement(Data::skills, skill_item->skill_id);
if (!skill) {
Output::Warning("AssignSkill: Item %d references invalid skill %d", skill_item->ID, skill_item->skill_id);
return;
}
}
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(active_actor, skill_item ? *ReaderUtil::GetElement(Data::skills, skill_item->skill_id) : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
return;
}
case RPG::Skill::Type_normal:
case RPG::Skill::Type_subskill:
default:
break;
}
switch (skill->scope) {
case RPG::Skill::Scope_enemies:
case RPG::Skill::Scope_self:
case RPG::Skill::Scope_party: {
if (skill_item) {
const RPG::Skill *skill = ReaderUtil::GetElement(Data::skills, skill_item->skill_id);
if (!skill) {
Output::Warning("AssignSkill: Item %d references invalid skill %d", skill_item->ID, skill_item->skill_id);
return;
}
}
}
default:
break;
}
switch (skill->scope) {
case RPG::Skill::Scope_enemy:
SetState(State_SelectEnemyTarget);
break;
case RPG::Skill::Scope_ally:
SetState(State_SelectAllyTarget);
status_window->SetChoiceMode(Window_BattleStatus::ChoiceMode_All);
break;
case RPG::Skill::Scope_enemies:
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(
active_actor, Main_Data::game_enemyparty.get(), skill_item ? *ReaderUtil::GetElement(Data::skills, skill_item->skill_id) : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
case RPG::Skill::Scope_self:
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(
active_actor, active_actor, skill_item ? *ReaderUtil::GetElement(Data::skills, skill_item->skill_id) : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
case RPG::Skill::Scope_party:
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Skill>(
active_actor, Main_Data::game_party.get(), skill_item ? *ReaderUtil::GetElement(Data::skills, skill_item->skill_id) : *skill_window->GetSkill(), skill_item));
ActionSelectedCallback(active_actor);
break;
}
}