incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
91e484e514e421b5791e74eae1641b18c7e6be52
psopeeps-newserv/src/Episode3/CardSpecial.cc
T
Martin Michelsen 91e484e514 clang-format everything
2023-04-16 15:44:12 -07:00

4537 lines
161 KiB
C++
Raw Blame History

#include "Server.hh"
#include <math.h>
using namespace std;
namespace Episode3 {
CardSpecial::DiceRoll::DiceRoll() {
this->clear();
}
void CardSpecial::DiceRoll::clear() {
this->client_id = 0;
this->unknown_a2 = 0;
this->value = 0;
this->value_used_in_expr = 0;
this->unknown_a5 = 0xFFFF;
}
CardSpecial::AttackEnvStats::AttackEnvStats() {
this->clear();
}
void CardSpecial::AttackEnvStats::clear() {
this->num_set_cards = 0;
this->dice_roll_value1 = 0;
this->effective_ap = 0;
this->effective_tp = 0;
this->current_hp = 0;
this->max_hp = 0;
this->effective_ap_if_not_tech = 0;
this->effective_ap_if_not_physical = 0;
this->player_num_destroyed_fcs = 0;
this->player_num_atk_points = 0;
this->defined_max_hp = 0;
this->dice_roll_value2 = 0;
this->card_cost = 0;
this->total_num_set_cards = 0;
this->action_cards_ap = 0;
this->action_cards_tp = 0;
this->unknown_a1 = 0;
this->num_item_or_creature_cards_in_hand = 0;
this->num_destroyed_ally_fcs = 0;
this->target_team_num_set_cards = 0;
this->condition_giver_team_num_set_cards = 0;
this->num_native_creatures = 0;
this->num_a_beast_creatures = 0;
this->num_machine_creatures = 0;
this->num_dark_creatures = 0;
this->num_sword_type_items = 0;
this->num_gun_type_items = 0;
this->num_cane_type_items = 0;
this->effective_ap_if_not_tech2 = 0;
this->team_dice_boost = 0;
this->sc_effective_ap = 0;
this->attack_bonus = 0;
this->num_sword_type_items_on_team = 0;
this->target_attack_bonus = 0;
this->last_attack_preliminary_damage = 0;
this->last_attack_damage = 0;
this->total_last_attack_damage = 0;
this->last_attack_damage_count = 0;
this->target_current_hp = 0;
}
uint32_t CardSpecial::AttackEnvStats::at(size_t offset) const {
constexpr size_t count = sizeof(*this) / sizeof(uint32_t);
return reinterpret_cast<const parray<uint32_t, count>*>(this)->at(offset);
}
CardSpecial::CardSpecial(shared_ptr<Server> server)
: w_server(server),
unknown_a2(0) {}
shared_ptr<Server> CardSpecial::server() {
auto s = this->w_server.lock();
if (!s) {
throw runtime_error("server is deleted");
}
return s;
}
shared_ptr<const Server> CardSpecial::server() const {
auto s = this->w_server.lock();
if (!s) {
throw runtime_error("server is deleted");
}
return s;
}
void CardSpecial::adjust_attack_damage_due_to_conditions(
shared_ptr<const Card> target_card, int16_t* inout_damage, uint16_t attacker_card_ref) {
shared_ptr<const Card> attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
auto attack_medium = attacker_card ? attacker_card->action_chain.chain.attack_medium : AttackMedium::UNKNOWN;
for (size_t z = 0; z < 9; z++) {
const auto& cond = target_card->action_chain.conditions[z];
if (cond.type == ConditionType::NONE) {
continue;
}
if (this->card_ref_has_ability_trap(cond)) {
continue;
}
if (!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
cond.card_ref,
target_card->get_card_ref(),
attacker_card_ref,
cond.card_definition_effect_index,
attack_medium)) {
continue;
}
switch (cond.type) {
case ConditionType::WEAK_HIT_BLOCK:
if (*inout_damage <= cond.value) {
*inout_damage = 0;
}
break;
case ConditionType::EXP_DECOY: {
auto target_ps = target_card->player_state();
if (target_ps) {
uint8_t target_team_id = target_ps->get_team_id();
int16_t exp_deduction = this->server()->team_exp[target_team_id];
if (exp_deduction < *inout_damage) {
*inout_damage = *inout_damage - exp_deduction;
this->server()->team_exp[target_team_id] = 0;
} else {
this->server()->team_exp[target_team_id] = exp_deduction - *inout_damage;
exp_deduction = *inout_damage;
*inout_damage = 0;
}
this->send_6xB4x06_for_exp_change(
target_card, attacker_card_ref, -exp_deduction, true);
this->compute_team_dice_boost(target_team_id);
}
break;
}
case ConditionType::UNKNOWN_73:
if (cond.value <= *inout_damage) {
*inout_damage = 0;
}
break;
case ConditionType::HALFGUARD:
if (cond.value <= *inout_damage) {
*inout_damage /= 2;
}
break;
default:
break;
}
}
}
void CardSpecial::adjust_dice_boost_if_team_has_condition_52(
uint8_t team_id, uint8_t* inout_dice_boost, shared_ptr<const Card> card) {
if (!card || (team_id == 0xFF) || !inout_dice_boost || (card->card_flags & 3)) {
return;
}
auto ps = card->player_state();
if (!ps || (ps->get_team_id() != team_id)) {
return;
}
for (size_t z = 0; z < 9; z++) {
if (!this->card_ref_has_ability_trap(card->action_chain.conditions[z]) &&
(card->action_chain.conditions[z].type == ConditionType::UNKNOWN_52)) {
*inout_dice_boost = *inout_dice_boost * card->action_chain.conditions[z].value8;
}
}
}
void CardSpecial::apply_action_conditions(
uint8_t when,
shared_ptr<const Card> attacker_card,
shared_ptr<Card> defender_card,
uint32_t flags,
const ActionState* as) {
ActionState temp_as;
if (attacker_card == defender_card) {
temp_as = this->create_attack_state_from_card_action_chain(attacker_card);
if (as) {
temp_as = *as;
}
} else {
temp_as = this->create_defense_state_for_card_pair_action_chains(
attacker_card, defender_card);
}
this->apply_defense_conditions(temp_as, when, defender_card, flags);
}
bool CardSpecial::apply_attribute_guard_if_possible(
uint32_t flags,
CardClass card_class,
shared_ptr<Card> card,
uint16_t condition_giver_card_ref,
uint16_t attacker_card_ref) {
shared_ptr<const Card> condition_giver_card = this->server()->card_for_set_card_ref(condition_giver_card_ref);
if (condition_giver_card) {
auto ce = condition_giver_card->get_definition();
if (ce && (ce->def.card_class() == card_class)) {
if (flags & 2) {
card->action_chain.reset();
}
if (flags & 0x10) {
card->action_metadata.defense_power = 99;
card->action_metadata.defense_bonus = 0;
}
}
}
shared_ptr<const Card> attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
if (attacker_card) {
auto ce = attacker_card->get_definition();
if (ce && (ce->def.card_class() == card_class) && (flags & 0x10)) {
card->action_metadata.defense_power = 99;
card->action_metadata.defense_bonus = 0;
}
}
return true;
}
bool CardSpecial::apply_defense_condition(
uint8_t when,
Condition* defender_cond,
uint8_t cond_index,
const ActionState& defense_state,
shared_ptr<Card> defender_card,
uint32_t flags,
bool unknown_p8) {
if (defender_cond->type == ConditionType::NONE) {
return false;
}
auto orig_eff = this->original_definition_for_condition(*defender_cond);
uint16_t attacker_card_ref = defense_state.attacker_card_ref;
if (attacker_card_ref == 0xFFFF) {
attacker_card_ref = defense_state.original_attacker_card_ref;
}
bool defender_has_ability_trap = this->card_ref_has_ability_trap(*defender_cond);
if (!(flags & 4) ||
this->is_card_targeted_by_condition(*defender_cond, defense_state, defender_card)) {
if ((when == 2) && (defender_cond->type == ConditionType::GUOM) && (flags & 4)) {
CardShortStatus stat = defender_card->get_short_status();
if (stat.card_flags & 4) {
this->server()->base()->log.debug("(when=2) @%04hX clearing GUOM from @%04hX",
attacker_card_ref, defender_card->get_card_ref());
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 0x0E);
cmd.effect.target_card_ref = defender_card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = -static_cast<int8_t>(defender_cond->type);
cmd.effect.condition_index = cond_index;
this->server()->send(cmd);
this->apply_stat_deltas_to_card_from_condition_and_clear_cond(
*defender_cond, defender_card);
defender_card->send_6xB4x4E_4C_4D_if_needed();
return false;
}
}
if ((when == 4) && (flags & 4) && !defender_has_ability_trap &&
(defender_cond->type == ConditionType::ACID)) {
int16_t hp = defender_card->get_current_hp();
if (hp > 0) {
this->server()->base()->log.debug("(when=2) @%04hX has ACID; removing 1 HP",
defender_cond->card_ref.load());
this->send_6xB4x06_for_stat_delta(
defender_card, defender_cond->card_ref, 0x20, -1, 0, 1);
defender_card->set_current_hp(hp - 1);
this->destroy_card_if_hp_zero(defender_card, defender_cond->condition_giver_card_ref);
}
}
if (!orig_eff || (orig_eff->when != when)) {
flags = flags & 0xFFFFFFFB;
}
if ((flags == 0) || defender_has_ability_trap) {
return false;
}
DiceRoll dice_roll;
dice_roll.client_id = defender_card->get_client_id();
dice_roll.unknown_a2 = 3;
dice_roll.value = defender_cond->dice_roll_value;
dice_roll.value_used_in_expr = false;
uint8_t original_cond_flags = defender_cond->flags;
auto astats = this->compute_attack_env_stats(
defense_state, defender_card, dice_roll, defender_cond->card_ref,
defender_cond->condition_giver_card_ref);
string expr = orig_eff->expr;
int16_t expr_value = this->evaluate_effect_expr(astats, expr.c_str(), dice_roll);
this->execute_effect(
*defender_cond, defender_card, expr_value, defender_cond->value,
orig_eff->type, flags, attacker_card_ref);
if (flags & 4) {
if (!(defender_card->card_flags & 2)) {
defender_card->compute_action_chain_results(true, false);
}
defender_card->action_chain.chain.card_ap = defender_card->ap;
defender_card->action_chain.chain.card_tp = defender_card->tp;
defender_card->send_6xB4x4E_4C_4D_if_needed();
}
if (dice_roll.value_used_in_expr && !(original_cond_flags & 1) && !unknown_p8) {
defender_cond->flags |= 1;
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x08;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 0x10);
cmd.effect.target_card_ref = defender_cond->card_ref;
cmd.effect.dice_roll_value = dice_roll.value;
this->server()->send(cmd);
}
return true;
} else {
if (defender_cond->type != ConditionType::NONE) {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 0x0D);
cmd.effect.target_card_ref = defender_card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = -static_cast<int8_t>(defender_cond->type);
this->server()->send(cmd);
}
this->apply_stat_deltas_to_card_from_condition_and_clear_cond(
*defender_cond, defender_card);
defender_card->send_6xB4x4E_4C_4D_if_needed();
return false;
}
}
bool CardSpecial::apply_defense_conditions(
const ActionState& as,
uint8_t when,
shared_ptr<Card> defender_card,
uint32_t flags) {
for (size_t z = 0; z < 9; z++) {
this->apply_defense_condition(
when, &defender_card->action_chain.conditions[z], z, as, defender_card, flags, 0);
}
return true;
}
bool CardSpecial::apply_stat_deltas_to_all_cards_from_all_conditions_with_card_ref(
uint16_t card_ref) {
bool ret = false;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
continue;
}
auto sc_card = ps->get_sc_card();
if (sc_card) {
ret |= this->apply_stats_deltas_to_card_from_all_conditions_with_card_ref(
card_ref, sc_card);
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto set_card = ps->get_set_card(set_index);
if (set_card) {
ret |= this->apply_stats_deltas_to_card_from_all_conditions_with_card_ref(
card_ref, set_card);
}
}
}
return ret;
}
bool CardSpecial::apply_stat_deltas_to_card_from_condition_and_clear_cond(
Condition& cond, shared_ptr<Card> card) {
ConditionType cond_type = cond.type;
int16_t cond_value = clamp<int16_t>(cond.value, -99, 99);
uint8_t cond_flags = cond.flags;
uint16_t cond_card_ref = card->get_card_ref();
cond.clear();
switch (cond_type) {
case ConditionType::UNKNOWN_0C:
if (cond_flags & 2) {
int16_t ap = clamp<int16_t>(card->ap, -99, 99);
int16_t tp = clamp<int16_t>(card->tp, -99, 99);
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, tp - ap, 0, 0);
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, ap - tp, 0, 0);
card->ap = tp;
card->tp = ap;
}
break;
case ConditionType::A_H_SWAP:
if (cond_flags & 2) {
int16_t ap = clamp<int16_t>(card->ap, -99, 99);
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
if (hp != ap) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, hp - ap, 0, 0);
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x20, ap - hp, 0, 0);
card->set_current_hp(ap, 1, 1);
card->ap = hp;
this->destroy_card_if_hp_zero(card, cond_card_ref);
}
}
break;
case ConditionType::AP_OVERRIDE:
if (cond_flags & 2) {
// Note: The original code calls a function here that returns a
// Condition pointer; however, the called function searches the card's
// condition list and then ignores the result and unconditionally
// returns null, completely obviating the non-null case here. We
// implement the non-null case for documentation purposes, but it
// appears to be completely dead code. It's unclear if this is a legit
// bug in the original code, or if it was a debug feature or
// late-development intentional change.
Condition* other_cond = nullptr; // return_null???(card, ConditionType::AP_OVERRIDE);
if (!other_cond) {
this->send_6xB4x06_for_stat_delta(
card, cond_card_ref, 0xA0, -cond_value, 0, 0);
card->ap = max<int16_t>(card->ap - cond_value, 0);
} else {
other_cond->value = clamp<int16_t>(other_cond->value + cond_value, -99, 99);
}
}
break;
case ConditionType::TP_OVERRIDE:
if (cond_flags & 2) {
// Like AP_OVERRIDE above, the non-null case here is dead code in the
// original code as well.
Condition* other_cond = nullptr; // return_null???(card, ConditionType::TP_OVERRIDE)
if (!other_cond) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, -cond_value, 0, 0);
card->tp = max<int16_t>(card->tp - cond_value, 0);
} else {
other_cond->value = clamp<int16_t>(other_cond->value + cond_value, -99, 99);
}
}
break;
case ConditionType::MISC_AP_BONUSES:
if (cond_flags & 2) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, -cond_value, 0, 0);
card->ap = max<int16_t>(card->ap - cond_value, 0);
}
break;
case ConditionType::MISC_TP_BONUSES:
if (cond_flags & 2) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, -cond_value, 0, 0);
card->tp = max<int16_t>(card->tp - cond_value, 0);
}
break;
case ConditionType::AP_SILENCE:
if (cond_flags & 2) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, cond_value, 0, 0);
card->ap = max<int16_t>(card->ap + cond_value, 0);
}
break;
case ConditionType::TP_SILENCE:
if (cond_flags & 2) {
this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, cond_value, 0, 0);
card->tp = max<int16_t>(card->tp + cond_value, 0);
}
break;
default:
break;
}
return true;
}
bool CardSpecial::apply_stats_deltas_to_card_from_all_conditions_with_card_ref(
uint16_t card_ref, shared_ptr<Card> card) {
bool ret = false;
for (ssize_t z = 8; z >= 0; z--) {
auto& cond = card->action_chain.conditions[z];
if ((cond.type != ConditionType::NONE) && (cond.card_ref == card_ref)) {
ret |= this->apply_stat_deltas_to_card_from_condition_and_clear_cond(
cond, card);
}
}
return ret;
}
bool CardSpecial::card_has_condition_with_ref(
shared_ptr<const Card> card,
ConditionType cond_type,
uint16_t card_ref,
uint16_t match_card_ref) const {
size_t z = 0;
while ((z < 9) &&
((card->action_chain.conditions[z].type != cond_type) ||
(card->action_chain.conditions[z].card_ref == card_ref))) {
z++;
}
if (z >= 9) {
return false;
}
return (match_card_ref != 0xFFFF) ? (card_ref == match_card_ref) : true;
}
bool CardSpecial::card_is_destroyed(shared_ptr<const Card> card) const {
if (card->card_flags & 3) {
return true;
}
if (card->get_current_hp() > 0) {
return false;
}
return !this->server()->ruler_server->card_ref_or_any_set_card_has_condition_46(
card->get_card_ref());
}
void CardSpecial::compute_attack_ap(
shared_ptr<const Card> target_card,
int16_t* out_value,
uint16_t attacker_card_ref) {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
AttackMedium attacker_sc_attack_medium = attacker_card
? attacker_card->action_chain.chain.attack_medium
: AttackMedium::UNKNOWN;
uint16_t target_card_ref = target_card->get_card_ref();
auto check_card = [&](shared_ptr<Card> card) -> void {
if (!card || (card->card_flags & 3)) {
return;
}
for (size_t cond_index = 0; cond_index < 9; cond_index++) {
auto& cond = card->action_chain.conditions[cond_index];
if (cond.type == ConditionType::NONE ||
this->card_ref_has_ability_trap(cond) ||
!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
card->action_chain.conditions[cond_index].card_ref,
target_card->get_card_ref(),
attacker_card_ref,
card->action_chain.conditions[cond_index].card_definition_effect_index,
attacker_sc_attack_medium)) {
continue;
}
auto cond_type = card->action_chain.conditions[cond_index].type;
if (((cond_type == ConditionType::UNKNOWN_5F) &&
(target_card_ref == card->action_chain.conditions[cond_index].condition_giver_card_ref)) ||
((cond_type == ConditionType::UNKNOWN_60) &&
(target_card_ref == card->action_chain.conditions[cond_index].card_ref))) {
*out_value = card->action_chain.conditions[cond_index].value8;
}
}
};
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t set_index = 0; set_index < 8; set_index++) {
check_card(ps->get_set_card(set_index));
}
check_card(ps->get_sc_card());
}
}
if (attacker_card &&
attacker_card->get_attack_condition_value(ConditionType::UNKNOWN_7D, 0xFFFF, 0xFF, 0xFFFF, nullptr)) {
*out_value = *out_value * 1.5f;
}
if (target_card &&
target_card->get_attack_condition_value(ConditionType::UNKNOWN_7D, 0xFFFF, 0xFF, 0xFFFF, nullptr)) {
*out_value = 0;
}
}
CardSpecial::AttackEnvStats CardSpecial::compute_attack_env_stats(
const ActionState& pa,
shared_ptr<const Card> card,
const DiceRoll& dice_roll,
uint16_t target_card_ref,
uint16_t condition_giver_card_ref) {
this->action_state = pa;
auto attacker_card = this->server()->card_for_set_card_ref(pa.attacker_card_ref);
if (!attacker_card && (pa.original_attacker_card_ref != 0xFFFF)) {
attacker_card = this->server()->card_for_set_card_ref(pa.original_attacker_card_ref);
}
AttackEnvStats ast;
auto ps = card->player_state();
ast.num_set_cards = ps->count_set_cards();
auto condition_giver_card = this->server()->card_for_set_card_ref(condition_giver_card_ref);
auto target_card = this->server()->card_for_set_card_ref(target_card_ref);
if (!target_card) {
target_card = condition_giver_card;
}
size_t ps_num_set_cards = 0;
for (size_t z = 0; z < 4; z++) {
auto other_ps = this->server()->get_player_state(z);
if (other_ps) {
ps_num_set_cards += other_ps->count_set_cards();
}
}
ast.total_num_set_cards = ps_num_set_cards;
uint8_t target_card_team_id = target_card
? target_card->player_state()->get_team_id()
: 0xFF;
size_t target_team_num_set_cards = 0;
size_t condition_giver_team_num_set_cards = 0;
for (size_t z = 0; z < 4; z++) {
auto other_ps = this->server()->get_player_state(z);
if (other_ps) {
if (target_card_team_id == other_ps->get_team_id()) {
target_team_num_set_cards += other_ps->count_set_cards();
} else {
condition_giver_team_num_set_cards += other_ps->count_set_cards();
}
}
}
ast.target_team_num_set_cards = target_team_num_set_cards;
ast.condition_giver_team_num_set_cards = condition_giver_team_num_set_cards;
ast.num_native_creatures = this->get_all_set_cards_by_team_and_class(
CardClass::NATIVE_CREATURE, 0xFF, true)
.size();
ast.num_a_beast_creatures = this->get_all_set_cards_by_team_and_class(
CardClass::A_BEAST_CREATURE, 0xFF, true)
.size();
ast.num_machine_creatures = this->get_all_set_cards_by_team_and_class(
CardClass::MACHINE_CREATURE, 0xFF, true)
.size();
ast.num_dark_creatures = this->get_all_set_cards_by_team_and_class(
CardClass::DARK_CREATURE, 0xFF, true)
.size();
ast.num_sword_type_items = this->get_all_set_cards_by_team_and_class(
CardClass::SWORD_ITEM, 0xFF, true)
.size();
ast.num_gun_type_items = this->get_all_set_cards_by_team_and_class(
CardClass::GUN_ITEM, 0xFF, true)
.size();
ast.num_cane_type_items = this->get_all_set_cards_by_team_and_class(
CardClass::CANE_ITEM, 0xFF, true)
.size();
ast.num_sword_type_items_on_team = card
? this->get_all_set_cards_by_team_and_class(CardClass::SWORD_ITEM, card->get_team_id(), true).size()
: 0;
size_t num_item_or_creature_cards_in_hand = 0;
for (size_t z = 0; z < 6; z++) {
uint16_t card_ref = ps->card_ref_for_hand_index(z);
if (card_ref == 0xFFFF) {
continue;
}
auto ce = this->server()->definition_for_card_id(card_ref);
if (ce && ((ce->def.type == CardType::ITEM) || (ce->def.type == CardType::CREATURE))) {
num_item_or_creature_cards_in_hand++;
}
}
ast.num_item_or_creature_cards_in_hand = num_item_or_creature_cards_in_hand;
ast.num_destroyed_ally_fcs = card->num_destroyed_ally_fcs;
// Note: The original implementation has dice_roll as optional, but since it's
// provided at all callsites, we require it (and hence don't check for nullptr
// here)
ast.dice_roll_value1 = dice_roll.value;
ast.dice_roll_value2 = dice_roll.value;
ast.effective_ap = card->action_chain.chain.effective_ap;
ast.effective_tp = card->action_chain.chain.effective_tp;
ast.current_hp = card->get_current_hp();
ast.max_hp = card->get_max_hp();
ast.team_dice_boost = card ? this->server()->team_dice_boost[card->get_team_id()] : 0;
ast.effective_ap_if_not_tech = (!attacker_card || (attacker_card->action_chain.chain.attack_medium == AttackMedium::TECH))
? 0
: attacker_card->action_chain.chain.damage;
ast.effective_ap_if_not_tech2 = (!attacker_card || (attacker_card->action_chain.chain.attack_medium == AttackMedium::TECH))
? 0
: attacker_card->action_chain.chain.damage;
ast.effective_ap_if_not_physical = (!attacker_card || (attacker_card->action_chain.chain.attack_medium == AttackMedium::PHYSICAL))
? 0
: attacker_card->action_chain.chain.damage;
ast.sc_effective_ap = attacker_card ? attacker_card->action_chain.chain.damage : 0;
ast.attack_bonus = card->action_metadata.attack_bonus;
ast.last_attack_preliminary_damage = card->last_attack_preliminary_damage;
ast.last_attack_damage = card->last_attack_final_damage;
int32_t total_last_attack_damage;
size_t last_attack_damage_count;
this->sum_last_attack_damage(nullptr, &total_last_attack_damage, &last_attack_damage_count);
ast.total_last_attack_damage = total_last_attack_damage;
ast.last_attack_damage_count = last_attack_damage_count;
if (!target_card) {
ast.target_attack_bonus = 0;
ast.target_current_hp = 0;
} else {
ast.target_attack_bonus = target_card->action_metadata.attack_bonus;
ast.target_current_hp = target_card->get_current_hp();
}
ast.player_num_destroyed_fcs = ps->num_destroyed_fcs;
ast.player_num_atk_points = ps->get_atk_points();
auto ce = card->get_definition();
ast.card_cost = ce->def.self_cost;
ast.defined_max_hp = ast.max_hp;
size_t z;
// Note: The (z < 9) conditions in these two loops are not present in the
// original code.
for (z = 0;
((target_card_ref != pa.attacker_card_ref) && (z < 9) && (pa.action_card_refs[z] != 0xFFFF));
z++) {
}
ast.action_cards_ap = 0;
ast.action_cards_tp = 0;
for (; (z < 9) && (pa.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_a2 = pa.action_card_refs[z];
auto ce = this->server()->definition_for_card_ref(pa.action_card_refs[z]);
if (ce) {
if (ce->def.ap.type != CardDefinition::Stat::Type::MINUS_STAT) {
ast.action_cards_ap += ce->def.ap.stat;
}
if (ce->def.tp.type != CardDefinition::Stat::Type::MINUS_STAT) {
ast.action_cards_tp += ce->def.tp.stat;
}
}
}
return ast;
}
shared_ptr<Card> CardSpecial::compute_replaced_target_based_on_conditions(
uint16_t target_card_ref,
int unknown_p3,
int unknown_p4,
uint16_t attacker_card_ref,
uint16_t set_card_ref,
int unknown_p7,
uint32_t* unknown_p9,
uint8_t def_effect_index,
uint32_t* unknown_p11,
uint16_t sc_card_ref) {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
auto target_card = this->server()->card_for_set_card_ref(target_card_ref);
uint8_t target_client_id = client_id_for_card_ref(target_card_ref);
uint8_t target_team_id = 0xFF;
if (unknown_p9) {
*unknown_p9 = 0;
}
if (target_card) {
target_team_id = target_card->get_team_id();
}
if (unknown_p11) {
*unknown_p11 = 0;
}
Location target_card_loc;
if (!target_card) {
target_card_loc.x = 0;
target_card_loc.y = 0;
target_card_loc.direction = Direction::RIGHT;
} else {
this->get_card1_loc_with_card2_opposite_direction(
&target_card_loc, target_card, attacker_card);
}
auto attack_medium = attacker_card ? attacker_card->action_chain.chain.attack_medium : AttackMedium::INVALID_FF;
if ((this->server()->get_battle_phase() != BattlePhase::ACTION) ||
(this->server()->get_current_action_subphase() == ActionSubphase::ATTACK)) {
return nullptr;
}
if (target_card_ref == attacker_card_ref) {
return nullptr;
}
if (target_card_ref == set_card_ref) {
return nullptr;
}
bool has_pierce = ((target_client_id != 0xFF) &&
attacker_card &&
(attacker_card->action_chain.check_flag(0x00002000 << target_client_id)));
// Handle Parry if present
if (target_card && !(target_card->card_flags & 3)) {
for (size_t x = 0; x < 9; x++) {
auto& cond = target_card->action_chain.conditions[x];
if ((unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) {
continue;
}
if (cond.type == ConditionType::NONE) {
continue;
}
if (!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
target_card->action_chain.conditions[x].card_ref,
target_card->get_card_ref(),
attacker_card_ref,
target_card->action_chain.conditions[x].card_definition_effect_index,
attack_medium)) {
continue;
}
if (target_card->action_chain.conditions[x].type != ConditionType::PARRY) {
continue;
}
auto target_ps = target_card->player_state();
if (has_pierce || (unknown_p7 != 0) || !target_ps) {
continue;
}
// Parry forwards the attack to a random FC within one tile of the
// original target. Note that Sega's implementation (used here) hardcodes
// the Gifoie card's ID (00D9) for compute_effective_range.
// TODO: We should fix this so it doesn't rely on a fixed card definition.
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, 0x00D9, target_card_loc, this->server()->base()->map_and_rules1);
auto card_refs_in_parry_range = target_ps->get_all_cards_within_range(
range, target_card_loc, 0xFF);
// Filter out the attacker card ref, the set card ref, the original
// target, and any SCs within the range
vector<uint16_t> candidate_card_refs;
for (uint16_t card_ref : card_refs_in_parry_range) {
if (attacker_card_ref == card_ref) {
continue;
}
if (set_card_ref == card_ref) {
continue;
}
if (target_card_ref == card_ref) {
continue;
}
auto ce = this->server()->definition_for_card_ref(card_ref);
if (ce && ((ce->def.type == CardType::HUNTERS_SC) || (ce->def.type == CardType::ARKZ_SC))) {
continue;
}
candidate_card_refs.emplace_back(card_ref);
}
size_t num_candidates = candidate_card_refs.size();
if (num_candidates > 0) {
uint8_t a = target_ps->roll_dice_with_effects(2);
uint8_t b = target_ps->roll_dice_with_effects(1);
return this->server()->card_for_set_card_ref(
candidate_card_refs[(a + b) - ((a + b) / num_candidates) * num_candidates]);
}
}
}
// Note: Some vestigial functionality was removed here. The original code has
// a parallel array of booleans that seem to specify a priority: if any of the
// candidate cards has true in the priority array, then the first candidate
// card with a true value is returned instead of a random entry from the
// entire array. The original code only puts false values into the priority
// array, effectively rendering it unused, so we've omitted it entirely.
vector<shared_ptr<Card>> candidate_cards;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto other_ps = this->server()->get_player_state(client_id);
if (!other_ps) {
continue;
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto other_set_card = other_ps->get_set_card(set_index);
if (!other_set_card || (other_set_card->card_flags & 3)) {
continue;
}
for (size_t z = 0; (z < 9) && (candidate_cards.size() < 36); z++) {
auto& cond = other_set_card->action_chain.conditions[z];
if ((unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) {
continue;
}
if (cond.type == ConditionType::NONE) {
continue;
}
if (!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
other_set_card->action_chain.conditions[z].card_ref,
other_set_card->get_card_ref(),
attacker_card_ref,
other_set_card->action_chain.conditions[z].card_definition_effect_index,
attack_medium)) {
continue;
}
switch (other_set_card->action_chain.conditions[z].type) {
case ConditionType::GUARD_CREATURE:
if (!has_pierce &&
(unknown_p7 != 0) &&
((unknown_p3 != 0) || (unknown_p4 != 0)) &&
(target_client_id == client_id) &&
target_card &&
target_card->get_definition()->def.is_sc()) {
candidate_cards.emplace_back(other_set_card);
}
break;
case ConditionType::DEFENDER:
if (!has_pierce &&
(unknown_p7 == 0) &&
(unknown_p4 != 0) &&
(target_card_ref == other_set_card->action_chain.conditions[z].condition_giver_card_ref)) {
candidate_cards.emplace_back(other_set_card);
if (unknown_p11 && (def_effect_index != 0xFF) && (set_card_ref != 0xFFFF) &&
!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
set_card_ref, sc_card_ref, other_set_card->get_card_ref(), def_effect_index, attack_medium)) {
*unknown_p11 = 1;
}
}
break;
case ConditionType::UNKNOWN_39:
if (!has_pierce &&
(unknown_p7 == 0) &&
(unknown_p3 != 0) &&
(target_card_ref == other_set_card->action_chain.conditions[z].condition_giver_card_ref)) {
candidate_cards.emplace_back(other_set_card);
}
break;
case ConditionType::SURVIVAL_DECOYS:
if (!has_pierce &&
(unknown_p7 == 0) &&
attacker_card &&
(attacker_card->action_chain.chain.target_card_ref_count > 1) &&
(unknown_p3 != 0) &&
(other_set_card->get_team_id() == target_team_id)) {
candidate_cards.emplace_back(other_set_card);
}
break;
case ConditionType::REFLECT:
if ((unknown_p7 == 0) && (unknown_p3 != 0)) {
if (target_card_ref == other_set_card->action_chain.conditions[z].condition_giver_card_ref) {
if (unknown_p9) {
*unknown_p9 = 0;
}
return other_set_card;
} else if (unknown_p9) {
*unknown_p9 = 1;
}
}
break;
default:
break;
}
}
}
auto other_sc = other_ps->get_sc_card();
if (other_sc && !(other_sc->card_flags & 3)) {
for (size_t z = 0; (z < 9) && (candidate_cards.size() < 36); z++) {
auto& cond = other_sc->action_chain.conditions[z];
if ((unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) {
continue;
}
if (cond.type == ConditionType::NONE) {
continue;
}
if (!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
cond.card_ref,
other_sc->get_card_ref(),
attacker_card_ref,
cond.card_definition_effect_index,
attack_medium)) {
continue;
}
switch (cond.type) {
case ConditionType::GUARD_CREATURE:
if (!has_pierce &&
(unknown_p7 != 0) &&
((unknown_p3 != 0) || (unknown_p4 != 0)) &&
(target_client_id == client_id) &&
target_card &&
target_card->get_definition()->def.is_sc()) {
candidate_cards.emplace_back(other_sc);
}
break;
case ConditionType::DEFENDER:
if (!has_pierce &&
(unknown_p7 == 0) &&
(unknown_p4 != 0) &&
(target_card_ref == cond.condition_giver_card_ref)) {
candidate_cards.emplace_back(other_sc);
if (unknown_p11 && (def_effect_index != 0xFF) && (set_card_ref != 0xFFFF) &&
!this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
set_card_ref, sc_card_ref, other_sc->get_card_ref(), def_effect_index, attack_medium)) {
*unknown_p11 = 1;
}
}
break;
case ConditionType::UNKNOWN_39:
if (!has_pierce &&
(unknown_p7 == 0) &&
(unknown_p3 != 0) &&
(target_card_ref == cond.condition_giver_card_ref)) {
candidate_cards.emplace_back(other_sc);
}
break;
case ConditionType::SURVIVAL_DECOYS:
if (!has_pierce &&
(unknown_p7 == 0) &&
attacker_card &&
(attacker_card->action_chain.chain.target_card_ref_count > 1) &&
(unknown_p3 != 0) &&
(other_sc->get_team_id() == target_team_id)) {
candidate_cards.emplace_back(other_sc);
}
break;
case ConditionType::REFLECT:
if ((unknown_p7 == 0) && (unknown_p3 != 0)) {
if (target_card_ref == cond.condition_giver_card_ref) {
if (unknown_p9) {
*unknown_p9 = 0;
}
return other_sc;
} else if (unknown_p9) {
*unknown_p9 = 1;
}
}
break;
default:
break;
}
}
}
}
if (candidate_cards.empty()) {
return nullptr;
}
// If the set card is a candidate (or the attacker is, if there's no set
// card), don't redirect the attack at all
for (size_t z = 0; z < candidate_cards.size(); z++) {
auto candidate_card = candidate_cards[z];
uint16_t candidate_card_ref = candidate_card->get_card_ref();
if ((set_card_ref == candidate_card_ref) ||
((set_card_ref == 0xFFFF) && (attacker_card_ref == candidate_card_ref))) {
return nullptr;
}
}
if (candidate_cards.size() == 1) {
return candidate_cards[0];
}
uint8_t index = 0;
auto target_ps = target_card->player_state();
if (target_ps && (unknown_p7 == 0)) {
uint8_t a = target_ps->roll_dice_with_effects(2);
uint8_t b = target_ps->roll_dice_with_effects(1);
index = (a + b) - ((a + b) / candidate_cards.size()) * candidate_cards.size();
}
return candidate_cards[index];
}
StatSwapType CardSpecial::compute_stat_swap_type(shared_ptr<const Card> card) const {
if (!card) {
return StatSwapType::NONE;
}
StatSwapType ret = StatSwapType::NONE;
for (size_t cond_index = 0; cond_index < 9; cond_index++) {
auto& cond = card->action_chain.conditions[cond_index];
if (cond.type != ConditionType::NONE) {
if (!this->card_ref_has_ability_trap(cond)) {
if (cond.type == ConditionType::UNKNOWN_75) {
if (ret == StatSwapType::A_H_SWAP) {
ret = StatSwapType::NONE;
} else {
ret = StatSwapType::A_H_SWAP;
}
} else if (cond.type == ConditionType::A_T_SWAP) {
if (ret == StatSwapType::A_T_SWAP) {
ret = StatSwapType::NONE;
} else {
ret = StatSwapType::A_T_SWAP;
}
}
}
}
}
return ret;
}
void CardSpecial::compute_team_dice_boost(uint8_t team_id) {
uint8_t value = this->server()->team_exp[team_id] / (this->server()->team_client_count[team_id] * 12);
this->adjust_dice_boost_if_team_has_condition_52(team_id, &value, 0);
this->server()->team_dice_boost[team_id] = min<uint8_t>(value, 8);
}
bool CardSpecial::condition_has_when_20_or_21(const Condition& cond) const {
auto ce = this->server()->definition_for_card_ref(cond.card_ref);
if (!ce) {
return false;
}
uint8_t when = ce->def.effects[cond.card_definition_effect_index].when;
return ((when == 0x20) || (when == 0x21));
}
size_t CardSpecial::count_action_cards_with_condition_for_all_current_attacks(
ConditionType cond_type, uint16_t card_ref) const {
size_t ret = 0;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
ret += this->count_action_cards_with_condition_for_current_attack(
ps->get_sc_card(), cond_type, card_ref);
for (size_t set_index = 0; set_index < 8; set_index++) {
ret += this->count_action_cards_with_condition_for_current_attack(
ps->get_set_card(set_index), cond_type, card_ref);
}
}
}
return ret;
}
size_t CardSpecial::count_action_cards_with_condition_for_current_attack(
shared_ptr<const Card> card, ConditionType cond_type, uint16_t card_ref) const {
if (!card) {
return 0;
}
size_t ret = 0;
auto check_card_ref = [&](uint16_t other_card_ref) {
if (other_card_ref == card_ref) {
return;
}
auto ce = this->server()->definition_for_card_ref(other_card_ref);
if (!ce) {
return;
}
for (size_t cond_index = 0; cond_index < 3; cond_index++) {
if (ce->def.effects[cond_index].type == ConditionType::NONE) {
break;
}
if (ce->def.effects[cond_index].type == cond_type) {
ret++;
break;
}
}
};
for (size_t z = 0; z < card->action_chain.chain.attack_action_card_ref_count; z++) {
check_card_ref(card->action_chain.chain.attack_action_card_refs[z]);
}
for (size_t z = 0; z < card->action_metadata.defense_card_ref_count; z++) {
check_card_ref(card->action_metadata.defense_card_refs[z]);
}
return ret;
}
size_t CardSpecial::count_cards_with_card_id_set_by_player_except_card_ref(
uint16_t card_id, uint16_t card_ref) const {
size_t ret = 0;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
continue;
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card &&
(card->get_card_ref() != card_ref) &&
(card->get_definition()->def.card_id == card_id)) {
ret++;
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::get_all_set_cards_by_team_and_class(
CardClass card_class, uint8_t team_id, bool exclude_destroyed_cards) const {
vector<shared_ptr<const Card>> ret;
auto check_card = [&](shared_ptr<const Card> card) -> void {
if (card &&
(!exclude_destroyed_cards || !(card->card_flags & 2)) &&
(card->get_definition()->def.card_class() == card_class) &&
((team_id == 0xFF) || (card->get_team_id() == team_id))) {
ret.emplace_back(card);
}
};
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
continue;
}
check_card(ps->get_sc_card());
for (size_t set_index = 0; set_index < 8; set_index++) {
check_card(ps->get_set_card(set_index));
}
}
return ret;
}
ActionState CardSpecial::create_attack_state_from_card_action_chain(
shared_ptr<const Card> attacker_card) const {
ActionState ret;
if (attacker_card) {
ret.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(
attacker_card->get_card_ref(), 4);
for (size_t z = 0; z < attacker_card->action_chain.chain.attack_action_card_ref_count; z++) {
ret.action_card_refs[z] = this->send_6xB4x06_if_card_ref_invalid(
attacker_card->action_chain.chain.attack_action_card_refs[z], 5);
}
for (size_t z = 0; z < attacker_card->action_chain.chain.target_card_ref_count; z++) {
ret.target_card_refs[z] = this->send_6xB4x06_if_card_ref_invalid(
attacker_card->action_chain.chain.target_card_refs[z], 6);
}
}
return ret;
}
ActionState CardSpecial::create_defense_state_for_card_pair_action_chains(
shared_ptr<const Card> attacker_card,
shared_ptr<const Card> defender_card) const {
ActionState ret;
if (defender_card && attacker_card) {
size_t count = 0;
for (size_t z = 0; z < defender_card->action_metadata.defense_card_ref_count; z++) {
if ((defender_card->action_metadata.defense_card_refs[z] != 0xFFFF) &&
(defender_card->action_metadata.original_attacker_card_refs[z] == attacker_card->get_card_ref())) {
ret.action_card_refs[count++] = this->send_6xB4x06_if_card_ref_invalid(
defender_card->action_metadata.defense_card_refs[z], 7);
}
}
}
if (defender_card) {
ret.target_card_refs[0] = this->send_6xB4x06_if_card_ref_invalid(
defender_card->get_card_ref(), 8);
}
if (attacker_card) {
ret.original_attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(
attacker_card->get_card_ref(), 9);
}
return ret;
}
void CardSpecial::destroy_card_if_hp_zero(
shared_ptr<Card> card, uint16_t attacker_card_ref) {
if (card && (card->get_current_hp() <= 0)) {
card->destroy_set_card(this->server()->card_for_set_card_ref(attacker_card_ref));
}
}
bool CardSpecial::evaluate_effect_arg2_condition(
const ActionState& as,
shared_ptr<const Card> card,
const char* arg2_text,
DiceRoll& dice_roll,
uint16_t set_card_ref,
uint16_t sc_card_ref,
uint8_t random_percent,
uint8_t when) const {
// Note: In the original code, as and dice_roll were optional pointers, but
// they are non-null at all callsites, so we've replaced them with references
// (and eliminated the null checks within this function).
uint16_t attacker_card_ref = as.attacker_card_ref;
if (attacker_card_ref == 0xFFFF) {
attacker_card_ref = as.original_attacker_card_ref;
}
auto set_card = this->server()->card_for_set_card_ref(set_card_ref);
bool set_card_has_ability_trap = (set_card &&
(this->card_has_condition_with_ref(set_card, ConditionType::ABILITY_TRAP, 0xFFFF, 0xFFFF)));
switch (arg2_text[0]) {
case 'C':
card = this->server()->card_for_set_card_ref(set_card_ref);
if (!card) {
card = this->server()->card_for_set_card_ref(sc_card_ref);
}
if (!card) {
return false;
}
[[fallthrough]];
case 'c': {
uint8_t ch1 = arg2_text[1] - '0';
uint8_t ch2 = arg2_text[2] - '0';
if ((ch1 > 9) || (ch2 > 9)) {
return false;
}
auto ps = this->server()->get_player_state(client_id_for_card_ref(card->get_card_ref()));
if (!ps) {
return false;
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (!card) {
continue;
}
auto ce = card->get_definition();
if (!ce) {
continue;
}
for (size_t cond_index = 0; cond_index < 3; cond_index++) {
if (ce->def.effects[cond_index].type == ConditionType::NONE) {
break;
}
uint8_t arg2_command = ce->def.effects[cond_index].arg2[0];
if ((arg2_command == 'c') || (arg2_command == 'C')) {
uint8_t other_ch1 = ce->def.effects[cond_index].arg2[1] - 0x30;
if ((other_ch1 > 9)) {
return false;
}
if (other_ch1 == ch2) {
return true;
}
}
}
}
return false;
}
case 'b': {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
return (attacker_card && (attacker_card->action_chain.chain.damage <= atoi(arg2_text + 1)));
}
case 'd': {
if (set_card_has_ability_trap) {
return false;
}
uint8_t low = arg2_text[1] - '0';
uint8_t high = arg2_text[2] - '0';
if ((low < 10) && (high < 10)) {
if (high < low) {
uint8_t t = high;
high = low;
low = t;
}
dice_roll.value_used_in_expr = true;
return ((low <= dice_roll.value) && (dice_roll.value <= high));
}
return false;
}
case 'h':
return (atoi(arg2_text + 1) <= card->get_current_hp());
case 'i':
return (atoi(arg2_text + 1) >= card->get_current_hp());
case 'm': {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
return (attacker_card && (attacker_card->action_chain.chain.damage >= atoi(arg2_text + 1)));
}
case 'n':
switch (atoi(arg2_text + 1)) {
case 0:
return true;
case 1:
return (!card || (card->get_definition()->def.type == CardType::HUNTERS_SC));
case 2:
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto target_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (target_card && target_card->check_card_flag(2)) {
return true;
}
}
return false;
case 3:
for (size_t z = 0; z < 8; z++) {
uint16_t action_card_ref = as.action_card_refs[z];
if (action_card_ref != 0xFFFF) {
auto ce = this->server()->definition_for_card_ref(action_card_ref);
if (card_class_is_tech_like(ce->def.card_class())) {
return true;
}
}
}
return false;
case 4:
return card->action_chain.check_flag(0x0001E000);
case 5:
return card->action_chain.check_flag(0x00001E00);
case 6:
return (card->get_definition()->def.card_class() == CardClass::NATIVE_CREATURE);
case 7:
return (card->get_definition()->def.card_class() == CardClass::A_BEAST_CREATURE);
case 8:
return (card->get_definition()->def.card_class() == CardClass::MACHINE_CREATURE);
case 9:
return (card->get_definition()->def.card_class() == CardClass::DARK_CREATURE);
case 10:
return (card->get_definition()->def.card_class() == CardClass::SWORD_ITEM);
case 11:
return (card->get_definition()->def.card_class() == CardClass::GUN_ITEM);
case 12:
return (card->get_definition()->def.card_class() == CardClass::CANE_ITEM);
case 13: {
auto ce = card->get_definition();
return ((ce->def.card_class() == CardClass::GUARD_ITEM) ||
(ce->def.card_class() == CardClass::MAG_ITEM) ||
this->server()->ruler_server->find_condition_on_card_ref(
card->get_card_ref(), ConditionType::GUARD_CREATURE, 0, 0, 0));
}
case 14:
return card->get_definition()->def.is_sc();
case 15:
return ((card->action_chain.chain.attack_action_card_ref_count == 0) &&
(card->action_metadata.defense_card_ref_count == 0));
case 16:
return this->server()->ruler_server->card_ref_is_aerial(card->get_card_ref());
case 17: {
auto sc_card = this->server()->card_for_set_card_ref(sc_card_ref);
int16_t this_ap = card->ap;
int16_t other_ap = -1;
if (!sc_card) {
auto ce = this->server()->definition_for_card_ref(sc_card_ref);
if (ce) {
other_ap = ce->def.ap.stat;
}
} else {
other_ap = sc_card->ap;
}
return (other_ap == this_ap);
}
case 18:
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto target_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (target_card && target_card->get_definition()->def.is_sc()) {
return true;
}
}
return false;
case 19:
return this->server()->ruler_server->find_condition_on_card_ref(
card->get_card_ref(), ConditionType::PARALYZE, 0, 0, 0);
case 20:
return this->server()->ruler_server->find_condition_on_card_ref(
card->get_card_ref(), ConditionType::FREEZE, 0, 0, 0);
case 21: {
uint8_t client_id = client_id_for_card_ref(sc_card_ref);
if (client_id != 0xFF) {
return card->action_chain.check_flag(0x00002000 << client_id);
}
return false;
}
case 22: {
uint8_t client_id = client_id_for_card_ref(sc_card_ref);
if (client_id != 0xFF) {
return card->action_chain.check_flag(0x00000200 << client_id);
}
return false;
}
default:
return false;
}
throw logic_error("this should be impossible");
case 'o': {
uint8_t v = atoi(arg2_text + 1);
if ((v / 10) == 1) {
auto new_card = this->server()->card_for_set_card_ref(set_card_ref);
if (!new_card) {
new_card = this->server()->card_for_set_card_ref(sc_card_ref);
}
if (new_card) {
card = new_card;
}
}
return (this->find_condition_with_parameters(
card, ConditionType::ANY, set_card_ref, ((v % 10) == 0) ? 0xFF : (v % 10)) != nullptr);
}
case 'r':
return !set_card_has_ability_trap && (random_percent < atoi(arg2_text + 1));
case 's': {
auto ce = card->get_definition();
return ((ce->def.self_cost >= arg2_text[1] - '0') &&
(ce->def.self_cost <= arg2_text[2] - '0'));
}
case 't': {
auto set_card = this->server()->card_for_set_card_ref(set_card_ref);
if (!set_card) {
return false;
}
uint8_t v = atoi(arg2_text + 1);
// TODO: Figure out what this logic actually does and rename the variables
// or comment it appropriately.
if (when == 4) {
uint32_t y = set_card->unknown_a9 & 0xFFFFFFFE;
if ((set_card->unknown_a9 > 0) &&
(y == (y / (v & 0xFFFFFFFE)) * (v & 0xFFFFFFFE))) {
return true;
}
} else {
uint32_t y = set_card->unknown_a9;
if ((set_card->unknown_a9 > 0) &&
(y == (y / (v + 1)) * (v + 1))) {
return true;
}
}
return false;
}
default:
return false;
}
throw logic_error("this should be impossible");
}
int32_t CardSpecial::evaluate_effect_expr(
const AttackEnvStats& ast,
const char* expr,
DiceRoll& dice_roll) const {
// Note: This implementation is not based on the original code because the
// original code was hard to follow - it used a look-behind approach with lots
// of local variables instead of the look-ahead approach that this
// implementation uses. Hopefully this implementation is easier to follow.
vector<pair<ExpressionTokenType, int32_t>> tokens;
while (expr) {
ExpressionTokenType type;
int32_t value = 0;
expr = this->get_next_expr_token(expr, &type, &value);
if (expr) {
if (type == ExpressionTokenType::SPACE) {
throw runtime_error("expression contains space token");
}
// Turn references into numbers, so only numbers and operators can appear
// in the tokens vector
if (type == ExpressionTokenType::REFERENCE) {
if ((value == 1) || (value == 11)) {
dice_roll.value_used_in_expr = true;
}
tokens.emplace_back(make_pair(ExpressionTokenType::NUMBER, ast.at(value)));
} else {
tokens.emplace_back(make_pair(type, value));
}
}
}
// Operators are evaluated left-to-right - there are no operator precedence
// rules
int32_t value = 0;
for (size_t token_index = 0; token_index < tokens.size(); token_index++) {
auto token_type = tokens[token_index].first;
int32_t token_value = tokens[token_index].second;
if ((token_type == ExpressionTokenType::SPACE) || (token_type == ExpressionTokenType::REFERENCE)) {
throw logic_error("space or reference token present in expr evaluation phase 2");
}
if (token_type == ExpressionTokenType::NUMBER) {
value = token_value;
} else {
if (token_index >= tokens.size() - 1) {
throw runtime_error("no token on right side of binary operator");
}
token_index++;
auto right_token_type = tokens[token_index].first;
auto right_value = tokens[token_index].second;
if (right_token_type != ExpressionTokenType::NUMBER) {
throw runtime_error("non-number, non-reference token on right side of operator");
}
switch (token_type) {
case ExpressionTokenType::ROUND_DIVIDE:
value = lround(value / right_value);
break;
case ExpressionTokenType::SUBTRACT:
value -= right_value;
break;
case ExpressionTokenType::ADD:
value += right_value;
break;
case ExpressionTokenType::MULTIPLY:
value *= right_value;
break;
case ExpressionTokenType::FLOOR_DIVIDE:
value = floor(value / right_value);
break;
default:
throw logic_error("invalid binary operator");
}
}
}
return value;
}
bool CardSpecial::execute_effect(
Condition& cond,
shared_ptr<Card> card,
int16_t expr_value,
int16_t unknown_p5,
ConditionType cond_type,
uint unknown_p7,
uint16_t attacker_card_ref) {
int16_t clamped_expr_value = clamp<int16_t>(expr_value, -99, 99);
int16_t clamped_unknown_p5 = clamp<int16_t>(unknown_p5, -99, 99);
cond.value8 = clamped_expr_value;
if (this->card_ref_has_ability_trap(cond)) {
return false;
}
if (card->card_flags & 1) {
return false;
}
if ((card->card_flags & 3) ||
(card->action_metadata.check_flag(0x10) &&
(cond.card_ref != card->get_card_ref()) &&
(cond.condition_giver_card_ref != card->get_card_ref()))) {
unknown_p7 = unknown_p7 & 0xFFFFFFFB;
}
if (unknown_p7 == 0) {
return false;
}
int16_t positive_expr_value = max<int16_t>(0, clamped_expr_value);
clamped_unknown_p5 = max<int16_t>(0, clamped_unknown_p5);
auto attacker_sc = this->server()->card_for_set_card_ref(attacker_card_ref);
auto attack_medium = attacker_sc ? attacker_sc->action_chain.chain.attack_medium : AttackMedium::UNKNOWN;
switch (cond_type) {
case ConditionType::RAMPAGE:
case ConditionType::IMMOBILE:
case ConditionType::HOLD:
case ConditionType::UNKNOWN_07:
case ConditionType::GUOM:
case ConditionType::PARALYZE:
case ConditionType::PIERCE:
case ConditionType::UNKNOWN_0F:
case ConditionType::UNKNOWN_12:
case ConditionType::UNKNOWN_13:
case ConditionType::ACID:
case ConditionType::UNKNOWN_15:
case ConditionType::ABILITY_TRAP:
case ConditionType::FREEZE:
case ConditionType::MAJOR_PIERCE:
case ConditionType::HEAVY_PIERCE:
case ConditionType::MAJOR_RAMPAGE:
case ConditionType::HEAVY_RAMPAGE:
case ConditionType::DEF_DISABLE_BY_COST:
default:
return false;
case ConditionType::UNKNOWN_39:
case ConditionType::DEFENDER:
case ConditionType::SURVIVAL_DECOYS:
case ConditionType::EXP_DECOY:
case ConditionType::SET_MV:
case ConditionType::MV_BONUS:
return true;
case ConditionType::AP_BOOST:
if (unknown_p7 & 1) {
card->action_chain.chain.ap_effect_bonus = clamp<int8_t>(
card->action_chain.chain.ap_effect_bonus + positive_expr_value, -99, 99);
}
return true;
case ConditionType::MULTI_STRIKE:
if (unknown_p7 & 1) {
card->action_chain.chain.strike_count = positive_expr_value;
}
return true;
case ConditionType::DAMAGE_MOD_1:
if (unknown_p7 & 2) {
card->action_chain.chain.damage = positive_expr_value;
}
return true;
case ConditionType::TP_BOOST:
if (unknown_p7 & 1) {
card->action_chain.chain.tp_effect_bonus = clamp<int8_t>(
card->action_chain.chain.tp_effect_bonus + positive_expr_value, -99, 99);
}
return true;
case ConditionType::GIVE_DAMAGE:
if ((unknown_p7 & 4) != 0) {
int16_t current_hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = clamp<int16_t>(current_hp - positive_expr_value, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, -positive_expr_value, 0, 1);
new_hp = max<int16_t>(new_hp, 0);
if (new_hp != current_hp) {
card->set_current_hp(new_hp);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
case ConditionType::UNKNOWN_0C:
case ConditionType::A_T_SWAP_PERM:
if (unknown_p7 & 4) {
int16_t ap = clamp<int16_t>(card->ap, -99, 99);
int16_t tp = clamp<int16_t>(card->tp, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, tp - ap, 0, 0);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, ap - tp, 0, 0);
card->ap = tp;
card->tp = ap;
cond.flags |= 2;
}
return true;
case ConditionType::A_H_SWAP:
case ConditionType::A_H_SWAP_PERM:
if (unknown_p7 & 4) {
int16_t ap = clamp<int16_t>(card->ap, -99, 99);
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, hp - ap, 0, 0);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, ap - hp, 1, 0);
cond.flags |= 2;
if (ap != hp) {
card->set_current_hp(ap);
card->ap = hp;
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
case ConditionType::HEAL:
if (unknown_p7 & 4) {
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = clamp<int16_t>(hp + positive_expr_value, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, new_hp - hp, 1, 1);
if (new_hp != hp) {
card->set_current_hp(new_hp);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
case ConditionType::RETURN_TO_HAND:
if (unknown_p7 & 4) {
uint8_t client_id = client_id_for_card_ref(card->get_card_ref());
if (client_id == 0xFF) {
return false;
}
auto ps = this->server()->player_states[client_id];
if (!ps) {
return false;
}
if ((card->card_flags & 2) || this->card_is_destroyed(card)) {
return true;
}
this->send_6xB4x06_for_card_destroyed(card, attacker_card_ref);
card->unknown_802380C0();
if (!ps->return_set_card_to_hand1(card->get_card_ref())) {
return ps->discard_card_or_add_to_draw_pile(card->get_card_ref(), false);
}
}
return false;
case ConditionType::MIGHTY_KNUCKLE: {
auto ps = card->player_state();
uint8_t atk = ps->get_atk_points();
if (unknown_p7 & 1) {
card->action_chain.chain.ap_effect_bonus = clamp<int16_t>(
card->action_chain.chain.ap_effect_bonus + clamped_unknown_p5, -99, 99);
}
if (unknown_p7 & 4) {
ps->subtract_atk_points(atk);
}
return true;
}
case ConditionType::UNIT_BLOW:
if (unknown_p7 & 1) {
int16_t count = clamp<int16_t>(this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::UNIT_BLOW, 0xFFFF), -99, 99);
card->action_chain.chain.ap_effect_bonus = clamp<int16_t>(card->action_chain.chain.ap_effect_bonus + count * positive_expr_value, -99, 99);
}
return false;
case ConditionType::CURSE:
if (unknown_p7 & 4) {
for (size_t z = 0; z < card->action_chain.chain.target_card_ref_count; z++) {
auto target_card = this->server()->card_for_set_card_ref(
card->action_chain.chain.target_card_refs[z]);
if (target_card) {
CardShortStatus stat = target_card->get_short_status();
if (stat.card_flags & 2) {
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = max<int16_t>(0, hp - 1);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, -1, 0, 1);
if (hp != new_hp) {
card->set_current_hp(new_hp);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
}
}
}
return true;
case ConditionType::COMBO_AP:
if (unknown_p7 & 1) {
int16_t count = clamp<int16_t>(this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::COMBO_AP, 0xFFFF), -99, 99);
card->action_chain.chain.ap_effect_bonus = clamp<int16_t>(
card->action_chain.chain.ap_effect_bonus + count * count, -99, 99);
}
return false;
case ConditionType::PIERCE_RAMPAGE_BLOCK:
if (unknown_p7 & 4) {
card->action_chain.set_flags(0x40);
}
if (unknown_p7 & 3) {
card->action_chain.reset();
}
return true;
case ConditionType::ANTI_ABNORMALITY_1:
if (unknown_p7 & 4) {
for (ssize_t z = 8; z >= 0; z--) {
auto& cond = card->action_chain.conditions[z];
if ((cond.type == ConditionType::IMMOBILE) ||
(cond.type == ConditionType::HOLD) ||
(cond.type == ConditionType::UNKNOWN_07) ||
(cond.type == ConditionType::GUOM) ||
(cond.type == ConditionType::PARALYZE) ||
(cond.type == ConditionType::UNKNOWN_13) ||
(cond.type == ConditionType::ACID) ||
(cond.type == ConditionType::UNKNOWN_15) ||
(cond.type == ConditionType::CURSE) ||
(cond.type == ConditionType::PIERCE_RAMPAGE_BLOCK) ||
(cond.type == ConditionType::FREEZE) ||
(cond.type == ConditionType::UNKNOWN_1E) ||
(cond.type == ConditionType::DROP)) {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 0x0C);
cmd.effect.target_card_ref = card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = -static_cast<int8_t>(cond.type);
cmd.effect.condition_index = z;
this->server()->send(cmd);
this->apply_stat_deltas_to_card_from_condition_and_clear_cond(
cond, card);
card->send_6xB4x4E_4C_4D_if_needed();
}
}
}
return false;
case ConditionType::UNKNOWN_1E:
if (unknown_p7 & 4) {
auto sc_card = this->server()->card_for_set_card_ref(attacker_card_ref);
if (!sc_card || (sc_card->action_chain.chain.attack_medium == AttackMedium::PHYSICAL)) {
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = lround(hp * 0.5f);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, new_hp - hp, 0, 1);
if (new_hp != hp) {
card->set_current_hp(new_hp);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
}
return true;
case ConditionType::EXPLOSION:
if (unknown_p7 & 0x40) {
int16_t count = clamp<int16_t>(this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::EXPLOSION, 0xFFFF), -99, 99);
card->action_metadata.attack_bonus = clamp<int16_t>(count * count, -99, 99);
}
return false;
case ConditionType::UNKNOWN_22:
if (unknown_p7 & 4) {
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, positive_expr_value - card->tp, 0, 1);
card->tp = positive_expr_value;
}
return true;
case ConditionType::RETURN_TO_DECK: {
if (!(unknown_p7 & 4)) {
return true;
}
uint8_t client_id = client_id_for_card_ref(card->get_card_ref());
if (client_id == 0xFF) {
return false;
}
auto ps = this->server()->player_states[client_id];
if (!ps) {
return false;
}
card->unknown_802380C0();
return ps->discard_card_or_add_to_draw_pile(card->get_card_ref(), true);
}
case ConditionType::AP_LOSS:
if (unknown_p7 & 1) {
card->action_chain.chain.ap_effect_bonus = clamp<int16_t>(
card->action_chain.chain.ap_effect_bonus - positive_expr_value, -99, 99);
}
return true;
case ConditionType::BONUS_FROM_LEADER:
if (unknown_p7 & 1) {
clamped_unknown_p5 = this->count_cards_with_card_id_set_by_player_except_card_ref(expr_value, 0xFFFF) + (card->action_chain).chain.ap_effect_bonus;
(card->action_chain).chain.ap_effect_bonus = clamp<int16_t>(clamped_unknown_p5, -99, 99);
}
return true;
case ConditionType::FILIAL: {
if (unknown_p7 & 4) {
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, positive_expr_value, 0, 1);
if (positive_expr_value != 0) {
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = clamp<int16_t>(hp + positive_expr_value, -99, 99);
card->set_current_hp(new_hp, true, false);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
}
case ConditionType::SNATCH:
if (unknown_p7 & 4) {
uint8_t attacker_client_id = client_id_for_card_ref(cond.card_ref);
uint8_t target_client_id = client_id_for_card_ref(card->get_card_ref());
if ((attacker_client_id != 0xFF) && (target_client_id != 0xFF)) {
auto attacker_ps = this->server()->player_states[attacker_client_id];
auto target_ps = this->server()->player_states[target_client_id];
if (attacker_ps && target_ps) {
uint8_t attacker_team_id = attacker_ps->get_team_id();
uint8_t target_team_id = target_ps->get_team_id();
if (positive_expr_value < this->server()->team_exp[target_team_id]) {
this->server()->team_exp[attacker_team_id] += positive_expr_value;
this->server()->team_exp[target_team_id] -= positive_expr_value;
} else {
positive_expr_value = this->server()->team_exp[target_team_id];
this->server()->team_exp[attacker_team_id] += this->server()->team_exp[target_team_id];
this->server()->team_exp[target_team_id] = 0;
}
this->compute_team_dice_boost(attacker_team_id);
this->compute_team_dice_boost(target_team_id);
this->send_6xB4x06_for_exp_change(card, attacker_card_ref, -positive_expr_value, 1);
this->server()->update_battle_state_flags_and_send_6xB4x03_if_needed();
}
}
}
return true;
case ConditionType::HAND_DISRUPTER: {
if (unknown_p7 & 4) {
auto ps = card->player_state();
for (; positive_expr_value > 0; positive_expr_value--) {
size_t hand_size = ps->get_hand_size();
if (hand_size > 0) {
uint8_t a = ps->roll_dice_with_effects(2);
uint8_t b = ps->roll_dice_with_effects(1);
uint16_t card_ref = ps->card_ref_for_hand_index(
(a + b) - ((a + b) / hand_size) * hand_size);
if (card_ref != 0xFFFF) {
ps->discard_ref_from_hand(card_ref);
}
} else {
break;
}
}
ps->update_hand_and_equip_state_and_send_6xB4x02_if_needed();
}
return true;
}
case ConditionType::DROP:
if (unknown_p7 & 4) {
auto ps = card->player_state();
if (ps) {
uint8_t team_id = ps->get_team_id();
int16_t delta = 0;
if (this->server()->team_exp[team_id] < 4) {
this->server()->team_exp[team_id] = 0;
} else {
delta = -3;
this->server()->team_exp[team_id] -= 3;
}
this->compute_team_dice_boost(team_id);
this->send_6xB4x06_for_exp_change(card, attacker_card_ref, delta, 1);
}
}
return true;
case ConditionType::ACTION_DISRUPTER:
if (unknown_p7 & 4) {
for (size_t z = 0; z < card->action_chain.chain.attack_action_card_ref_count; z++) {
this->apply_stat_deltas_to_all_cards_from_all_conditions_with_card_ref(card->action_chain.chain.attack_action_card_refs[z]);
}
card->action_chain.chain.attack_action_card_ref_count = 0;
}
return true;
case ConditionType::SET_HP: {
if ((unknown_p7 & 4) && (card->action_metadata.defense_power < 99)) {
int16_t hp = card->get_current_hp();
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, positive_expr_value - hp, 0, 1);
if (hp != positive_expr_value) {
card->set_current_hp(positive_expr_value, true, false);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
}
case ConditionType::NATIVE_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::NATIVE_CREATURE, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::A_BEAST_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::A_BEAST_CREATURE, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::MACHINE_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::MACHINE_CREATURE, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::DARK_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::DARK_CREATURE, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::SWORD_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::SWORD_ITEM, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::GUN_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::GUN_ITEM, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::CANE_SHIELD:
return this->apply_attribute_guard_if_possible(
unknown_p7, CardClass::CANE_ITEM, card, cond.condition_giver_card_ref, attacker_card_ref);
case ConditionType::UNKNOWN_38: {
auto ps = card->player_state();
if (ps && (unknown_p7 & 4)) {
ps->subtract_def_points(ps->get_def_points() - positive_expr_value);
ps->update_hand_and_equip_state_and_send_6xB4x02_if_needed();
}
return true;
}
case ConditionType::GIVE_OR_TAKE_EXP:
if (unknown_p7 & 4) {
uint8_t client_id = client_id_for_card_ref(card->get_card_ref());
if ((client_id != 0xFF) && this->server()->player_states[client_id]) {
uint8_t team_id = this->server()->player_states[client_id]->get_team_id();
int32_t existing_exp = this->server()->team_exp[team_id];
if ((clamped_expr_value + existing_exp) < 0) {
clamped_expr_value = -existing_exp;
this->server()->team_exp[team_id] = 0;
} else {
this->server()->team_exp[team_id] = existing_exp + clamped_expr_value;
}
this->send_6xB4x06_for_exp_change(card, attacker_card_ref, clamped_expr_value, 1);
this->compute_team_dice_boost(team_id);
this->server()->update_battle_state_flags_and_send_6xB4x03_if_needed();
}
}
return true;
case ConditionType::UNKNOWN_3D:
if (unknown_p7 & 4) {
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, positive_expr_value - card->ap, 0, 1);
card->ap = positive_expr_value;
}
return true;
case ConditionType::DEATH_COMPANION:
if (attacker_sc && (unknown_p7 & 4)) {
vector<uint16_t> card_refs;
card_refs.emplace_back(attacker_sc->get_card_ref());
if (attacker_sc != card) {
card_refs.emplace_back(card->get_card_ref());
}
for (uint16_t card_ref : card_refs) {
auto sc_card = this->server()->card_for_set_card_ref(card_ref);
if (sc_card && (sc_card->get_current_hp() > 0)) {
if (this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
cond.card_ref, cond.condition_giver_card_ref,
sc_card->get_card_ref(), cond.card_definition_effect_index,
attack_medium)) {
this->send_6xB4x06_for_stat_delta(sc_card, attacker_card_ref, 0x20, -sc_card->get_current_hp(), 0, 1);
sc_card->set_current_hp(0);
this->destroy_card_if_hp_zero(sc_card, attacker_card_ref);
}
}
}
}
return false;
case ConditionType::GROUP:
if (unknown_p7 & 1) {
auto ce = card->get_definition();
if (ce) {
int16_t count = clamp<int16_t>(
this->count_cards_with_card_id_set_by_player_except_card_ref(ce->def.card_id, card->get_card_ref()), -99, 99);
card->action_chain.chain.ap_effect_bonus = clamp<int16_t>(
card->action_chain.chain.ap_effect_bonus + count * positive_expr_value, -99, 99);
}
}
return true;
case ConditionType::BERSERK:
if (unknown_p7 & 4) {
int16_t hp = clamp<int16_t>(card->get_current_hp(), -99, 99);
int16_t new_hp = clamp<int16_t>(hp - this->max_all_attack_bonuses(nullptr), -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, new_hp - hp, 0, 1);
new_hp = max<int16_t>(new_hp, 0);
if (new_hp != hp) {
card->set_current_hp(new_hp);
this->destroy_card_if_hp_zero(card, attacker_card_ref);
}
}
return true;
case ConditionType::UNKNOWN_49:
if (unknown_p7 & 4) {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
if (attacker_card && (attacker_card != card)) {
for (ssize_t z = 8; z >= 0; z--) {
this->apply_stat_deltas_to_card_from_condition_and_clear_cond(
attacker_card->action_chain.conditions[z], attacker_card);
}
for (size_t z = 0; z < 9; z++) {
attacker_card->action_chain.conditions[z] = card->action_chain.conditions[z];
}
for (size_t z = 0; z < 9; z++) {
auto& cond = attacker_card->action_chain.conditions[z];
if (cond.type != ConditionType::UNKNOWN_49) {
this->execute_effect(
cond, attacker_card, positive_expr_value, clamped_unknown_p5, cond.type, unknown_p7, attacker_card_ref);
}
}
}
}
return true;
case ConditionType::AP_GROWTH:
if (unknown_p7 & 4) {
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, positive_expr_value, 0, 1);
card->ap = clamp<int16_t>(card->ap + positive_expr_value, -99, 99);
}
return true;
case ConditionType::TP_GROWTH:
if (unknown_p7 & 4) {
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, positive_expr_value, 0, 1);
card->tp = clamp<int16_t>(card->tp + positive_expr_value, -99, 99);
}
return true;
case ConditionType::COPY:
if (unknown_p7 & 4) {
auto attacker_card = this->server()->card_for_set_card_ref(attacker_card_ref);
if (attacker_card && (attacker_card != card)) {
int16_t new_ap = clamp<int16_t>((positive_expr_value < 51) ? (card->ap / 2) : card->ap, -99, 99);
int16_t new_tp = clamp<int16_t>((positive_expr_value < 51) ? (card->tp / 2) : card->tp, -99, 99);
this->send_6xB4x06_for_stat_delta(
attacker_card, attacker_card_ref, 0xA0, new_ap - attacker_card->ap, 0, 0);
this->send_6xB4x06_for_stat_delta(
attacker_card, attacker_card_ref, 0x80, new_tp - attacker_card->tp, 0, 0);
attacker_card->ap = new_ap;
attacker_card->tp = new_tp;
}
}
return true;
case ConditionType::MISC_GUARDS:
if (unknown_p7 & 8) {
card->action_metadata.defense_bonus = clamp<int16_t>(
positive_expr_value + card->action_metadata.defense_bonus, -99, 99);
}
return true;
case ConditionType::AP_OVERRIDE:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
cond.value = clamp<int16_t>(positive_expr_value - card->ap, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, cond.value, 0, 0);
card->ap = positive_expr_value;
cond.flags |= 2;
}
return true;
case ConditionType::TP_OVERRIDE:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
cond.value = clamp<int16_t>(positive_expr_value - card->tp, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, cond.value, 0, 0);
card->tp = positive_expr_value;
cond.flags |= 2;
}
return true;
case ConditionType::SLAYERS_ASSASSINS:
case ConditionType::UNKNOWN_64:
case ConditionType::FORWARD_DAMAGE:
if (unknown_p7 & 0x20) {
card->action_metadata.attack_bonus = clamp<int16_t>(
positive_expr_value + card->action_metadata.attack_bonus, -99, 99);
}
return true;
case ConditionType::BLOCK_ATTACK:
if (unknown_p7 & 4) {
card->action_metadata.set_flags(0x10);
}
return true;
case ConditionType::COMBO_TP:
if (unknown_p7 & 1) {
ssize_t count = this->count_cards_with_card_id_set_by_player_except_card_ref(
expr_value, 0xFFFF);
card->action_chain.chain.tp_effect_bonus = clamp<int16_t>(
count + card->action_chain.chain.tp_effect_bonus, -99, 99);
}
return true;
case ConditionType::MISC_AP_BONUSES:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
int16_t orig_ap = clamp<int16_t>(card->ap, -99, 99);
card->ap = clamp<int16_t>(positive_expr_value + card->ap, 0, 99);
cond.value = clamp<int16_t>(card->ap - orig_ap, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, cond.value, 0, 0);
cond.flags |= 2;
}
return false;
case ConditionType::MISC_TP_BONUSES:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
int16_t orig_tp = clamp<int16_t>(card->tp, -99, 99);
card->tp = clamp<int16_t>(positive_expr_value + card->tp, 0, 99);
cond.value = clamp<int16_t>(card->tp - orig_tp, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, cond.value, 0, 0);
cond.flags |= 2;
}
return false;
case ConditionType::MISC_DEFENSE_BONUSES:
case ConditionType::WEAK_SPOT_INFLUENCE:
if (unknown_p7 & 0x20) {
card->action_metadata.attack_bonus = clamp<int16_t>(
card->action_metadata.attack_bonus - positive_expr_value, 0, 99);
}
return true;
case ConditionType::MOSTLY_HALFGUARDS:
case ConditionType::DAMAGE_MODIFIER_2:
if (unknown_p7 & 0x40) {
card->action_metadata.attack_bonus = positive_expr_value;
}
return true;
case ConditionType::PERIODIC_FIELD:
if ((unknown_p7 & 0x40) &&
(static_cast<uint16_t>(attack_medium) == ((this->server()->get_round_num() >> 1) & 1) + 1)) {
card->action_metadata.attack_bonus = 0;
}
return true;
case ConditionType::AP_SILENCE:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
int16_t prev_ap = clamp<int16_t>(card->ap, -99, 99);
card->ap = clamp<int16_t>(card->ap - positive_expr_value, 0, 99);
cond.value = clamp<int16_t>(prev_ap - card->ap, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, -cond.value, 0, 0);
cond.flags |= 2;
}
return false;
case ConditionType::TP_SILENCE:
if ((unknown_p7 & 4) && !(cond.flags & 2)) {
int16_t prev_ap = clamp<int16_t>(card->tp, -99, 99);
card->tp = clamp<int16_t>(card->tp - positive_expr_value, 0, 99);
cond.value = clamp<int16_t>(prev_ap - card->tp, -99, 99);
this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, -cond.value, 0, 0);
cond.flags |= 2;
}
return false;
case ConditionType::RAMPAGE_AP_LOSS:
if (unknown_p7 & 1) {
card->action_chain.chain.tp_effect_bonus = clamp<int16_t>(
card->action_chain.chain.tp_effect_bonus - positive_expr_value, -99, 99);
}
return true;
case ConditionType::UNKNOWN_77:
if (attacker_sc && (unknown_p7 & 4)) {
vector<uint16_t> card_refs;
card_refs.emplace_back(attacker_sc->get_card_ref());
for (size_t z = 0; z < attacker_sc->action_chain.chain.target_card_ref_count; z++) {
card_refs.emplace_back(attacker_sc->action_chain.chain.target_card_refs[z]);
}
for (uint16_t card_ref : card_refs) {
auto set_card = this->server()->card_for_set_card_ref(card_ref);
if (set_card && (set_card->get_current_hp() > 0)) {
if (this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
cond.card_ref,
cond.condition_giver_card_ref,
set_card->get_card_ref(),
cond.card_definition_effect_index,
attack_medium)) {
this->send_6xB4x06_for_stat_delta(
set_card, attacker_card_ref, 0x20, -set_card->get_current_hp(), 0, 1);
set_card->set_current_hp(0);
this->destroy_card_if_hp_zero(set_card, attacker_card_ref);
}
}
}
}
return false;
}
}
const Condition* CardSpecial::find_condition_with_parameters(
shared_ptr<const Card> card,
ConditionType cond_type,
uint16_t set_card_ref,
uint8_t def_effect_index) const {
const Condition* ret = nullptr;
uint8_t max_order = 9;
for (size_t z = 0; z < 9; z++) {
if (card->action_chain.conditions[z].type == ConditionType::NONE) {
continue;
}
auto& cond = card->action_chain.conditions[z];
auto orig_eff = this->original_definition_for_condition(cond);
if (!this->card_ref_has_ability_trap(cond) &&
((cond_type == ConditionType::ANY) || (cond.type == cond_type)) &&
((set_card_ref == 0xFFFF) || (cond.card_ref == set_card_ref)) &&
((def_effect_index == 0xFF) || (orig_eff && (orig_eff->effect_num == def_effect_index))) &&
(!ret || (max_order < cond.order))) {
max_order = cond.order;
ret = &cond;
}
}
return ret;
}
Condition* CardSpecial::find_condition_with_parameters(
shared_ptr<Card> card,
ConditionType cond_type,
uint16_t set_card_ref,
uint8_t def_effect_index) const {
return const_cast<Condition*>(this->find_condition_with_parameters(
static_cast<shared_ptr<const Card>>(card), cond_type, set_card_ref, def_effect_index));
}
void CardSpecial::get_card1_loc_with_card2_opposite_direction(
Location* out_loc,
shared_ptr<const Card> card1,
shared_ptr<const Card> card2) {
if (card1) {
if (!card2 || (static_cast<uint8_t>(card2->facing_direction) & 0x80)) {
*out_loc = card1->loc;
} else if ((card2->loc.x == card1->loc.x) && (card2->loc.y == card1->loc.y)) {
*out_loc = card1->loc;
out_loc->direction = card2->facing_direction;
} else {
*out_loc = card1->loc;
out_loc->direction = turn_around(card2->facing_direction);
}
}
}
uint16_t CardSpecial::get_card_id_with_effective_range(
shared_ptr<const Card> card1, uint16_t default_card_id, shared_ptr<const Card> card2) const {
if (card2 && !(static_cast<uint8_t>(card2->facing_direction) & 0x80)) {
return this->server()->ruler_server->get_card_id_with_effective_range(
card1 ? card1->get_card_ref() : 0xFFFF, default_card_id, 0);
}
return default_card_id;
}
void CardSpecial::get_effective_ap_tp(
StatSwapType type,
int16_t* effective_ap,
int16_t* effective_tp,
int16_t hp,
int16_t ap,
int16_t tp) {
switch (type) {
case StatSwapType::NONE:
*effective_ap = ap;
*effective_tp = tp;
break;
case StatSwapType::A_T_SWAP:
*effective_ap = tp;
*effective_tp = ap;
break;
case StatSwapType::A_H_SWAP:
*effective_ap = hp;
*effective_tp = tp;
break;
default:
throw logic_error("invalid stat swap state");
}
}
const char* CardSpecial::get_next_expr_token(
const char* expr, ExpressionTokenType* out_type, int32_t* out_value) const {
switch (*expr) {
case '\0':
*out_type = ExpressionTokenType::SPACE;
return nullptr;
case ' ':
*out_type = ExpressionTokenType::SPACE;
return expr + 1;
case '+':
*out_type = ExpressionTokenType::ADD;
return expr + 1;
case '-':
*out_type = ExpressionTokenType::SUBTRACT;
return expr + 1;
case '*':
*out_type = ExpressionTokenType::MULTIPLY;
return expr + 1;
case '/':
if (expr[1] == '/') {
*out_type = ExpressionTokenType::FLOOR_DIVIDE;
return expr + 2;
} else {
*out_type = ExpressionTokenType::ROUND_DIVIDE;
return expr + 1;
}
}
if ((*expr >= 'a') && (*expr <= 'z')) {
string token_buf;
for (; ('a' <= *expr) && (*expr < 'z'); expr++) {
token_buf.push_back(*expr);
}
*out_type = ExpressionTokenType::SPACE;
*out_value = 0x27;
static const vector<const char*> tokens = {
"f", "d", "ap", "tp", "hp", "mhp", "dm", "tdm", "tf", "ac", "php",
"dc", "cs", "a", "kap", "ktp", "dn", "hf", "df", "ff", "ef", "bi",
"ab", "mc", "dk", "sa", "gn", "wd", "tt", "lv", "adm", "ddm", "sat",
"edm", "ldm", "rdm", "fdm", "ndm", "ehp"};
for (size_t z = 0; z < tokens.size(); z++) {
if (token_buf == tokens[z]) {
*out_type = ExpressionTokenType::REFERENCE;
*out_value = z;
return expr;
}
}
return expr;
}
if ((*expr >= '0') && (*expr <= '9')) {
*out_type = ExpressionTokenType::NUMBER;
*out_value = strtol(expr, const_cast<char**>(&expr), 10);
return expr;
}
throw runtime_error("invalid card effect expression");
}
vector<shared_ptr<const Card>> CardSpecial::get_targeted_cards_for_condition(
uint16_t card_ref,
uint8_t def_effect_index,
uint16_t setter_card_ref,
const ActionState& as,
int16_t p_target_type,
bool apply_usability_filters) const {
vector<shared_ptr<const Card>> ret;
uint8_t client_id = client_id_for_card_ref(card_ref);
auto card1 = this->server()->card_for_set_card_ref(card_ref);
if (!card1) {
card1 = this->server()->card_for_set_card_ref(setter_card_ref);
}
auto card2 = this->server()->card_for_set_card_ref((as.attacker_card_ref == 0xFFFF)
? as.original_attacker_card_ref
: as.attacker_card_ref);
Location card1_loc;
if (!card1) {
card1_loc.x = 0;
card1_loc.y = 0;
card1_loc.direction = Direction::RIGHT;
} else {
this->get_card1_loc_with_card2_opposite_direction(&card1_loc, card1, card2);
}
AttackMedium attack_medium = card2
? card2->action_chain.chain.attack_medium
: AttackMedium::UNKNOWN;
auto add_card_refs = [&](const vector<uint16_t>& result_card_refs) -> void {
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card) {
ret.emplace_back(result_card);
}
}
};
switch (p_target_type) {
case 1:
case 5: {
auto result_card = this->server()->card_for_set_card_ref(setter_card_ref);
if (result_card) {
ret.emplace_back(result_card);
}
break;
}
case 2:
if (as.original_attacker_card_ref == 0xFFFF) {
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto result_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (result_card) {
ret.emplace_back(result_card);
}
}
} else if (card2) {
ret.emplace_back(card2);
}
break;
case 3:
if (card1) {
auto ce = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (ce && ps) {
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, ce->def.card_id, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
add_card_refs(ps->get_card_refs_within_range_from_all_players(range, card1_loc, CardType::ITEM));
}
}
break;
case 4:
size_t z;
for (z = 0; (z < 9) && (as.action_card_refs[z] != 0xFFFF) && (as.action_card_refs[z] != card_ref); z++) {
}
for (; (z < 9) && (as.action_card_refs[z] != 0xFFFF); z++) {
auto result_card = this->server()->card_for_set_card_ref(as.action_card_refs[z]);
if (result_card) {
ret.emplace_back(result_card);
}
}
break;
case 6:
ret = this->get_attacker_card_and_sc_if_item(as);
break;
case 7: {
auto card = this->get_attacker_card(as);
if (card) {
ret.emplace_back(card);
}
break;
}
case 8: {
auto card = this->sc_card_for_client_id(client_id);
if (card) {
ret.emplace_back(card);
}
break;
}
case 9:
if (card1) {
auto ce = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (ce && ps) {
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, ce->def.card_id, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
add_card_refs(ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id()));
}
}
break;
case 10:
ret = this->find_all_cards_on_same_or_other_team(client_id, true);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 11:
ret = this->find_all_set_cards_on_client_team(client_id);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 12:
ret = this->find_all_cards_by_aerial_attribute(false);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 13:
ret = this->find_cards_by_condition_inc_exc(ConditionType::FREEZE);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 14:
ret = this->find_cards_in_hp_range(-1000, 3);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 15:
ret = this->get_all_set_cards();
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 16:
ret = this->find_cards_in_hp_range(8, 1000);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 17: {
auto result_card = this->server()->card_for_set_card_ref(card_ref);
if (result_card) {
ret.emplace_back(result_card);
}
break;
}
case 18: {
auto card = this->sc_card_for_client_id(client_id);
if (card) {
ret.emplace_back(card);
}
break;
}
case 19:
ret = this->find_all_sc_cards_of_class(CardClass::HU_SC);
break;
case 20:
ret = this->find_all_sc_cards_of_class(CardClass::RA_SC);
break;
case 21:
ret = this->find_all_sc_cards_of_class(CardClass::FO_SC);
break;
case 22:
if (card1) {
auto def = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (def && ps) {
// TODO: Again, Sega hardcodes the Gifoie card's ID here... we
// should fix this eventually.
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id());
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card &&
(result_card->get_definition()->def.type != CardType::ITEM) &&
(card1 != result_card)) {
ret.emplace_back(result_card);
}
}
if (card1) {
ret.emplace_back(card1);
}
}
}
break;
case 23:
if (card1) {
auto def = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (def && ps) {
// TODO: Again with the Gifoie hardcoding...
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF);
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card &&
(result_card->get_definition()->def.type != CardType::ITEM)) {
ret.emplace_back(result_card);
}
}
}
}
break;
case 24:
ret = this->find_cards_by_condition_inc_exc(ConditionType::PARALYZE);
break;
case 25:
ret = this->find_all_cards_by_aerial_attribute(true);
break;
case 26:
ret = this->find_cards_damaged_by_at_least(1);
break;
case 27:
ret = this->get_all_set_cards_by_team_and_class(CardClass::NATIVE_CREATURE, 0xFF, false);
break;
case 28:
ret = this->get_all_set_cards_by_team_and_class(CardClass::A_BEAST_CREATURE, 0xFF, false);
break;
case 29:
ret = this->get_all_set_cards_by_team_and_class(CardClass::MACHINE_CREATURE, 0xFF, false);
break;
case 30:
ret = this->get_all_set_cards_by_team_and_class(CardClass::DARK_CREATURE, 0xFF, false);
break;
case 31:
ret = this->get_all_set_cards_by_team_and_class(CardClass::SWORD_ITEM, 0xFF, false);
break;
case 32:
ret = this->get_all_set_cards_by_team_and_class(CardClass::GUN_ITEM, 0xFF, false);
break;
case 33:
ret = this->get_all_set_cards_by_team_and_class(CardClass::CANE_ITEM, 0xFF, false);
break;
case 34:
if (as.original_attacker_card_ref == 0xFFFF) {
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto result_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (result_card &&
result_card->get_definition() &&
!result_card->get_definition()->def.is_sc()) {
ret.emplace_back(result_card);
}
}
} else if (card2 &&
card2->get_definition() &&
!card2->get_definition()->def.is_sc()) {
ret.emplace_back(card2);
}
break;
case 35:
if (card1) {
auto def = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (def && ps) {
// TODO: Again with the Gifoie hardcoding...
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF);
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card) {
auto ce = result_card->get_definition();
if (ce->def.type == CardType::HUNTERS_SC) {
bool should_add = true;
for (uint16_t other_result_card_ref : result_card_refs) {
if ((other_result_card_ref != result_card_ref) &&
(client_id_for_card_ref(other_result_card_ref) == client_id_for_card_ref(result_card_ref))) {
should_add = false;
break;
}
}
if (should_add) {
ret.emplace_back(result_card);
}
} else {
ret.emplace_back(result_card);
}
}
}
}
}
break;
case 36:
if (as.original_attacker_card_ref == 0xFFFF) {
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto result_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (result_card &&
result_card->get_definition() &&
result_card->get_definition()->def.is_sc()) {
ret.emplace_back(result_card);
}
}
} else if (card2 &&
card2->get_definition() &&
card2->get_definition()->def.is_sc()) {
ret.emplace_back(card2);
}
break;
case 37:
ret = this->find_all_cards_on_same_or_other_team(client_id, false);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 38:
if (card1) {
auto def = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (def && ps) {
// TODO: Yet another Gifoie hardcode location :(
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id());
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card &&
(result_card->get_definition()->def.type != CardType::ITEM) &&
(result_card->get_card_ref() != card_ref)) {
ret.emplace_back(result_card);
}
}
}
}
break;
case 39:
ret = this->find_all_set_cards_with_cost_in_range(4, 99);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 40:
ret = this->find_all_set_cards_with_cost_in_range(0, 3);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 41: {
auto ps = card1->player_state();
if (card1 && ps) {
// TODO: Sigh. Gifoie again.
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF);
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card &&
(result_card != card1) &&
(result_card->get_card_ref() != card_ref) &&
(result_card->get_definition()->def.is_fc())) {
ret.emplace_back(result_card);
}
}
for (size_t z = 0; z < 8; z++) {
auto result_card = ps->get_set_card(z);
if (result_card && (card1 != result_card) &&
(result_card->get_definition()->def.type == CardType::ITEM)) {
bool already_in_ret = false;
for (auto c : ret) {
if (c == result_card) {
already_in_ret = true;
break;
}
}
if (!already_in_ret) {
ret.emplace_back(result_card);
}
}
}
}
break;
}
case 42: {
auto check_card = [&](shared_ptr<const Card> result_card) -> void {
if (result_card) {
ret.emplace_back(result_card);
auto ce = result_card->get_definition();
auto ps = result_card->player_state();
if ((ce->def.type == CardType::ITEM) && ps) {
result_card = ps->get_sc_card();
if (result_card) {
ret.emplace_back(result_card);
}
}
}
};
if (as.original_attacker_card_ref == 0xFFFF) {
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
check_card(this->server()->card_for_set_card_ref(as.target_card_refs[z]));
}
} else if (card2) {
check_card(card2);
}
break;
}
case 43:
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto result_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (!result_card) {
continue;
}
auto ce = result_card->get_definition();
auto ps = result_card->player_state();
if (ce && !ce->def.is_sc() && result_card->check_card_flag(2) && ps) {
auto result_sc_card = ps->get_sc_card();
if (result_sc_card) {
ret.emplace_back(result_sc_card);
}
}
}
break;
case 44: {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t z = 0; z < 8; z++) {
auto result_card = ps->get_set_card(z);
if (result_card) {
ret.emplace_back(result_card);
}
}
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
}
break;
}
case 45:
this->sum_last_attack_damage(&ret, 0, 0);
ret = this->filter_cards_by_range(ret, card1, card1_loc, card2);
break;
case 46:
if (card1) {
auto def = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (def && ps) {
// TODO: Yet another hardcoded card ID... but this time it's Cross
// Slay instead of Gifoie
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x009C, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF);
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card && (result_card->get_definition()->def.type != CardType::ITEM)) {
ret.emplace_back(result_card);
}
}
}
}
break;
case 47: {
uint8_t client_id = client_id_for_card_ref(as.original_attacker_card_ref);
if (client_id != 0xFF) {
auto card = this->sc_card_for_client_id(client_id);
if (card) {
ret.emplace_back(card);
}
}
break;
}
case 48:
if (card1) {
auto ce = this->server()->definition_for_card_ref(card_ref);
auto ps = card1->player_state();
if (ce && ps) {
// TODO: Sigh. Gifoie. Sigh.
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF);
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card) {
auto def = result_card->get_definition();
if (ce->def.type == CardType::HUNTERS_SC) {
bool should_add = true;
for (uint16_t other_result_card_ref : result_card_refs) {
if (other_result_card_ref != result_card_ref) {
if (client_id_for_card_ref(other_result_card_ref) == client_id_for_card_ref(result_card_ref)) {
should_add = false;
break;
}
}
}
if (should_add) {
ret.emplace_back(result_card);
}
} else {
ret.emplace_back(result_card);
}
}
}
}
auto result_card = this->server()->card_for_set_card_ref(setter_card_ref);
if (result_card) {
ret.emplace_back(result_card);
}
}
break;
case 49:
if (card1) {
auto ps = card1->player_state();
if (ps) {
// TODO: One more Gifoie here.
uint16_t range_card_id = this->get_card_id_with_effective_range(card1, 0x00D9, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, range_card_id, card1_loc, this->server()->base()->map_and_rules1);
auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id());
for (uint16_t result_card_ref : result_card_refs) {
auto result_card = this->server()->card_for_set_card_ref(result_card_ref);
if (result_card && (result_card != card1) &&
(result_card->get_card_ref() != card_ref) &&
result_card->get_definition()->def.is_fc()) {
ret.emplace_back(result_card);
}
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto result_card = ps->get_set_card(set_index);
if (result_card && (card1 != result_card) &&
(result_card->get_definition()->def.type == CardType::ITEM)) {
bool should_add = true;
for (auto c : ret) {
if (c == result_card) {
should_add = false;
break;
}
}
if (should_add) {
ret.emplace_back(result_card);
}
}
}
}
}
}
if (apply_usability_filters) {
vector<shared_ptr<const Card>> filtered_ret;
for (auto c : ret) {
if (this->server()->ruler_server->check_usability_or_apply_condition_for_card_refs(
card_ref, setter_card_ref, c->get_card_ref(), def_effect_index, attack_medium)) {
filtered_ret.emplace_back(c);
}
}
return filtered_ret;
} else {
return ret;
}
}
vector<shared_ptr<Card>> CardSpecial::get_targeted_cards_for_condition(
uint16_t card_ref,
uint8_t def_effect_index,
uint16_t setter_card_ref,
const ActionState& as,
int16_t p_target_type,
bool apply_usability_filters) {
return this->server()->const_cast_set_cards_v(as_const(*this).get_targeted_cards_for_condition(
card_ref, def_effect_index, setter_card_ref, as, p_target_type, apply_usability_filters));
}
bool CardSpecial::is_card_targeted_by_condition(
const Condition& cond,
const ActionState& as,
shared_ptr<const Card> card) const {
auto ce = this->server()->definition_for_card_ref(cond.card_ref);
auto sc_card = this->server()->card_for_set_card_ref(cond.card_ref);
if (cond.type != ConditionType::NONE) {
if ((!sc_card || ((sc_card != card) && (sc_card->card_flags & 2))) &&
ce &&
((ce->def.type == CardType::ITEM) || ce->def.is_sc()) &&
(cond.remaining_turns != 100) &&
(client_id_for_card_ref(card->get_card_ref()) == client_id_for_card_ref(cond.card_ref))) {
return false;
}
if (cond.remaining_turns == 102) {
if (sc_card && ((sc_card == card) || !(sc_card->card_flags & 2))) {
auto target_cards = this->get_targeted_cards_for_condition(
cond.card_ref,
cond.card_definition_effect_index,
cond.condition_giver_card_ref,
as,
atoi(&ce->def.effects[cond.card_definition_effect_index].arg3[1]),
0);
for (auto c : target_cards) {
if (c == card) {
return true;
}
}
}
return false;
} else {
return true;
}
}
return true;
}
void CardSpecial::on_card_set(shared_ptr<PlayerState> ps, uint16_t card_ref) {
auto sc_card = ps->get_sc_card();
uint16_t sc_card_ref = sc_card ? sc_card->get_card_ref() : 0xFFFF;
ActionState as;
this->unknown_8024C2B0(1, card_ref, as, sc_card_ref);
}
const CardDefinition::Effect* CardSpecial::original_definition_for_condition(
const Condition& cond) const {
auto ce = this->server()->definition_for_card_ref(cond.card_ref);
if (!ce) {
return nullptr;
}
const auto* eff = &ce->def.effects[cond.card_definition_effect_index];
return (eff->type == ConditionType::NONE) ? nullptr : eff;
}
bool CardSpecial::card_ref_has_ability_trap(const Condition& cond) const {
auto card = this->server()->card_for_set_card_ref(cond.card_ref);
if (!card) {
return false;
} else {
return this->card_has_condition_with_ref(
card, ConditionType::ABILITY_TRAP, 0xFFFF, 0xFFFF);
}
}
void CardSpecial::send_6xB4x06_for_exp_change(
shared_ptr<const Card> card,
uint16_t attacker_card_ref,
uint8_t dice_roll_value,
bool unknown_p5) const {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x02;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 10);
cmd.effect.target_card_ref = card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.dice_roll_value = dice_roll_value;
cmd.effect.ap = clamp<int16_t>(card->ap, 0, 99);
cmd.effect.current_hp = clamp<int16_t>(card->get_current_hp(), 0, 99);
if (unknown_p5 == 0) {
cmd.effect.current_hp |= 0x80;
}
// NOTE: The original code appears to have a copy/paste error here: if
// card->tp > 99, then it sets cmd.effect.ap = 99 instead of cmd.effect.tp.
// We implement the presumably intended behavior here instead.
cmd.effect.tp = clamp<int16_t>(card->tp, 0, 99);
this->server()->send(cmd);
}
void CardSpecial::send_6xB4x06_for_card_destroyed(
shared_ptr<const Card> destroyed_card, uint16_t attacker_card_ref) const {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(
attacker_card_ref, 0x13);
cmd.effect.target_card_ref = destroyed_card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = 0x7E;
this->server()->send(cmd);
}
uint16_t CardSpecial::send_6xB4x06_if_card_ref_invalid(
uint16_t card_ref, int16_t value) const {
if (!this->server()->card_ref_is_empty_or_has_valid_card_id(card_ref)) {
if (value != 0) {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = 0xFFFF;
cmd.effect.target_card_ref = 0xFFFF;
cmd.effect.value = value;
cmd.effect.operation = 0x7E;
this->server()->send(cmd);
}
card_ref = 0xFFFF;
}
return card_ref;
}
void CardSpecial::send_6xB4x06_for_stat_delta(
shared_ptr<const Card> card,
uint16_t attacker_card_ref,
uint32_t flags,
int16_t hp_delta,
bool unknown_p6,
bool unknown_p7) const {
if (((hp_delta > 50) || (hp_delta < -50)) && (flags == 0x20)) {
if (hp_delta < 0) {
hp_delta = -card->get_current_hp();
} else {
hp_delta = card->get_max_hp() - card->get_current_hp();
}
}
if (unknown_p6) {
hp_delta = min<int16_t>(hp_delta + card->get_current_hp(), card->get_max_hp()) - card->get_current_hp();
if (hp_delta == 0) {
return;
}
}
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = flags | 2;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card_ref, 10);
cmd.effect.target_card_ref = card->get_card_ref();
cmd.effect.value = -hp_delta;
cmd.effect.ap = clamp<int16_t>(card->ap, 0, 99);
cmd.effect.current_hp = clamp<int16_t>(card->get_current_hp(), 0, 99);
cmd.effect.tp = clamp<int16_t>(card->tp, 0, 99);
if (!unknown_p7) {
cmd.effect.current_hp |= 0x80;
}
this->server()->send(cmd);
}
bool CardSpecial::should_cancel_condition_due_to_anti_abnormality(
const CardDefinition::Effect& eff,
shared_ptr<const Card> card,
uint16_t target_card_ref,
uint16_t sc_card_ref) const {
if (!card) {
return false;
}
if ((card->card_flags & 3) ||
(card->action_metadata.check_flag(0x10) &&
(card->get_card_ref() != target_card_ref) &&
(card->get_card_ref() != sc_card_ref))) {
return true;
}
auto ce = card->get_definition();
if (ce->def.is_sc() && (eff.type == ConditionType::FREEZE)) {
return true;
}
switch (eff.type) {
case ConditionType::IMMOBILE:
case ConditionType::HOLD:
case ConditionType::GUOM:
case ConditionType::PARALYZE:
case ConditionType::ACID:
case ConditionType::CURSE:
case ConditionType::FREEZE:
case ConditionType::DROP: {
const auto* cond = this->find_condition_with_parameters(card, ConditionType::ANTI_ABNORMALITY_2, 0xFFFF, 0xFF);
return (cond != nullptr) ||
this->server()->ruler_server->card_ref_is_boss_sc(card->get_card_ref());
}
default:
return false;
}
}
bool CardSpecial::should_return_card_ref_to_hand_on_destruction(
uint16_t card_ref) const {
if (card_ref == 0xFFFF) {
return false;
}
uint8_t client_id = client_id_for_card_ref(card_ref);
if (client_id == 0xFF) {
return false;
}
auto ce = this->server()->definition_for_card_ref(card_ref);
if (!ce) {
return false;
}
auto ps = (client_id == 0xFF) ? nullptr : this->server()->get_player_state(client_id);
if (!ps) {
return false;
}
auto check_card = [&](shared_ptr<const Card> card) -> bool {
if (!card) {
return false;
}
for (size_t cond_index = 0; cond_index < 9; cond_index++) {
if (this->card_ref_has_ability_trap(card->action_chain.conditions[cond_index])) {
continue;
}
auto cond_type = card->action_chain.conditions[cond_index].type;
if ((cond_type == ConditionType::RETURN) &&
!(card->card_flags & 1) &&
(card->get_card_ref() == card_ref)) {
return true;
} else if ((cond_type == ConditionType::REBORN) &&
!(card->card_flags & 3) &&
(ce->def.card_id == static_cast<uint16_t>(card->action_chain.conditions[cond_index].value))) {
return true;
}
}
return false;
};
for (size_t set_index = 0; set_index < 8; set_index++) {
if (check_card(ps->get_set_card(set_index))) {
return true;
}
}
return check_card(ps->get_sc_card());
}
size_t CardSpecial::sum_last_attack_damage(
vector<shared_ptr<const Card>>* out_cards,
int32_t* out_damage_sum,
size_t* out_damage_count) const {
size_t damage_count = 0;
auto check_card = [&](shared_ptr<const Card> c) -> void {
if (c && (c->last_attack_final_damage > 0)) {
if (out_damage_sum) {
*out_damage_sum += c->last_attack_final_damage;
}
if (out_cards) {
out_cards->emplace_back(c);
}
damage_count++;
}
};
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
continue;
}
check_card(ps->get_sc_card());
for (size_t set_index = 0; set_index < 8; set_index++) {
check_card(ps->get_set_card(set_index));
}
}
if (out_damage_count) {
*out_damage_count += damage_count;
}
return damage_count;
}
void CardSpecial::update_condition_orders(shared_ptr<Card> card) {
vector<size_t> cond_indexes;
for (size_t z = 0; z < 9; z++) {
if (card->action_chain.conditions[z].type != ConditionType::NONE) {
cond_indexes.emplace_back(z);
}
}
bool modified = true;
while (modified) {
modified = false;
for (size_t index_offset = 0; index_offset < cond_indexes.size() - 1; index_offset++) {
size_t this_index = cond_indexes[index_offset];
size_t next_index = cond_indexes[index_offset + 1];
uint8_t this_cond_order = card->action_chain.conditions[this_index].order;
uint8_t next_cond_order = card->action_chain.conditions[next_index].order;
if (next_cond_order < this_cond_order) {
card->action_chain.conditions[this_index].order = next_cond_order;
card->action_chain.conditions[next_index].order = this_cond_order;
modified = true;
}
}
}
size_t cond_order = 0;
for (size_t index : cond_indexes) {
card->action_chain.conditions[index].order = cond_order++;
}
}
int16_t CardSpecial::max_all_attack_bonuses(size_t* out_count) const {
int16_t max_attack_bonus = 0;
size_t num_attack_bonuses = 0;
auto check_card = [&](shared_ptr<const Card> c) {
if (!c) {
return;
}
if (c->action_metadata.attack_bonus > max_attack_bonus) {
max_attack_bonus = c->action_metadata.attack_bonus;
}
if (c->action_metadata.attack_bonus > 0) {
num_attack_bonuses++;
}
};
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
check_card(ps->get_sc_card());
for (size_t set_index = 0; set_index < 8; set_index++) {
check_card(ps->get_set_card(set_index));
}
}
}
if (out_count) {
*out_count = num_attack_bonuses;
}
return max_attack_bonus;
}
void CardSpecial::unknown_80244AA8(shared_ptr<Card> card) {
ActionState as = this->create_attack_state_from_card_action_chain(card);
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->player_states[client_id];
if (ps) {
auto other_card = ps->get_sc_card();
if (other_card) {
this->clear_invalid_conditions_on_card(other_card, as);
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto other_card = ps->get_set_card(set_index);
if (other_card) {
this->clear_invalid_conditions_on_card(other_card, as);
}
}
}
}
this->apply_defense_conditions(as, 0x27, card, 4);
this->unknown_8024C2B0(0x27, card->get_card_ref(), as, 0xFFFF);
this->apply_defense_conditions(as, 0x13, card, 4);
this->unknown_8024C2B0(0x13, card->get_card_ref(), as, 0xFFFF);
}
void CardSpecial::check_for_defense_interference(
shared_ptr<const Card> attacker_card,
shared_ptr<Card> target_card,
int16_t* inout_unknown_p4) {
// Note: This check is not part of the original implementation.
if (this->server()->base()->data_index->behavior_flags & BehaviorFlag::DISABLE_INTERFERENCE) {
return;
}
if (!inout_unknown_p4) {
return;
}
if (target_card->get_current_hp() > *inout_unknown_p4) {
return;
}
uint16_t ally_sc_card_ref = this->server()->ruler_server->get_ally_sc_card_ref(
target_card->get_card_ref());
if (ally_sc_card_ref == 0xFFFF) {
return;
}
auto ally_sc = this->server()->card_for_set_card_ref(ally_sc_card_ref);
if (!ally_sc || (ally_sc->card_flags & 2)) {
return;
}
uint8_t target_ally_client_id = client_id_for_card_ref(ally_sc_card_ref);
if (target_ally_client_id == 0xFF) {
return;
}
uint8_t target_client_id = client_id_for_card_ref(target_card->get_card_ref());
if (target_client_id == 0xFF) {
return;
}
auto ally_hes = this->server()->ruler_server->get_hand_and_equip_state_for_client_id(target_ally_client_id);
if (!ally_hes || !ally_hes->is_cpu_player) {
return;
}
uint16_t target_card_id = this->server()->card_id_for_card_ref(target_card->get_card_ref());
if (target_card_id == 0xFFFF) {
return;
}
uint16_t ally_sc_card_id = this->server()->card_id_for_card_ref(ally_sc_card_ref);
if (ally_sc_card_id == 0xFFFF) {
return;
}
auto target_ps = target_card->player_state();
if (!target_ps) {
return;
}
if (target_ps->unknown_a17 >= 1) {
return;
}
auto entry = get_interference_probability_entry(
target_card_id, ally_sc_card_id, false);
if (!entry || (this->server()->get_random(99) >= entry->defense_probability)) {
return;
}
target_ps->unknown_a17++;
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(attacker_card->get_card_ref(), 0x12);
cmd.effect.target_card_ref = target_card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = 0x7D;
this->server()->send(cmd);
if (inout_unknown_p4) {
*inout_unknown_p4 = 0;
target_card->action_metadata.set_flags(0x10);
}
}
void CardSpecial::unknown_8024C2B0(
uint32_t when,
uint16_t set_card_ref,
const ActionState& as,
uint16_t sc_card_ref,
bool apply_defense_condition_to_all_cards,
uint16_t apply_defense_condition_to_card_ref) {
set_card_ref = this->send_6xB4x06_if_card_ref_invalid(set_card_ref, 1);
auto ce = this->server()->definition_for_card_ref(set_card_ref);
if (!ce) {
return;
}
uint16_t as_attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 2);
if (as_attacker_card_ref == 0xFFFF) {
as_attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(as.original_attacker_card_ref, 3);
}
G_ApplyConditionEffect_GC_Ep3_6xB4x06 dice_cmd;
dice_cmd.effect.target_card_ref = set_card_ref;
bool as_action_card_refs_contains_set_card_ref = false;
bool as_action_card_refs_contains_duplicate_of_set_card = false;
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
if (as.action_card_refs[z] == dice_cmd.effect.target_card_ref) {
as_action_card_refs_contains_set_card_ref = true;
break;
}
auto action_ce = this->server()->definition_for_card_ref(as.action_card_refs[z]);
if (action_ce && (action_ce->def.card_id == action_ce->def.card_id)) {
as_action_card_refs_contains_duplicate_of_set_card = true;
}
}
bool unknown_v1 = as_action_card_refs_contains_duplicate_of_set_card && as_action_card_refs_contains_set_card_ref;
uint8_t random_percent = this->server() ? this->server()->get_random(99) : 0;
bool any_expr_used_dice_roll = false;
DiceRoll dice_roll;
uint8_t client_id = client_id_for_card_ref(dice_cmd.effect.target_card_ref);
auto set_card_ps = (client_id == 0xFF) ? nullptr : this->server()->player_states[client_id];
dice_roll.value = 1;
if (set_card_ps) {
dice_roll.value = set_card_ps->roll_dice_with_effects(1);
}
dice_roll.client_id = client_id;
dice_roll.unknown_a2 = 3;
dice_roll.value_used_in_expr = false;
for (size_t def_effect_index = 0; (def_effect_index < 3) && !unknown_v1 && (ce->def.effects[def_effect_index].type != ConditionType::NONE); def_effect_index++) {
const auto& card_effect = ce->def.effects[def_effect_index];
if (card_effect.when != when) {
continue;
}
{
string as_s = as.str();
string eff_s = card_effect.str();
this->server()->base()->log.debug("(when=%" PRIu32 ") set=@%04hX sc=@%04hX as=%s att=@%04hX eff=%s",
when, set_card_ref, sc_card_ref, as_s.c_str(), as_attacker_card_ref, eff_s.c_str());
}
int16_t arg3_value = atoi(&card_effect.arg3[1]);
auto targeted_cards = this->get_targeted_cards_for_condition(
set_card_ref, def_effect_index, sc_card_ref, as, arg3_value, 1);
bool all_targets_matched = false;
if (!targeted_cards.empty() &&
((card_effect.type == ConditionType::UNKNOWN_64) ||
(card_effect.type == ConditionType::MISC_DEFENSE_BONUSES) ||
(card_effect.type == ConditionType::MOSTLY_HALFGUARDS))) {
size_t count = 0;
for (size_t z = 0; z < targeted_cards.size(); z++) {
dice_roll.value_used_in_expr = false;
string arg2_text = card_effect.arg2;
if (this->evaluate_effect_arg2_condition(
as, targeted_cards[z], arg2_text.c_str(), dice_roll,
set_card_ref, sc_card_ref, random_percent, when)) {
count++;
}
if (dice_roll.value_used_in_expr) {
any_expr_used_dice_roll = true;
}
}
if (count == targeted_cards.size()) {
auto set_card = this->server()->card_for_set_card_ref(set_card_ref);
if (!set_card) {
set_card = this->server()->card_for_set_card_ref(sc_card_ref);
}
targeted_cards.clear();
if (set_card != nullptr) {
targeted_cards.emplace_back(set_card);
}
all_targets_matched = true;
} else {
targeted_cards.clear();
}
}
for (size_t z = 0; z < targeted_cards.size(); z++) {
dice_roll.value_used_in_expr = false;
string arg2_str = card_effect.arg2;
if (all_targets_matched ||
this->evaluate_effect_arg2_condition(
as, targeted_cards[z], arg2_str.c_str(), dice_roll, set_card_ref, sc_card_ref, random_percent, when)) {
auto env_stats = this->compute_attack_env_stats(
as, targeted_cards[z], dice_roll, set_card_ref, sc_card_ref);
string expr_str = card_effect.expr;
int16_t value = this->evaluate_effect_expr(env_stats, expr_str.c_str(), dice_roll);
uint32_t unknown_v1 = 0;
auto target_card = this->compute_replaced_target_based_on_conditions(
targeted_cards[z]->get_card_ref(),
0,
1,
as_attacker_card_ref,
set_card_ref,
0,
nullptr,
def_effect_index,
&unknown_v1,
sc_card_ref);
if (!target_card) {
target_card = targeted_cards[z];
}
ssize_t applied_cond_index = -1;
if ((unknown_v1 == 0) && !this->should_cancel_condition_due_to_anti_abnormality(card_effect, target_card, dice_cmd.effect.target_card_ref, sc_card_ref)) {
applied_cond_index = target_card->apply_abnormal_condition(
card_effect, def_effect_index, dice_cmd.effect.target_card_ref, sc_card_ref, value, dice_roll.value, random_percent);
// This debug_print call is in the original code.
// this->debug_print(when, 4, &env_stats, "!set_abnormal..", target_card, card_effect.type);
}
if (applied_cond_index >= 0) {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(as_attacker_card_ref, 0x14);
cmd.effect.target_card_ref = target_card->get_card_ref();
cmd.effect.value = (target_card->action_chain).conditions[applied_cond_index].remaining_turns;
cmd.effect.operation = static_cast<int8_t>(card_effect.type);
this->server()->send(cmd);
}
if (dice_roll.value_used_in_expr) {
target_card->action_chain.conditions[applied_cond_index].flags |= 1;
}
if ((applied_cond_index >= 0) &&
(apply_defense_condition_to_all_cards || (apply_defense_condition_to_card_ref == targeted_cards[z]->get_card_ref()))) {
this->apply_defense_condition(
when, &target_card->action_chain.conditions[applied_cond_index], applied_cond_index, as, target_card, 4, 1);
}
target_card->send_6xB4x4E_4C_4D_if_needed(0);
}
if (dice_roll.value_used_in_expr) {
any_expr_used_dice_roll = true;
}
}
}
if (any_expr_used_dice_roll) {
dice_cmd.effect.flags = 0x08;
dice_cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(
as_attacker_card_ref, 0x15);
dice_cmd.effect.dice_roll_value = dice_roll.value;
this->server()->send(dice_cmd);
}
}
vector<shared_ptr<const Card>> CardSpecial::get_all_set_cards() const {
vector<shared_ptr<const Card>> ret;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t set_index = 0; set_index < 8; set_index++) {
auto set_card = ps->get_set_card(set_index);
if (set_card) {
ret.emplace_back(set_card);
}
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_cards_by_condition_inc_exc(
ConditionType include_cond,
ConditionType exclude_cond,
AssistEffect include_eff,
AssistEffect exclude_eff) const {
vector<shared_ptr<const Card>> ret;
auto check_card = [&](uint8_t client_id, shared_ptr<const Card> c) -> void {
if (c) {
bool should_include = false;
bool should_exclude = false;
for (size_t z = 0; z < 9; z++) {
auto type = c->action_chain.conditions[z].type;
if ((type == include_cond) || (include_cond == ConditionType::ANY_FF)) {
should_include = true;
}
if ((type == exclude_cond) && (exclude_cond != ConditionType::NONE)) {
should_exclude = true;
}
}
size_t num_assists = this->server()->assist_server->compute_num_assist_effects_for_client(client_id);
for (size_t z = 0; z < num_assists; z++) {
auto eff = this->server()->assist_server->get_active_assist_by_index(z);
if ((exclude_eff != AssistEffect::NONE) &&
((include_eff == AssistEffect::ANY) || (include_eff == eff))) {
should_include = true;
}
if ((exclude_eff != AssistEffect::NONE) && (exclude_eff == eff)) {
should_exclude = true;
}
}
if (should_include && !should_exclude) {
ret.emplace_back(c);
}
}
};
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
continue;
}
for (size_t set_index = 0; set_index < 8; set_index++) {
check_card(client_id, ps->get_set_card(set_index));
}
check_card(client_id, ps->get_sc_card());
}
return ret;
}
void CardSpecial::clear_invalid_conditions_on_card(
shared_ptr<Card> card, const ActionState& as) {
for (size_t cond_index = 0; cond_index < 9; cond_index++) {
auto& cond = card->action_chain.conditions[cond_index];
if (cond.type != ConditionType::NONE) {
if (!this->is_card_targeted_by_condition(cond, as, card)) {
if (cond.type != ConditionType::NONE) {
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = 0xFFFF;
cmd.effect.target_card_ref = card->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = -static_cast<int8_t>(cond.type);
this->server()->send(cmd);
}
this->apply_stat_deltas_to_card_from_condition_and_clear_cond(cond, card);
card->send_6xB4x4E_4C_4D_if_needed();
}
}
}
}
const InterferenceProbabilityEntry* get_interference_probability_entry(
uint16_t row_card_id,
uint16_t column_card_id,
bool is_attack) {
static const InterferenceProbabilityEntry entries[] = {
{0x0004, 0xFF, 0xFF},
{0x0002, 0x04, 0x00},
{0x0002, 0x00, 0x0F},
{0x0003, 0x03, 0x00},
{0x0003, 0x00, 0x0A},
{0x0006, 0x01, 0x00},
{0x0006, 0x00, 0x05},
{0x0111, 0x01, 0x00},
{0x0111, 0x00, 0x05},
{0x0001, 0x03, 0x00},
{0x0001, 0x00, 0x0A},
{0x0002, 0xFF, 0xFF},
{0x0004, 0x04, 0x00},
{0x0004, 0x00, 0x0F},
{0x0003, 0x06, 0x00},
{0x0003, 0x00, 0x14},
{0x0006, 0x04, 0x00},
{0x0006, 0x00, 0x0F},
{0x0003, 0xFF, 0xFF},
{0x0004, 0x04, 0x00},
{0x0004, 0x00, 0x0F},
{0x0002, 0x04, 0x00},
{0x0002, 0x00, 0x0F},
{0x0006, 0xFF, 0xFF},
{0x0002, 0x06, 0x00},
{0x0002, 0x00, 0x14},
{0x0111, 0xFF, 0xFF},
{0x0004, 0x01, 0x00},
{0x0004, 0x00, 0x05},
{0x0001, 0x06, 0x00},
{0x0001, 0x00, 0x14},
{0x0001, 0xFF, 0xFF},
{0x0111, 0x04, 0x00},
{0x0111, 0x00, 0x0F},
{0x0112, 0xFF, 0xFF},
{0x0113, 0x06, 0x00},
{0x0113, 0x00, 0x14},
{0x0110, 0x06, 0x00},
{0x0110, 0x00, 0x14},
{0x0114, 0x01, 0x00},
{0x0114, 0x00, 0x05},
{0x011D, 0x02, 0x00},
{0x011D, 0x00, 0x07},
{0x0113, 0xFF, 0xFF},
{0x0003, 0x03, 0x00},
{0x0003, 0x00, 0x0A},
{0x0112, 0x03, 0x00},
{0x0112, 0x00, 0x0A},
{0x0110, 0xFF, 0xFF},
{0x0005, 0x03, 0x00},
{0x0005, 0x00, 0x0A},
{0x0112, 0x04, 0x00},
{0x0112, 0x00, 0x0F},
{0x0005, 0xFF, 0xFF},
{0x0110, 0x03, 0x00},
{0x0110, 0x00, 0x0A},
{0x0114, 0xFF, 0xFF},
{0x0005, 0x03, 0x00},
{0x0005, 0x00, 0x0A},
{0x0110, 0x01, 0x00},
{0x0110, 0x00, 0x05},
{0x0115, 0x06, 0x00},
{0x0115, 0x00, 0x14},
{0x0115, 0xFF, 0xFF},
{0x0004, 0x01, 0x00},
{0x0004, 0x00, 0x05},
{0x0003, 0x01, 0x00},
{0x0003, 0x00, 0x05},
{0x0006, 0x01, 0x00},
{0x0006, 0x00, 0x05},
{0x0112, 0x01, 0x00},
{0x0112, 0x00, 0x05},
{0x0110, 0x01, 0x00},
{0x0110, 0x00, 0x05},
{0x0114, 0x04, 0x00},
{0x0114, 0x00, 0x0F},
{0x0008, 0xFF, 0xFF},
{0x0007, 0x06, 0x00},
{0x0007, 0x00, 0x14},
{0x0116, 0x01, 0x00},
{0x0116, 0x00, 0x05},
{0x011E, 0x03, 0x00},
{0x011E, 0x00, 0x0A},
{0x0118, 0x06, 0x00},
{0x0118, 0x00, 0x14},
{0x0007, 0xFF, 0xFF},
{0x0008, 0x06, 0x00},
{0x0008, 0x00, 0x14},
{0x0118, 0x01, 0x00},
{0x0118, 0x00, 0x05},
{0x011B, 0x03, 0x00},
{0x011B, 0x00, 0x0A},
{0x0116, 0xFF, 0xFF},
{0x0008, 0x01, 0x00},
{0x0008, 0x00, 0x05},
{0x011C, 0x03, 0x00},
{0x011C, 0x00, 0x0A},
{0x011A, 0xFF, 0xFF},
{0x0119, 0x04, 0x00},
{0x0119, 0x00, 0x0F},
{0x011D, 0x04, 0x00},
{0x011D, 0x00, 0x0F},
{0x0119, 0xFF, 0xFF},
{0x011A, 0x04, 0x00},
{0x011A, 0x00, 0x0F},
{0x011D, 0x04, 0x00},
{0x011D, 0x00, 0x0F},
{0x011D, 0xFF, 0xFF},
{0x0119, 0x04, 0x00},
{0x0119, 0x00, 0x0F},
{0x011A, 0x04, 0x00},
{0x011A, 0x00, 0x0F},
{0x0112, 0x01, 0x00},
{0x0112, 0x00, 0x07},
{0x011E, 0xFF, 0xFF},
{0x0008, 0x03, 0x00},
{0x0008, 0x00, 0x0A},
{0x0118, 0x06, 0x00},
{0x0118, 0x00, 0x14},
{0x011C, 0xFF, 0xFF},
{0x0116, 0x04, 0x00},
{0x0116, 0x00, 0x0F},
{0x011E, 0x01, 0x00},
{0x011E, 0x00, 0x05},
{0x0118, 0xFF, 0xFF},
{0x011E, 0x06, 0x00},
{0x011E, 0x00, 0x14},
{0x011B, 0xFF, 0xFF},
{0x0007, 0x03, 0x00},
{0x0007, 0x00, 0x0A},
{0x0117, 0x03, 0x00},
{0x0117, 0x00, 0x0A},
{0x011F, 0x06, 0x00},
{0x011F, 0x00, 0x14},
{0x0117, 0xFF, 0xFF},
{0x011F, 0x03, 0x00},
{0x011F, 0x00, 0x0A},
{0x011B, 0x04, 0x00},
{0x011B, 0x00, 0x0F},
{0x011F, 0xFF, 0xFF},
{0x0007, 0x01, 0x00},
{0x0007, 0x00, 0x05},
{0x011B, 0x06, 0x00},
{0x011B, 0x00, 0x14},
{0x0117, 0x04, 0x00},
{0x0117, 0x00, 0x0F},
};
constexpr size_t num_entries = sizeof(entries) / sizeof(entries[0]);
const InterferenceProbabilityEntry* ret_entry = nullptr;
int16_t current_max = -1;
size_t logical_index = 0;
uint16_t current_row_card_id = 0xFFFF;
for (size_t z = 0; z < num_entries; z++) {
const auto& entry = entries[z];
uint16_t current_column_card_id = entry.card_id;
if ((entry.attack_probability != 0xFF) || (entry.defense_probability != 0xFF)) {
if ((row_card_id == current_row_card_id) &&
(column_card_id == current_column_card_id)) {
uint8_t v = is_attack ? entry.attack_probability : entry.defense_probability;
if (current_max <= v) {
ret_entry = &entry;
current_max = v;
}
}
logical_index++;
} else {
current_row_card_id = current_column_card_id;
}
}
return ret_entry;
}
void CardSpecial::on_card_destroyed(
shared_ptr<Card> attacker_card, shared_ptr<Card> destroyed_card) {
ActionState attack_as = this->create_attack_state_from_card_action_chain(attacker_card);
ActionState defense_as = this->create_defense_state_for_card_pair_action_chains(
attacker_card, destroyed_card);
uint16_t destroyed_card_ref = destroyed_card->get_card_ref();
this->unknown_8024C2B0(5, destroyed_card_ref, defense_as, 0xFFFF);
for (size_t z = 0; (z < 8) && (defense_as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(
5, defense_as.action_card_refs[z], defense_as, destroyed_card->get_card_ref());
}
if (attacker_card) {
for (size_t cond_index = 0; cond_index < 9; cond_index++) {
auto& cond = attacker_card->action_chain.conditions[cond_index];
if (cond.type == ConditionType::CURSE) {
this->execute_effect(cond, attacker_card, 0, 0, ConditionType::CURSE, 4, 0xFFFF);
}
}
}
this->send_6xB4x06_for_card_destroyed(destroyed_card, attack_as.attacker_card_ref);
}
vector<shared_ptr<const Card>> CardSpecial::find_cards_in_hp_range(
int16_t min, int16_t max) const {
vector<shared_ptr<const Card>> ret;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
auto card = ps->get_sc_card();
if (card) {
int16_t hp = card->get_current_hp();
if ((min <= hp) && (hp <= max)) {
ret.emplace_back(card);
}
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card) {
int16_t hp = card->get_current_hp();
if ((min <= hp) && (hp <= max)) {
ret.emplace_back(card);
}
}
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_all_cards_by_aerial_attribute(bool is_aerial) const {
vector<shared_ptr<const Card>> ret;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card && (this->server()->ruler_server->card_ref_is_aerial(card->get_card_ref()) == is_aerial)) {
ret.emplace_back(card);
}
}
auto card = ps->get_sc_card();
if (card && (this->server()->ruler_server->card_ref_is_aerial(card->get_card_ref()) == is_aerial)) {
ret.emplace_back(card);
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_cards_damaged_by_at_least(int16_t damage) const {
vector<shared_ptr<const Card>> ret;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card && (damage + card->get_current_hp() <= card->get_max_hp())) {
ret.emplace_back(card);
}
}
auto card = ps->get_sc_card();
if (card) {
if (damage + card->get_current_hp() <= card->get_max_hp()) {
ret.emplace_back(card);
}
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_all_set_cards_on_client_team(uint8_t client_id) const {
vector<shared_ptr<const Card>> ret;
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
return ret;
}
for (size_t other_client_id = 0; other_client_id < 4; other_client_id++) {
auto other_ps = this->server()->get_player_state(other_client_id);
if (other_ps && (other_ps->get_team_id() == ps->get_team_id())) {
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = other_ps->get_set_card(set_index);
if (card) {
ret.emplace_back(card);
}
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_all_cards_on_same_or_other_team(uint8_t client_id, bool same_team) const {
vector<shared_ptr<const Card>> ret;
auto ps = this->server()->get_player_state(client_id);
if (!ps) {
return ret;
}
for (size_t other_client_id = 0; other_client_id < 4; other_client_id++) {
auto other_ps = this->server()->get_player_state(other_client_id);
if (other_ps) {
bool should_collect = false;
if (!same_team) {
if ((other_ps->get_team_id() != 0xFF) && (ps->get_team_id() != other_ps->get_team_id())) {
should_collect = true;
}
} else {
if (ps->get_team_id() == other_ps->get_team_id()) {
should_collect = true;
}
}
if (should_collect) {
auto card = other_ps->get_sc_card();
if (card) {
ret.emplace_back(card);
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = other_ps->get_set_card(set_index);
if (card) {
ret.emplace_back(card);
}
}
}
}
}
return ret;
}
shared_ptr<const Card> CardSpecial::sc_card_for_client_id(uint8_t client_id) const {
auto ps = this->server()->get_player_state(client_id);
return ps ? ps->get_sc_card() : nullptr;
}
shared_ptr<const Card> CardSpecial::get_attacker_card(const ActionState& as) const {
uint32_t card_ref = as.attacker_card_ref;
if (card_ref == 0xFFFF) {
card_ref = as.original_attacker_card_ref;
}
auto card = this->server()->card_for_set_card_ref(card_ref);
if (card) {
auto ce = card->get_definition();
if ((ce->def.type == CardType::ITEM) || (ce->def.type == CardType::CREATURE)) {
return card;
}
}
return nullptr;
}
vector<shared_ptr<const Card>> CardSpecial::get_attacker_card_and_sc_if_item(const ActionState& as) const {
vector<shared_ptr<const Card>> ret;
uint16_t card_ref = as.attacker_card_ref;
if (card_ref == 0xFFFF) {
card_ref = as.original_attacker_card_ref;
}
auto card = this->server()->card_for_set_card_ref(card_ref);
if (card) {
auto ce = card->get_definition();
if (ce->def.type == CardType::ITEM) {
auto ps = card->player_state();
if (ps) {
ret.emplace_back(ps->get_sc_card());
}
ret.emplace_back(card);
} else {
if ((ce->def.type == CardType::HUNTERS_SC) ||
(ce->def.type == CardType::ARKZ_SC) ||
(ce->def.type == CardType::CREATURE)) {
ret.emplace_back(card);
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::find_all_set_cards_with_cost_in_range(uint8_t min_cost, uint8_t max_cost) const {
vector<shared_ptr<const Card>> ret;
for (size_t client_id = 0; client_id < 4; client_id++) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card) {
auto ce = card->get_definition();
if (ce && (min_cost <= ce->def.self_cost) && (ce->def.self_cost <= max_cost)) {
ret.emplace_back(card);
}
}
}
}
}
return ret;
}
vector<shared_ptr<const Card>> CardSpecial::filter_cards_by_range(
const vector<shared_ptr<const Card>>& cards,
shared_ptr<const Card> card1,
const Location& card1_loc,
shared_ptr<const Card> card2) const {
vector<shared_ptr<const Card>> ret;
if (!card1 || cards.empty()) {
return ret;
}
auto ps = card1->player_state();
if (!ps) {
return ret;
}
// TODO: Remove hardcoded card ID here (Earthquake)
uint16_t card_id = this->get_card_id_with_effective_range(card1, 0x00ED, card2);
parray<uint8_t, 9 * 9> range;
compute_effective_range(range, this->server()->base()->data_index, card_id, card1_loc, this->server()->base()->map_and_rules1);
auto card_refs_in_range = ps->get_card_refs_within_range_from_all_players(range, card1_loc, CardType::ITEM);
for (auto card : cards) {
if (!card || (card->get_card_ref() == 0xFFFF)) {
continue;
}
for (uint16_t card_ref_in_range : card_refs_in_range) {
if (card_ref_in_range == card->get_card_ref()) {
ret.emplace_back(card);
break;
}
}
}
return ret;
}
void CardSpecial::unknown_8024AAB8(const ActionState& as) {
this->unknown_action_state_a1 = as;
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
uint16_t card_ref = this->send_6xB4x06_if_card_ref_invalid(
as.action_card_refs[z], 0x1E);
if (card_ref == 0xFFFF) {
break;
}
if (this->send_6xB4x06_if_card_ref_invalid(as.original_attacker_card_ref, 0x1F) == 0xFFFF) {
this->unknown_8024C2B0(
1,
as.action_card_refs[z],
as,
this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x21));
this->unknown_8024C2B0(
0xb,
as.action_card_refs[z],
as,
this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x22));
} else {
uint16_t card_ref = this->send_6xB4x06_if_card_ref_invalid(as.target_card_refs[0], 0x20);
if (card_ref != 0xFFFF) {
this->unknown_8024C2B0(1, as.action_card_refs[z], as, card_ref);
this->unknown_8024C2B0(0x15, as.action_card_refs[z], as, card_ref);
}
}
}
if (as.original_attacker_card_ref == 0xffff) {
uint16_t card_ref1 = this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x23);
uint16_t card_ref2 = this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x25);
this->unknown_8024C2B0(0x33, card_ref2, as, card_ref1);
card_ref1 = this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x24);
card_ref2 = this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x26);
this->unknown_8024C2B0(0x34, card_ref2, as, card_ref1);
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
uint16_t card_ref = this->send_6xB4x06_if_card_ref_invalid(
as.action_card_refs[z], 0x27);
if (card_ref == 0xFFFF) {
break;
}
this->unknown_8024C2B0(0x35, as.target_card_refs[z], as, as.attacker_card_ref);
}
}
}
void CardSpecial::unknown_80244BE4(shared_ptr<Card> card) {
ActionState as = this->create_attack_state_from_card_action_chain(card);
this->apply_defense_conditions(as, 9, card, 4);
this->unknown_8024C2B0(9, card->get_card_ref(), as, 0xFFFF);
this->apply_defense_conditions(as, 0x27, card, 4);
this->unknown_8024C2B0(0x27, card->get_card_ref(), as, 0xFFFF);
}
void CardSpecial::unknown_80244CA8(shared_ptr<Card> card) {
ActionState as;
auto ps = card->player_state();
as.attacker_card_ref = card->get_card_ref();
as.action_card_refs = card->action_chain.chain.attack_action_card_refs;
as.target_card_refs = card->action_chain.chain.target_card_refs;
uint16_t sc_card_ref = 0xFFFF;
if (ps) {
auto sc_card = ps->get_sc_card();
if (sc_card) {
sc_card_ref = sc_card->get_card_ref();
}
}
this->apply_defense_conditions(as, 0x46, card, 4);
this->unknown_8024C2B0(0x46, card->get_card_ref(), as, sc_card_ref);
if (ps->is_team_turn()) {
this->apply_defense_conditions(as, 4, card, 4);
this->unknown_8024C2B0(4, card->get_card_ref(), as, sc_card_ref);
}
}
template <uint8_t When1, uint8_t When2>
void CardSpecial::unknown1_t(
shared_ptr<Card> unknown_p2, const ActionState* existing_as) {
ActionState as;
if (!existing_as) {
as = this->create_attack_state_from_card_action_chain(unknown_p2);
} else {
as = *existing_as;
}
this->apply_defense_conditions(as, When1, unknown_p2, 4);
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (card) {
ActionState target_as = this->create_defense_state_for_card_pair_action_chains(unknown_p2, card);
this->apply_defense_conditions(target_as, When1, card, 4);
}
}
auto card = this->sc_card_for_card(unknown_p2);
this->unknown_8024C2B0(When1, unknown_p2->get_card_ref(), as, card ? card->get_card_ref() : 0xFFFF);
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(When1, as.action_card_refs[z], as, unknown_p2->get_card_ref());
}
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (card) {
ActionState target_as = this->create_defense_state_for_card_pair_action_chains(
unknown_p2, card);
this->unknown_8024C2B0(When2, as.target_card_refs[z], target_as, unknown_p2->get_card_ref());
for (size_t w = 0; (w < 8) && (target_as.action_card_refs[w] != 0xFFFF); w++) {
this->unknown_8024C2B0(When1, target_as.action_card_refs[w], target_as, card->get_card_ref());
}
}
}
}
void CardSpecial::unknown_80249060(shared_ptr<Card> unknown_p2) {
this->unknown1_t<0x0F, 0x0A>(unknown_p2);
}
void CardSpecial::unknown_80249254(shared_ptr<Card> unknown_p2) {
if (unknown_p2->player_state()->is_team_turn()) {
this->unknown1_t<0x0E, 0x0A>(unknown_p2);
}
}
void CardSpecial::unknown_8024945C(shared_ptr<Card> unknown_p2, const ActionState& existing_as) {
this->unknown1_t<0x0A, 0x0A>(unknown_p2, &existing_as);
}
void CardSpecial::unknown_8024966C(shared_ptr<Card> unknown_p2, const ActionState* existing_as) {
ActionState as;
if (!existing_as) {
as = this->create_attack_state_from_card_action_chain(unknown_p2);
} else {
as = *existing_as;
}
auto card = this->sc_card_for_card(unknown_p2);
uint16_t card_ref = card ? card->get_card_ref() : 0xFFFF;
auto ce = unknown_p2->get_definition();
auto defender_card = (ce && (ce->def.type == CardType::ITEM) && card) ? card : unknown_p2;
this->apply_defense_conditions(as, 0x3D, unknown_p2, 4);
this->apply_defense_conditions(as, 0x3E, unknown_p2, 4);
if (defender_card) {
this->apply_defense_conditions(as, 0x22, defender_card, 4);
}
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (card) {
ActionState defense_as = this->create_defense_state_for_card_pair_action_chains(unknown_p2, card);
this->apply_defense_conditions(defense_as, 0x3D, card, 4);
this->apply_defense_conditions(defense_as, 0x3F, card, 4);
}
}
this->unknown_8024C2B0(0x3D, unknown_p2->get_card_ref(), as, card_ref);
this->unknown_8024C2B0(0x3E, unknown_p2->get_card_ref(), as, card_ref);
if (defender_card) {
this->unknown_8024C2B0(0x22, defender_card->get_card_ref(), as, card_ref);
}
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(0x3D, as.action_card_refs[z], as, unknown_p2->get_card_ref());
this->unknown_8024C2B0(0x3E, as.action_card_refs[z], as, unknown_p2->get_card_ref());
}
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (card) {
ActionState defense_as = this->create_defense_state_for_card_pair_action_chains(unknown_p2, card);
this->unknown_8024C2B0(0x3D, card->get_card_ref(), defense_as, unknown_p2->get_card_ref());
this->unknown_8024C2B0(0x3F, card->get_card_ref(), defense_as, unknown_p2->get_card_ref());
}
}
}
shared_ptr<Card> CardSpecial::sc_card_for_card(shared_ptr<Card> unknown_p2) {
auto ps = unknown_p2->player_state();
return ps ? ps->get_sc_card() : nullptr;
}
void CardSpecial::unknown_8024A9D8(const ActionState& pa, uint16_t action_card_ref) {
for (size_t z = 0; (z < 8) && (pa.action_card_refs[z] != 0xFFFF); z++) {
if ((action_card_ref == 0xFFFF) || (action_card_ref == pa.action_card_refs[z])) {
if (pa.original_attacker_card_ref == 0xFFFF) {
this->unknown_8024C2B0(0x29, pa.action_card_refs[z], pa, pa.attacker_card_ref);
this->unknown_8024C2B0(0x2A, pa.action_card_refs[z], pa, pa.attacker_card_ref);
} else {
this->unknown_8024C2B0(0x29, pa.action_card_refs[z], pa, pa.target_card_refs[0]);
this->unknown_8024C2B0(0x2B, pa.action_card_refs[z], pa, pa.target_card_refs[0]);
}
}
}
}
void CardSpecial::check_for_attack_interference(shared_ptr<Card> unknown_p2) {
// Note: This check is not part of the original implementation.
if (this->server()->base()->data_index->behavior_flags & BehaviorFlag::DISABLE_INTERFERENCE) {
return;
}
if (unknown_p2->action_chain.chain.damage <= 0) {
return;
}
uint16_t ally_sc_card_ref = this->server()->ruler_server->get_ally_sc_card_ref(
unknown_p2->get_card_ref());
if (ally_sc_card_ref == 0xFFFF) {
return;
}
uint8_t ally_client_id = client_id_for_card_ref(ally_sc_card_ref);
if (ally_client_id == 0xFF) {
return;
}
auto ally_sc_card = this->server()->card_for_set_card_ref(ally_sc_card_ref);
if (!ally_sc_card || (ally_sc_card->card_flags & 2)) {
return;
}
uint8_t client_id = client_id_for_card_ref(unknown_p2->get_card_ref());
if (client_id == 0xFF) {
return;
}
auto ally_hes = this->server()->ruler_server->get_hand_and_equip_state_for_client_id(ally_client_id);
if (!ally_hes || !ally_hes->is_cpu_player) {
return;
}
this->server()->ruler_server->get_hand_and_equip_state_for_client_id(client_id);
auto ps = unknown_p2->player_state();
if (!ps || (ps->unknown_a16 >= 1)) {
return;
}
uint16_t card_ref = unknown_p2->get_card_ref();
if ((unknown_p2->get_definition()->def.type == CardType::ITEM) && ps->get_sc_card()) {
card_ref = ps->get_sc_card()->get_card_ref();
}
uint16_t row_card_id = this->server()->card_id_for_card_ref(card_ref);
if (row_card_id == 0xFFFF) {
return;
}
uint16_t ally_sc_card_id = this->server()->card_id_for_card_ref(ally_sc_card_ref);
if (ally_sc_card_id == 0xFFFF) {
return;
}
const auto* entry = get_interference_probability_entry(
row_card_id, ally_sc_card_id, true);
if (!entry || (this->server()->get_random(99) >= entry->attack_probability)) {
return;
}
ps->unknown_a16++;
unknown_p2->action_chain.set_flags(0x100);
G_ApplyConditionEffect_GC_Ep3_6xB4x06 cmd;
cmd.effect.flags = 0x04;
cmd.effect.attacker_card_ref = this->send_6xB4x06_if_card_ref_invalid(
unknown_p2->get_card_ref(), 0x11);
cmd.effect.target_card_ref = unknown_p2->get_card_ref();
cmd.effect.value = 0;
cmd.effect.operation = 0x7D;
this->server()->send(cmd);
}
template <uint8_t When1, uint8_t When2, uint8_t When3, uint8_t When4>
void CardSpecial::unknown_t2(shared_ptr<Card> unknown_p2) {
ActionState as = this->create_attack_state_from_card_action_chain(unknown_p2);
auto sc_card = this->sc_card_for_card(unknown_p2);
uint16_t sc_card_ref = 0xFFFF;
if (sc_card) {
sc_card_ref = sc_card->get_card_ref();
}
auto defender_card = unknown_p2;
if (unknown_p2->get_definition() &&
(unknown_p2->get_definition()->def.type == CardType::ITEM) &&
sc_card) {
defender_card = sc_card;
}
this->apply_defense_conditions(as, When1, unknown_p2, 4);
this->apply_defense_conditions(as, When2, unknown_p2, 4);
if (defender_card) {
this->apply_defense_conditions(as, When3, defender_card, 4);
}
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto set_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (set_card) {
ActionState target_as = this->create_defense_state_for_card_pair_action_chains(
unknown_p2, set_card);
this->apply_defense_conditions(target_as, When1, set_card, 4);
this->apply_defense_conditions(target_as, When4, set_card, 4);
}
}
this->unknown_8024C2B0(When1, unknown_p2->get_card_ref(), as, sc_card_ref);
this->unknown_8024C2B0(When2, unknown_p2->get_card_ref(), as, sc_card_ref);
if (defender_card) {
this->unknown_8024C2B0(When3, defender_card->get_card_ref(), as, sc_card_ref);
}
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(When1, as.action_card_refs[z], as, unknown_p2->get_card_ref());
this->unknown_8024C2B0(When2, as.action_card_refs[z], as, unknown_p2->get_card_ref());
}
for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) {
auto set_card = this->server()->card_for_set_card_ref(as.target_card_refs[z]);
if (set_card) {
ActionState target_as = this->create_defense_state_for_card_pair_action_chains(unknown_p2, set_card);
this->unknown_8024C2B0(When1, set_card->get_card_ref(), target_as, unknown_p2->get_card_ref());
this->unknown_8024C2B0(When4, set_card->get_card_ref(), target_as, unknown_p2->get_card_ref());
for (size_t z = 0; (z < 8) && (target_as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(When1, target_as.action_card_refs[z], target_as, set_card->get_card_ref());
this->unknown_8024C2B0(When4, target_as.action_card_refs[z], target_as, set_card->get_card_ref());
}
}
}
}
void CardSpecial::unknown_8024997C(shared_ptr<Card> card) {
return this->unknown_t2<0x03, 0x0D, 0x21, 0x17>(card);
}
void CardSpecial::unknown_8024A394(shared_ptr<Card> card) {
return this->unknown_t2<0x02, 0x0C, 0x20, 0x16>(card);
}
bool CardSpecial::client_has_atk_dice_boost_condition(uint8_t client_id) {
auto ps = this->server()->get_player_state(client_id);
if (ps) {
auto card = ps->get_sc_card();
if (card) {
for (size_t z = 0; z < 9; z++) {
if (!this->card_ref_has_ability_trap(card->action_chain.conditions[z]) &&
(card->action_chain.conditions[z].type == ConditionType::ATK_DICE_BOOST)) {
return true;
}
}
}
for (size_t set_index = 0; set_index < 8; set_index++) {
auto card = ps->get_set_card(set_index);
if (card) {
for (size_t z = 0; z < 9; z++) {
if (!this->card_ref_has_ability_trap(card->action_chain.conditions[z]) &&
(card->action_chain.conditions[z].type == ConditionType::ATK_DICE_BOOST)) {
return true;
}
}
}
}
}
return false;
}
void CardSpecial::unknown_8024A6DC(
shared_ptr<Card> unknown_p2, shared_ptr<Card> unknown_p3) {
ActionState as = this->create_defense_state_for_card_pair_action_chains(
unknown_p2, unknown_p3);
for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) {
this->unknown_8024C2B0(1, as.action_card_refs[z], as, unknown_p3->get_card_ref());
this->unknown_8024C2B0(0x15, as.action_card_refs[z], as, unknown_p3->get_card_ref());
}
}
vector<shared_ptr<const Card>> CardSpecial::find_all_sc_cards_of_class(
CardClass card_class) const {
vector<shared_ptr<const Card>> ret;
for (size_t z = 0; z < 4; z++) {
auto ps = this->server()->get_player_state(z);
if (ps) {
auto sc_card = ps->get_sc_card();
if (sc_card && (sc_card->get_definition()->def.card_class() == card_class)) {
ret.emplace_back(sc_card);
}
}
}
return ret;
}
} // namespace Episode3
Reference in New Issue View Git Blame Copy Permalink