#include "Server.hh" #include using namespace std; namespace Episode3 { static uint16_t ref_for_card(shared_ptr card) { if (card) { return card->get_card_ref(); } else { return 0xFFFF; } } template static string refs_str_for_cards_vector(const vector>& cards) { string ret; for (const auto& card : cards) { if (!ret.empty()) { ret += ", "; } ret += std::format("@{:04X}", ref_for_card(card)); } return ret; } 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->non_target_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_bonus = 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->final_last_attack_damage = 0; this->last_attack_damage_count = 0; this->target_current_hp = 0; } uint32_t CardSpecial::AttackEnvStats::at(size_t index) const { static_assert(sizeof(parray) == sizeof(AttackEnvStats), "CardSpecial::AttackEnvStats does not have exactly 39 entries"); return reinterpret_cast*>(this)->at(index); } void CardSpecial::AttackEnvStats::print(FILE* stream) const { phosg::fwrite_fmt(stream, "(a) total_num_set_cards = {}\n", this->total_num_set_cards); phosg::fwrite_fmt(stream, "(ab) num_a_beast_creatures = {}\n", this->num_a_beast_creatures); phosg::fwrite_fmt(stream, "(ac) player_num_atk_points = {}\n", this->player_num_atk_points); phosg::fwrite_fmt(stream, "(adm) sc_effective_ap = {}\n", this->sc_effective_ap); phosg::fwrite_fmt(stream, "(ap) effective_ap = {}\n", this->effective_ap); phosg::fwrite_fmt(stream, "(bi) num_native_creatures = {}\n", this->num_native_creatures); phosg::fwrite_fmt(stream, "(cs) card_cost = {}\n", this->card_cost); phosg::fwrite_fmt(stream, "(d) dice_roll_value1 = {}\n", this->dice_roll_value1); phosg::fwrite_fmt(stream, "(dc) dice_roll_value2 = {}\n", this->dice_roll_value2); phosg::fwrite_fmt(stream, "(ddm) attack_bonus = {}\n", this->attack_bonus); phosg::fwrite_fmt(stream, "(df) num_destroyed_ally_fcs = {}\n", this->num_destroyed_ally_fcs); phosg::fwrite_fmt(stream, "(dk) num_dark_creatures = {}\n", this->num_dark_creatures); phosg::fwrite_fmt(stream, "(dm) effective_ap_if_not_tech = {}\n", this->effective_ap_if_not_tech); phosg::fwrite_fmt(stream, "(dn) unknown_a1 = {}\n", this->unknown_a1); phosg::fwrite_fmt(stream, "(edm) target_attack_bonus = {}\n", this->target_attack_bonus); phosg::fwrite_fmt(stream, "(ef) non_target_team_num_set_cards = {}\n", this->non_target_team_num_set_cards); phosg::fwrite_fmt(stream, "(ehp) target_current_hp = {}\n", this->target_current_hp); phosg::fwrite_fmt(stream, "(f) num_set_cards = {}\n", this->num_set_cards); phosg::fwrite_fmt(stream, "(fdm) final_last_attack_damage = {}\n", this->final_last_attack_damage); phosg::fwrite_fmt(stream, "(ff) target_team_num_set_cards = {}\n", this->target_team_num_set_cards); phosg::fwrite_fmt(stream, "(gn) num_gun_type_items = {}\n", this->num_gun_type_items); phosg::fwrite_fmt(stream, "(hf) num_item_or_creature_cards_in_hand = {}\n", this->num_item_or_creature_cards_in_hand); phosg::fwrite_fmt(stream, "(hp) current_hp = {}\n", this->current_hp); phosg::fwrite_fmt(stream, "(kap) action_cards_ap = {}\n", this->action_cards_ap); phosg::fwrite_fmt(stream, "(ktp) action_cards_tp = {}\n", this->action_cards_tp); phosg::fwrite_fmt(stream, "(ldm) last_attack_preliminary_damage = {}\n", this->last_attack_preliminary_damage); phosg::fwrite_fmt(stream, "(lv) team_dice_bonus = {}\n", this->team_dice_bonus); phosg::fwrite_fmt(stream, "(mc) num_machine_creatures = {}\n", this->num_machine_creatures); phosg::fwrite_fmt(stream, "(mhp) max_hp = {}\n", this->max_hp); phosg::fwrite_fmt(stream, "(ndm) last_attack_damage_count = {}\n", this->last_attack_damage_count); phosg::fwrite_fmt(stream, "(php) defined_max_hp = {}\n", this->defined_max_hp); phosg::fwrite_fmt(stream, "(rdm) last_attack_damage = {}\n", this->last_attack_damage); phosg::fwrite_fmt(stream, "(sa) num_sword_type_items = {}\n", this->num_sword_type_items); phosg::fwrite_fmt(stream, "(sat) num_sword_type_items_on_team = {}\n", this->num_sword_type_items_on_team); phosg::fwrite_fmt(stream, "(tdm) effective_ap_if_not_physical = {}\n", this->effective_ap_if_not_physical); phosg::fwrite_fmt(stream, "(tf) player_num_destroyed_fcs = {}\n", this->player_num_destroyed_fcs); phosg::fwrite_fmt(stream, "(tp) effective_tp = {}\n", this->effective_tp); phosg::fwrite_fmt(stream, "(tt) effective_ap_if_not_tech2 = {}\n", this->effective_ap_if_not_tech2); phosg::fwrite_fmt(stream, "(wd) num_cane_type_items = {}\n", this->num_cane_type_items); } CardSpecial::CardSpecial(shared_ptr server) : w_server(server) {} shared_ptr CardSpecial::server() { auto s = this->w_server.lock(); if (!s) { throw runtime_error("server is deleted"); } return s; } shared_ptr 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 target_card, int16_t* inout_damage, uint16_t attacker_card_ref) { auto s = this->server(); bool is_nte = s->options.is_nte(); shared_ptr attacker_card = s->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 (!is_nte && this->card_ref_has_ability_trap(cond)) { continue; } if (!s->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 (!is_nte && (*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 = s->team_exp[target_team_id]; if (exp_deduction < *inout_damage) { *inout_damage = *inout_damage - exp_deduction; s->team_exp[target_team_id] = 0; } else { s->team_exp[target_team_id] = exp_deduction - *inout_damage; exp_deduction = *inout_damage; *inout_damage = 0; } if (!is_nte) { this->send_6xB4x06_for_exp_change(target_card, attacker_card_ref, -exp_deduction, true); } this->compute_team_dice_bonus(target_team_id); } break; } case ConditionType::UNKNOWN_73: if (!is_nte && (cond.value <= *inout_damage)) { *inout_damage = 0; } break; case ConditionType::HALFGUARD: if (!is_nte && (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 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->server()->options.is_nte() || !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( EffectWhen when, shared_ptr attacker_card, shared_ptr defender_card, uint32_t flags, const ActionState* as) { auto s = this->server(); auto log = s->log_stack("apply_action_conditions: "); ActionState temp_as; if (attacker_card == defender_card) { temp_as = this->create_attack_state_from_card_action_chain(attacker_card); if (as) { log.debug_f("using action state from override"); temp_as = *as; } else { log.debug_f("using action state from attacker card"); } } else { temp_as = this->create_defense_state_for_card_pair_action_chains(attacker_card, defender_card); log.debug_f("using action state from card pair"); } 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, uint16_t condition_giver_card_ref, uint16_t attacker_card_ref) { shared_ptr 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 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( EffectWhen when, Condition* defender_cond, uint8_t cond_index, const ActionState& defense_state, shared_ptr defender_card, uint32_t flags, bool unknown_p8) { auto s = this->server(); bool is_nte = s->options.is_nte(); auto log = s->log_stack("apply_defense_condition: "); if (log.should_log(phosg::LogLevel::L_DEBUG)) { log.debug_f( "when={}, cond_index={}, defender_card=(@{:04X} #{:04X}), flags={:08X}, p8={}", phosg::name_for_enum(when), cond_index, defender_card->get_card_ref(), defender_card->get_card_id(), flags, unknown_p8 ? "true" : "false"); auto defender_cond_str = defender_cond->str(s); auto defense_state_str = defense_state.str(s); log.debug_f("defender_cond = {}", defender_cond_str); log.debug_f("defense_state = {}", defense_state_str); } if (defender_cond->type == ConditionType::NONE) { log.debug_f("no condition"); return false; } auto orig_eff = this->original_definition_for_condition(*defender_cond); if (log.should_log(phosg::LogLevel::L_DEBUG)) { auto orig_eff_str = orig_eff->str(); log.debug_f("orig_eff = {}", orig_eff_str); } uint16_t attacker_card_ref = defense_state.attacker_card_ref; if (attacker_card_ref == 0xFFFF) { attacker_card_ref = defense_state.original_attacker_card_ref; } log.debug_f("attacker_card_ref = @{:04X}", attacker_card_ref); bool defender_has_ability_trap = !is_nte && this->card_ref_has_ability_trap(*defender_cond); log.debug_f("defender_has_ability_trap = {}", defender_has_ability_trap ? "true" : "false"); if ((is_nte || (flags & 4)) && !this->is_card_targeted_by_condition(*defender_cond, defense_state, defender_card)) { log.debug_f("not targeted by condition"); if (defender_cond->type != ConditionType::NONE) { G_ApplyConditionEffect_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(defender_cond->type); s->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 == EffectWhen::AFTER_ANY_CARD_ATTACK) && (defender_cond->type == ConditionType::GUOM) && (flags & 4)) { log.debug_f("deleting guom condition"); CardShortStatus stat = defender_card->get_short_status(); if (stat.card_flags & 4) { G_ApplyConditionEffect_Ep3_6xB4x06 cmd; cmd.effect.flags = 0x04; cmd.effect.attacker_card_ref = attacker_card_ref; cmd.effect.target_card_ref = defender_card->get_card_ref(); cmd.effect.value = 0; cmd.effect.operation = -static_cast(defender_cond->type); cmd.effect.condition_index = cond_index; s->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 (s->options.is_nte()) { auto defender_ps = defender_card->player_state(); if ((when == EffectWhen::BEFORE_DRAW_PHASE) && (flags & 4) && (defender_cond->type == ConditionType::DROP) && defender_ps) { auto defender_sc_card = defender_ps->get_sc_card(); uint8_t defender_team_id = defender_ps->get_team_id(); if (defender_sc_card && s->team_exp[defender_team_id]) { G_ApplyConditionEffect_Ep3_6xB4x06 cmd; cmd.effect.flags = 0x04; cmd.effect.attacker_card_ref = defender_cond->card_ref; cmd.effect.target_card_ref = defender_sc_card->get_card_ref(); cmd.effect.value = 0; cmd.effect.operation = 0x2E; s->send(cmd); } s->team_exp[defender_team_id] = max(s->team_exp[defender_team_id] - 3, 0); this->compute_team_dice_bonus(defender_team_id); } } if ((when == EffectWhen::BEFORE_DICE_PHASE_THIS_TEAM_TURN) && (flags & 4) && !defender_has_ability_trap && (defender_cond->type == ConditionType::ACID)) { log.debug_f("applying acid"); int16_t hp = defender_card->get_current_hp(); if (hp > 0) { 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)) { log.debug_f("unsetting flag 4"); flags &= ~4; } if ((flags == 0) || defender_has_ability_trap) { log.debug_f("no condition remains to apply"); 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.decode(); int16_t expr_value = this->evaluate_effect_expr(astats, expr.c_str(), dice_roll); log.debug_f("execute_effect ..."); this->execute_effect(*defender_cond, defender_card, expr_value, defender_cond->value, orig_eff->type, flags, attacker_card_ref); if (flags & 4) { log.debug_f("recomputing action chaing results"); if (is_nte || !(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) { log.debug_f("dice roll was used; setting dice display flag"); defender_cond->flags |= 1; G_ApplyConditionEffect_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; s->send(cmd); } return true; } bool CardSpecial::apply_defense_conditions( const ActionState& as, EffectWhen when, shared_ptr 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) { auto s = this->server(); auto log = s->log_stack(std::format("apply_stat_deltas_to_card_from_condition_and_clear_cond(@{:04X} #{:04X}): ", card->get_card_ref(), card->get_card_id())); bool is_nte = s->options.is_nte(); log.debug_f("cond: {}", cond.str(s)); ConditionType cond_type = cond.type; int16_t cond_value = is_nte ? cond.value.load() : clamp(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::A_T_SWAP_0C: if (cond_flags & 2) { int16_t ap = clamp(card->ap, -99, 99); int16_t tp = clamp(card->tp, -99, 99); log.debug_f("A_T_SWAP_0C: swapping AP ({}) and TP ({})", ap, tp); if (!is_nte) { 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; } else { log.debug_f("A_T_SWAP_0C: required flag is missing"); } break; case ConditionType::A_H_SWAP: if (cond_flags & 2) { int16_t ap = clamp(card->ap, -99, 99); int16_t hp = clamp(card->get_current_hp(), -99, 99); if (hp != ap) { log.debug_f("A_H_SWAP: swapping AP ({}) and HP ({})", ap, hp); if (!is_nte) { 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, true, true); card->ap = hp; this->destroy_card_if_hp_zero(card, cond_card_ref); } else { log.debug_f("A_H_SWAP: AP ({}) == HP ({})", ap, hp); } } else { log.debug_f("A_H_SWAP: required flag is missing"); } break; case ConditionType::AP_OVERRIDE: if (cond_flags & 2) { // Note: In NTE, this case behaves intuitively, but in non-NTE, it seems // that find_condition was changed to always return null. Perhaps this // was an accident, or perhaps not, but we implement both behaviors. Condition* other_cond = is_nte ? card->find_condition(ConditionType::AP_OVERRIDE) : nullptr; if (!other_cond) { if (!is_nte) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, -cond_value, 0, 0); } card->ap = max(card->ap - cond_value, 0); log.debug_f("AP_OVERRIDE: subtracting {} from AP => {}", cond_value, card->ap); } else { other_cond->value = clamp(other_cond->value + cond_value, -99, 99); } } else { log.debug_f("AP_OVERRIDE: required flag is missing"); } break; case ConditionType::TP_OVERRIDE: if (cond_flags & 2) { // See note in the AP_OVERRIDE case about why non-NTE always uses null. Condition* other_cond = is_nte ? card->find_condition(ConditionType::TP_OVERRIDE) : nullptr; if (!other_cond) { if (!is_nte) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, -cond_value, 0, 0); } card->tp = max(card->tp - cond_value, 0); log.debug_f("TP_OVERRIDE: subtracting {} from TP => {}", cond_value, card->tp); } else { other_cond->value = clamp(other_cond->value + cond_value, -99, 99); } } else { log.debug_f("TP_OVERRIDE: required flag is missing"); } break; case ConditionType::MISC_AP_BONUSES: if (cond_flags & 2) { if (!is_nte) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, -cond_value, 0, 0); } card->ap = max(card->ap - cond_value, 0); log.debug_f("MISC_AP_BONUSES: subtracting {} from AP => {}", cond_value, card->ap); } else { log.debug_f("MISC_AP_BONUSES: required flag is missing"); } break; case ConditionType::MISC_TP_BONUSES: if (cond_flags & 2) { if (!is_nte) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, -cond_value, 0, 0); } card->tp = max(card->tp - cond_value, 0); log.debug_f("MISC_TP_BONUSES: subtracting {} from TP => {}", cond_value, card->tp); } else { log.debug_f("MISC_TP_BONUSES: required flag is missing"); } break; case ConditionType::AP_SILENCE: if (is_nte) { goto trial_unimplemented; } if (cond_flags & 2) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0xA0, cond_value, 0, 0); card->ap = max(card->ap + cond_value, 0); log.debug_f("AP_SILENCE: adding {} to AP => {}", cond_value, card->ap); } else { log.debug_f("AP_SILENCE: required flag is missing"); } break; case ConditionType::TP_SILENCE: if (is_nte) { goto trial_unimplemented; } if (cond_flags & 2) { this->send_6xB4x06_for_stat_delta(card, cond_card_ref, 0x80, cond_value, 0, 0); card->tp = max(card->tp + cond_value, 0); log.debug_f("TP_SILENCE: adding {} to TP => {}", cond_value, card->tp); } else { log.debug_f("TP_SILENCE: required flag is missing"); } break; trial_unimplemented: default: log.debug_f("{}: no adjustments for condition type", phosg::name_for_enum(cond_type)); break; } return true; } bool CardSpecial::apply_stats_deltas_to_card_from_all_conditions_with_card_ref( uint16_t card_ref, shared_ptr 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 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 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 target_card, int16_t* out_value, uint16_t attacker_card_ref) { auto s = this->server(); auto is_nte = s->options.is_nte(); auto attacker_card = s->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) -> 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 || (!is_nte && this->card_ref_has_ability_trap(cond)) || !s->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 = s->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 (!is_nte) { if (attacker_card && attacker_card->get_condition_value(ConditionType::UNKNOWN_7D)) { *out_value = *out_value * 1.5f; } if (target_card && target_card->get_condition_value(ConditionType::UNKNOWN_7D)) { *out_value = 0; } } } CardSpecial::AttackEnvStats CardSpecial::compute_attack_env_stats( const ActionState& pa, shared_ptr card, const DiceRoll& dice_roll, uint16_t target_card_ref, uint16_t condition_giver_card_ref) { auto s = this->server(); auto log = s->log_stack("compute_attack_env_stats: "); bool is_nte = s->options.is_nte(); string pa_str = pa.str(s); log.debug_f("pa={}, card=@{:04X} #{:04X}, dice_roll={}, target=@{:04X}, condition_giver=@{:04X}", pa_str, card->get_card_ref(), card->get_card_id(), dice_roll.value, target_card_ref, condition_giver_card_ref); auto attacker_card = s->card_for_set_card_ref(pa.attacker_card_ref); if (!attacker_card && (pa.original_attacker_card_ref != 0xFFFF)) { attacker_card = s->card_for_set_card_ref(pa.original_attacker_card_ref); log.debug_f("attacker=@{:04X} #{:04X} (from original)", attacker_card->get_card_ref(), attacker_card->get_card_id()); } else if (attacker_card) { log.debug_f("attacker=@{:04X} #{:04X} (from set)", attacker_card->get_card_ref(), attacker_card->get_card_id()); } else { log.debug_f("attacker=null (from set)"); } AttackEnvStats ast; auto ps = card->player_state(); log.debug_f("base ps = {}", ps->client_id); ast.num_set_cards = is_nte ? ps->count_set_cards_for_env_stats_nte() : ps->count_set_cards(); auto condition_giver_card = s->card_for_set_card_ref(condition_giver_card_ref); auto target_card = s->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 = s->get_player_state(z); if (other_ps) { ps_num_set_cards += is_nte ? other_ps->count_set_cards_for_env_stats_nte() : 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 non_target_team_num_set_cards = 0; for (size_t z = 0; z < 4; z++) { auto other_ps = s->get_player_state(z); if (other_ps) { if (target_card_team_id == other_ps->get_team_id()) { target_team_num_set_cards += is_nte ? other_ps->count_set_cards_for_env_stats_nte() : other_ps->count_set_cards(); } else { non_target_team_num_set_cards += is_nte ? other_ps->count_set_cards_for_env_stats_nte() : other_ps->count_set_cards(); } } } ast.target_team_num_set_cards = target_team_num_set_cards; ast.non_target_team_num_set_cards = non_target_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 = s->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; if (is_nte) { ast.num_destroyed_ally_fcs = s->team_num_cards_destroyed[ps->get_team_id()] - card->num_ally_fcs_destroyed_at_set_time; } else { 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_bonus = card ? s->team_dice_bonus[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 = 0; size_t last_attack_damage_count = 0; this->sum_last_attack_damage(nullptr, &total_last_attack_damage, &last_attack_damage_count); ast.final_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 = 0; uint16_t z_ref = pa.attacker_card_ref; // Note: The (z < 8) conditions in these two loops are not present in the // original code. for (z = 0; ((target_card_ref != z_ref) && (z < 8) && ((z_ref = pa.action_card_refs[z]) != 0xFFFF)); z++) { } ast.action_cards_ap = 0; ast.action_cards_tp = 0; for (; (z < 8) && (pa.action_card_refs[z] != 0xFFFF); z++) { auto ce = s->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 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 s = this->server(); bool is_nte = s->options.is_nte(); auto attacker_card = s->card_for_set_card_ref(attacker_card_ref); auto target_card = s->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 if (is_nte) { target_card_loc = target_card->loc; } 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 ((s->get_battle_phase() != BattlePhase::ACTION) || (s->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; } uint32_t pierce_flag = is_nte ? 0x00000080 : (0x00002000 << target_client_id); bool has_pierce = ((target_client_id != 0xFF) && attacker_card && (attacker_card->action_chain.check_flag(pierce_flag))); if (has_pierce && is_nte) { return nullptr; } // 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 (!is_nte && (unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) { continue; } if (cond.type == ConditionType::NONE) { continue; } if (!s->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 || (!is_nte && (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 range; compute_effective_range(range, s->options.card_index, 0x00D9, target_card_loc, s->map_and_rules); 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 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 = s->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 s->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. // Curiously, this code does not exist in NTE, so it seems it was added after // NTE but never used. vector> candidate_cards; for (size_t client_id = 0; client_id < 4; client_id++) { auto other_ps = s->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 (!is_nte && (unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) { continue; } if (cond.type == ConditionType::NONE) { continue; } if (!s->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 && (is_nte || (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 && (is_nte || (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 (!is_nte && unknown_p11 && (def_effect_index != 0xFF) && (set_card_ref != 0xFFFF) && !s->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 && (is_nte || (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 && (is_nte || (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 (!is_nte && (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 & (is_nte ? 1 : 3))) { for (size_t z = 0; (z < 9) && (candidate_cards.size() < 36); z++) { auto& cond = other_sc->action_chain.conditions[z]; if (!is_nte && (unknown_p7 == 0) && this->card_ref_has_ability_trap(cond)) { continue; } if (cond.type == ConditionType::NONE) { continue; } if (!s->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 && (is_nte || (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 && (is_nte || (unknown_p7 == 0)) && (unknown_p4 != 0) && (target_card_ref == cond.condition_giver_card_ref)) { candidate_cards.emplace_back(other_sc); if (!is_nte && unknown_p11 && (def_effect_index != 0xFF) && (set_card_ref != 0xFFFF) && !s->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 && (is_nte || (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 && (is_nte || (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 (!is_nte && (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 card) const { auto s = this->server(); auto log = s->log_stack(std::format("compute_stat_swap_type(@{:04X} #{:04X}): ", card->get_card_ref(), card->get_card_id())); if (!card) { log.debug_f("card is missing"); 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) { auto cond_log = log.sub(std::format("({}) ", cond_index)); string cond_str = cond.str(s); cond_log.debug_f("{}", cond_str); if (!this->card_ref_has_ability_trap(cond)) { if (cond.type == ConditionType::UNKNOWN_75) { if (ret == StatSwapType::A_H_SWAP) { log.debug_f("UNKNOWN_75: clearing"); ret = StatSwapType::NONE; } else { log.debug_f("UNKNOWN_75: setting A_H_SWAP"); ret = StatSwapType::A_H_SWAP; } } else if (cond.type == ConditionType::A_T_SWAP) { if (ret == StatSwapType::A_T_SWAP) { log.debug_f("A_T_SWAP: clearing"); ret = StatSwapType::NONE; } else { log.debug_f("A_T_SWAP: setting A_T_SWAP"); ret = StatSwapType::A_T_SWAP; } } } else { log.debug_f("skipping due to ability trap"); } } } log.debug_f("ret = {}", static_cast(ret)); return ret; } void CardSpecial::compute_team_dice_bonus(uint8_t team_id) { auto s = this->server(); uint8_t value = s->team_exp[team_id] / (s->team_client_count[team_id] * 12); this->adjust_dice_boost_if_team_has_condition_52(team_id, &value, 0); s->team_dice_bonus[team_id] = min(value, 8); } bool CardSpecial::condition_applies_on_sc_or_item_attack(const Condition& cond) const { auto ce = this->server()->definition_for_card_ref(cond.card_ref); if (!ce) { return false; } EffectWhen when = ce->def.effects[cond.card_definition_effect_index].when; return ((when == EffectWhen::AFTER_CREATURE_OR_HUNTER_SC_ATTACK) || (when == EffectWhen::BEFORE_CREATURE_OR_HUNTER_SC_ATTACK)); } 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 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_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> CardSpecial::get_all_set_cards_by_team_and_class( CardClass card_class, uint8_t team_id, bool exclude_destroyed_cards) const { auto s = this->server(); if (s->options.is_nte()) { team_id = 0xFF; exclude_destroyed_cards = false; } vector> ret; auto check_card = [&](shared_ptr 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 = s->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 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 attacker_card, shared_ptr 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, 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 card, const char* arg2_text, DiceRoll& dice_roll, uint16_t set_card_ref, uint16_t sc_card_ref, uint8_t random_percent, EffectWhen 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). auto s = this->server(); uint16_t attacker_card_ref = as.attacker_card_ref; if (attacker_card_ref == 0xFFFF) { attacker_card_ref = as.original_attacker_card_ref; } bool is_nte = s->options.is_nte(); auto set_card = s->card_for_set_card_ref(set_card_ref); bool set_card_has_ability_trap = (!is_nte && set_card && this->card_has_condition_with_ref(set_card, ConditionType::ABILITY_TRAP, 0xFFFF, 0xFFFF)); switch (arg2_text[0]) { case 'b': { auto attacker_card = s->card_for_set_card_ref(attacker_card_ref); return (attacker_card && (attacker_card->action_chain.chain.damage <= atoi(arg2_text + 1))); } case 'C': if (is_nte) { return false; } card = s->card_for_set_card_ref(set_card_ref); if (!card) { card = s->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 = s->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.at(0); if ((arg2_command == 'c') || (arg2_command == 'C')) { uint8_t other_ch1 = ce->def.effects[cond_index].arg2.at(1) - 0x30; if ((other_ch1 > 9)) { return false; } if (other_ch1 == ch2) { return true; } } } } return false; } 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 = s->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 0x00: // n00 return true; case 0x01: // n01 return (!card || (card->get_definition()->def.type == CardType::HUNTERS_SC)); case 0x02: // n02 for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { auto target_card = s->card_for_set_card_ref(as.target_card_refs[z]); if (target_card && target_card->check_card_flag(2)) { return true; } } return false; case 0x03: // n03 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 = s->definition_for_card_ref(action_card_ref); if (card_class_is_tech_like(ce->def.card_class(), is_nte)) { return true; } } } return false; case 0x04: // n04 return card->action_chain.check_flag(is_nte ? 0x00000080 : 0x0001E000); case 0x05: // n05 return card->action_chain.check_flag(is_nte ? 0x00000002 : 0x00001E00); case 0x06: // n06 return (card->get_definition()->def.card_class() == CardClass::NATIVE_CREATURE); case 0x07: // n07 return (card->get_definition()->def.card_class() == CardClass::A_BEAST_CREATURE); case 0x08: // n08 return (card->get_definition()->def.card_class() == CardClass::MACHINE_CREATURE); case 0x09: // n09 return (card->get_definition()->def.card_class() == CardClass::DARK_CREATURE); case 0x0A: // n10 return (card->get_definition()->def.card_class() == CardClass::SWORD_ITEM); case 0x0B: // n11 return (card->get_definition()->def.card_class() == CardClass::GUN_ITEM); case 0x0C: // n12 return (card->get_definition()->def.card_class() == CardClass::CANE_ITEM); case 0x0D: { // n13 auto ce = card->get_definition(); return ((ce->def.card_class() == CardClass::GUARD_ITEM) || (!is_nte && (ce->def.card_class() == CardClass::MAG_ITEM)) || s->ruler_server->find_condition_on_card_ref( card->get_card_ref(), ConditionType::GUARD_CREATURE, 0, 0, 0)); } case 0x0E: // n14 return card->get_definition()->def.is_sc(); case 0x0F: // n15 return ((card->action_chain.chain.attack_action_card_ref_count == 0) && (card->action_metadata.defense_card_ref_count == 0)); case 0x10: // n16 return s->ruler_server->card_ref_is_aerial(card->get_card_ref()); case 0x11: { // n17 auto sc_card = s->card_for_set_card_ref(sc_card_ref); int16_t this_ap = card->ap; int16_t other_ap = -1; if (!sc_card) { auto ce = s->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 0x12: // n18 for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { auto target_card = s->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 0x13: // n19 return s->ruler_server->find_condition_on_card_ref( card->get_card_ref(), ConditionType::PARALYZE, 0, 0, 0); case 0x14: // n20 return s->ruler_server->find_condition_on_card_ref( card->get_card_ref(), ConditionType::FREEZE, 0, 0, 0); case 0x15: { // n21 if (!is_nte) { 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 0x16: { // n22 if (!is_nte) { 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 = s->card_for_set_card_ref(set_card_ref); if (!new_card) { new_card = s->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 || is_nte) && (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 = s->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 (is_nte) { return (v < set_card->unknown_a9); } else if (when == EffectWhen::BEFORE_DICE_PHASE_THIS_TEAM_TURN) { 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 { using ExprToken = CardDefinition::Effect::ExprToken; auto log = this->server()->log_stack("evaluate_effect_expr: "); if (log.min_level == phosg::LogLevel::L_DEBUG) { log.debug_f( "ast, expr=\"{}\", dice_roll=(client_id={:02X}, a2={:02X}, value={:02X}, value_used_in_expr={}, a5={:04X})", expr, dice_roll.client_id, dice_roll.unknown_a2, dice_roll.value, dice_roll.value_used_in_expr ? "true" : "false", dice_roll.unknown_a5); ast.print(stderr); } // Note: This implementation is not based on the original code because the original code was hard to follow - it used // 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. auto tokens = ExprToken::parse(expr); for (auto& token : tokens) { if (token.type == ExprToken::Type::SPACE) { throw runtime_error("expression contains space token"); } // Turn references into numbers, so only numbers and operators can appear in the tokens vector if (token.type == ExprToken::Type::REFERENCE) { if ((token.value == 1) || (token.value == 11)) { dice_roll.value_used_in_expr = true; } token.type = ExprToken::Type::NUMBER; token.value = ast.at(token.value); } } // Operators are evaluated left-to-right - there are no operator precedence rules int32_t value = 0; log.debug_f("value={} (start)", value); for (size_t token_index = 0; token_index < tokens.size(); token_index++) { const auto& token = tokens[token_index]; if ((token.type == ExprToken::Type::SPACE) || (token.type == ExprToken::Type::REFERENCE)) { throw logic_error("space or reference token present in expr evaluation phase 2"); } if (token.type == ExprToken::Type::NUMBER) { value = token.value; log.debug_f("value={} (token_type=NUMBER, token_value={})", value, token.value); } else { if (token_index >= tokens.size() - 1) { throw runtime_error("no token on right side of binary operator"); } token_index++; const auto& right_token = tokens[token_index]; if (right_token.type != ExprToken::Type::NUMBER) { // REFERENCE was converted to NUMBER after parsing, based on the attack env stats throw runtime_error("non-number, non-reference token on right side of operator"); } switch (token.type) { case ExprToken::Type::ROUND_DIVIDE: value = lround(static_cast(value) / right_token.value); log.debug_f("value={} (token_type=ROUND_DIVIDE, right_token_value={})", value, right_token.value); break; case ExprToken::Type::SUBTRACT: value -= right_token.value; log.debug_f("value={} (token_type=SUBTRACT, right_token_value={})", value, right_token.value); break; case ExprToken::Type::ADD: value += right_token.value; log.debug_f("value={} (token_type=ADD, right_token_value={})", value, right_token.value); break; case ExprToken::Type::MULTIPLY: value *= right_token.value; log.debug_f("value={} (token_type=MULTIPLY, right_token_value={})", value, right_token.value); break; case ExprToken::Type::FLOOR_DIVIDE: value = floor(value / right_token.value); log.debug_f("value={} (token_type=FLOOR_DIVIDE, right_token_value={})", value, right_token.value); break; default: throw logic_error("invalid binary operator"); } } } log.debug_f("value={} (result)", value); return value; } bool CardSpecial::execute_effect( Condition& cond, shared_ptr card, int16_t expr_value, int16_t unknown_p5, ConditionType cond_type, uint32_t unknown_p7, uint16_t attacker_card_ref) { auto s = this->server(); auto log = s->log_stack(std::format("execute_effect(@{:04X} #{:04X}): ", card->get_card_ref(), card->get_card_id())); { string cond_str = cond.str(s); log.debug_f("cond={}, card=@{:04X}, expr_value={}, unknown_p5={}, cond_type={}, unknown_p7={} attacker_card_ref=@{:04X}", cond_str, ref_for_card(card), expr_value, unknown_p5, phosg::name_for_enum(cond_type), unknown_p7, attacker_card_ref); } bool is_nte = s->options.is_nte(); int16_t clamped_expr_value = clamp(expr_value, -99, 99); cond.value8 = clamped_expr_value; if (!is_nte) { 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 &= ~4; } if (unknown_p7 == 0) { return false; } } else if (card->action_metadata.check_flag(0x10) && (cond.card_ref != card->get_card_ref()) && (cond.condition_giver_card_ref != card->get_card_ref())) { return false; } int16_t positive_expr_value = max(clamped_expr_value, 0); int16_t clamped_unknown_p5 = clamp(unknown_p5, 0, is_nte ? unknown_p5 : 99); auto attacker_sc = s->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::CANNOT_DEFEND: case ConditionType::GUOM: case ConditionType::PARALYZE: case ConditionType::PIERCE: case ConditionType::UNUSED_0F: case ConditionType::SET_MV_COST_TO_0: case ConditionType::UNUSED_13: case ConditionType::ACID: case ConditionType::ADD_1_TO_MV_COST: 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::MV_BONUS: if (is_nte) { return false; } [[fallthrough]]; case ConditionType::UNKNOWN_39: case ConditionType::DEFENDER: case ConditionType::SURVIVAL_DECOYS: case ConditionType::EXP_DECOY: case ConditionType::SET_MV: return true; case ConditionType::AP_BOOST: if (unknown_p7 & 1) { if (is_nte) { card->action_chain.chain.ap_effect_bonus += positive_expr_value; } else { card->action_chain.chain.ap_effect_bonus = clamp( 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) { if (is_nte) { card->action_chain.chain.tp_effect_bonus += positive_expr_value; } else { card->action_chain.chain.tp_effect_bonus = clamp( 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 = is_nte ? card->get_current_hp() : clamp(card->get_current_hp(), -99, 99); int16_t new_hp = is_nte ? (current_hp - positive_expr_value) : clamp(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(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::A_T_SWAP_0C: case ConditionType::A_T_SWAP_PERM: if (unknown_p7 & 4) { int16_t ap = is_nte ? card->ap : clamp(card->ap, -99, 99); int16_t tp = is_nte ? card->tp : clamp(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 = is_nte ? card->ap : clamp(card->ap, -99, 99); int16_t hp = is_nte ? card->get_current_hp() : clamp(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 = is_nte ? card->get_current_hp() : clamp(card->get_current_hp(), -99, 99); int16_t new_hp = is_nte ? (hp + positive_expr_value) : clamp(hp + positive_expr_value, -99, 99); log.debug_f("HEAL: hp={}, positive_expr_value={}, new_hp={}", hp, positive_expr_value, new_hp); this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, new_hp - hp, true, true); 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 = s->player_states.at(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); if (!is_nte) { 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( 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) { size_t count = this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::UNIT_BLOW, 0xFFFF); int16_t clamped_count = is_nte ? count : clamp(count, -99, 99); int16_t result = card->action_chain.chain.ap_effect_bonus + clamped_count * positive_expr_value; card->action_chain.chain.ap_effect_bonus = is_nte ? result : clamp(result, -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 = s->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 = is_nte ? card->get_current_hp() : clamp(card->get_current_hp(), -99, 99); int16_t new_hp = max(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 = this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::COMBO_AP, 0xFFFF); int16_t clamped_count = is_nte ? count : clamp(count, -99, 99); int16_t result = card->action_chain.chain.ap_effect_bonus + clamped_count * clamped_count; card->action_chain.chain.ap_effect_bonus = is_nte ? result : clamp(result, -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::ABILITY_TRAP: if (is_nte && (unknown_p7 & 4)) { bool needs_update = false; for (ssize_t z = 8; z >= 0; z--) { auto& cond = card->action_chain.conditions[z]; if (cond.type == ConditionType::NONE) { break; } G_ApplyConditionEffect_Ep3_6xB4x06 cmd; cmd.effect.flags = 0x04; cmd.effect.attacker_card_ref = attacker_card_ref; cmd.effect.target_card_ref = card->get_card_ref(); cmd.effect.value = 0; cmd.effect.operation = -static_cast(cond.type); cmd.effect.condition_index = z; s->send(cmd); this->apply_stat_deltas_to_card_from_condition_and_clear_cond(cond, card); needs_update = true; } if (needs_update) { card->send_6xB4x4E_4C_4D_if_needed(); } } return false; 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::CANNOT_DEFEND) || (cond.type == ConditionType::GUOM) || (cond.type == ConditionType::PARALYZE) || (cond.type == ConditionType::UNUSED_13) || (cond.type == ConditionType::ACID) || (cond.type == ConditionType::ADD_1_TO_MV_COST) || (cond.type == ConditionType::CURSE) || (cond.type == ConditionType::PIERCE_RAMPAGE_BLOCK) || (!is_nte && (cond.type == ConditionType::FREEZE)) || (cond.type == ConditionType::UNKNOWN_1E) || (!is_nte && (cond.type == ConditionType::DROP))) { G_ApplyConditionEffect_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(cond.type); cmd.effect.condition_index = z; s->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 = s->card_for_set_card_ref(attacker_card_ref); if (!sc_card || (sc_card->action_chain.chain.attack_medium == AttackMedium::PHYSICAL)) { int16_t hp = is_nte ? card->get_current_hp() : clamp(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 & (is_nte ? 0x02 : 0x40)) { size_t count = this->count_action_cards_with_condition_for_all_current_attacks(ConditionType::EXPLOSION, 0xFFFF); int16_t clamped_count = is_nte ? count : clamp(count, -99, 99); card->action_metadata.attack_bonus = is_nte ? (clamped_count * clamped_count) : clamp(clamped_count * clamped_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 = s->player_states.at(client_id); if (!ps) { return false; } if (!is_nte) { card->unknown_802380C0(); } return ps->discard_card_or_add_to_draw_pile(card->get_card_ref(), !is_nte); } case ConditionType::AP_LOSS: if (unknown_p7 & 1) { int16_t new_value = card->action_chain.chain.ap_effect_bonus - positive_expr_value; card->action_chain.chain.ap_effect_bonus = is_nte ? new_value : clamp(new_value, -99, 99); } return true; case ConditionType::BONUS_FROM_LEADER: if (unknown_p7 & 1) { size_t leader_count = this->count_cards_with_card_id_except_card_ref(expr_value, 0xFFFF); int16_t new_value = card->action_chain.chain.ap_effect_bonus + leader_count; card->action_chain.chain.ap_effect_bonus = is_nte ? new_value : clamp(new_value, -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 = is_nte ? card->get_current_hp() : clamp(card->get_current_hp(), -99, 99); int16_t new_hp = is_nte ? (hp + positive_expr_value) : clamp(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 = s->player_states.at(attacker_client_id); auto target_ps = s->player_states.at(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 < s->team_exp[target_team_id]) { s->team_exp[attacker_team_id] += positive_expr_value; s->team_exp[target_team_id] -= positive_expr_value; } else { positive_expr_value = s->team_exp[target_team_id]; s->team_exp[attacker_team_id] += s->team_exp[target_team_id]; s->team_exp[target_team_id] = 0; } this->compute_team_dice_bonus(attacker_team_id); this->compute_team_dice_bonus(target_team_id); if (!is_nte) { this->send_6xB4x06_for_exp_change(card, attacker_card_ref, -positive_expr_value, 1); } s->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 (!is_nte && (unknown_p7 & 4)) { auto ps = card->player_state(); if (ps) { uint8_t team_id = ps->get_team_id(); int16_t delta = 0; if (s->team_exp[team_id] < 4) { s->team_exp[team_id] = 0; } else { delta = -3; s->team_exp[team_id] -= 3; } this->compute_team_dice_bonus(team_id); this->send_6xB4x06_for_exp_change(card, attacker_card_ref, delta, 1); } } return true; case ConditionType::ACTION_DISRUPTER: if (unknown_p7 & 4) { if (is_nte) { card->action_metadata.defense_card_ref_count = 0; } else { 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) && s->player_states.at(client_id)) { uint8_t team_id = s->player_states.at(client_id)->get_team_id(); int32_t existing_exp = s->team_exp[team_id]; if ((clamped_expr_value + existing_exp) < 0) { clamped_expr_value = -existing_exp; s->team_exp[team_id] = 0; } else { s->team_exp[team_id] = existing_exp + clamped_expr_value; } if (!is_nte) { this->send_6xB4x06_for_exp_change(card, attacker_card_ref, clamped_expr_value, 1); } this->compute_team_dice_bonus(team_id); s->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 card_refs; card_refs.emplace_back(attacker_sc->get_card_ref()); if (is_nte) { 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]); } } else if (attacker_sc != card) { card_refs.emplace_back(card->get_card_ref()); } for (uint16_t card_ref : card_refs) { auto sc_card = s->card_for_set_card_ref(card_ref); if (sc_card && (sc_card->get_current_hp() > 0)) { if (s->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) { size_t count = this->count_cards_with_card_id_except_card_ref(ce->def.card_id, card->get_card_ref()); int16_t clamped_count = is_nte ? count : clamp(count, -99, 99); int16_t new_value = card->action_chain.chain.ap_effect_bonus + clamped_count * positive_expr_value; card->action_chain.chain.ap_effect_bonus = is_nte ? new_value : clamp(new_value, -99, 99); } } return true; case ConditionType::BERSERK: if (unknown_p7 & 4) { int16_t hp = is_nte ? card->get_current_hp() : clamp(card->get_current_hp(), -99, 99); int16_t new_hp = is_nte ? (hp - card->action_chain.chain.damage) : clamp(hp - this->max_all_attack_bonuses(nullptr), -99, 99); this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x20, new_hp - hp, false, true); new_hp = max(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 = s->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 = is_nte ? (card->ap + positive_expr_value) : clamp(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 = is_nte ? (card->tp + positive_expr_value) : clamp(card->tp + positive_expr_value, -99, 99); } return true; case ConditionType::COPY: if (unknown_p7 & 4) { auto attacker_card = s->card_for_set_card_ref(attacker_card_ref); if (attacker_card && (attacker_card != card)) { int16_t new_ap = (positive_expr_value < 51) ? (card->ap / 2) : card->ap; int16_t new_tp = (positive_expr_value < 51) ? (card->tp / 2) : card->tp; if (!is_nte) { new_ap = clamp(new_ap, -99, 99); new_tp = clamp(new_tp, -99, 99); } this->send_6xB4x06_for_stat_delta(attacker_card, attacker_card_ref, 0xA0, new_ap - attacker_card->ap, false, false); this->send_6xB4x06_for_stat_delta(attacker_card, attacker_card_ref, 0x80, new_tp - attacker_card->tp, false, false); attacker_card->ap = new_ap; attacker_card->tp = new_tp; } } return true; case ConditionType::MISC_GUARDS: if (unknown_p7 & 8) { int16_t new_value = positive_expr_value + card->action_metadata.defense_bonus; card->action_metadata.defense_bonus = is_nte ? new_value : clamp(new_value, -99, 99); } return true; case ConditionType::AP_OVERRIDE: if ((unknown_p7 & 4) && !(cond.flags & 2)) { cond.value = is_nte ? (positive_expr_value - card->ap) : clamp(positive_expr_value - card->ap, -99, 99); this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0xA0, cond.value, false, false); card->ap = positive_expr_value; cond.flags |= 2; } return true; case ConditionType::TP_OVERRIDE: if ((unknown_p7 & 4) && !(cond.flags & 2)) { cond.value = is_nte ? (positive_expr_value - card->tp) : clamp(positive_expr_value - card->tp, -99, 99); this->send_6xB4x06_for_stat_delta(card, attacker_card_ref, 0x80, cond.value, false, false); card->tp = positive_expr_value; cond.flags |= 2; } return true; case ConditionType::UNKNOWN_64: case ConditionType::FORWARD_DAMAGE: if (is_nte) { return false; } [[fallthrough]]; case ConditionType::SLAYERS_ASSASSINS: if (is_nte) { auto set_card = s->card_for_set_card_ref(attacker_card_ref); bool card_found = false; if (!set_card) { card_found = false; } else { for (size_t z = 0; z < set_card->action_chain.chain.target_card_ref_count; z++) { if (set_card->action_chain.chain.target_card_refs[z] == card->get_card_ref()) { card_found = true; break; } } } if (card_found) { if (unknown_p7 & 8) { card->action_metadata.defense_bonus -= positive_expr_value; } return true; } else { return this->execute_effect( cond, card, positive_expr_value, clamped_unknown_p5, ConditionType::GIVE_DAMAGE, unknown_p7, attacker_card_ref); } } else if (unknown_p7 & 0x20) { card->action_metadata.attack_bonus = clamp( card->action_metadata.attack_bonus + positive_expr_value, -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_except_card_ref(expr_value, 0xFFFF); int16_t new_value = count + card->action_chain.chain.tp_effect_bonus; card->action_chain.chain.tp_effect_bonus = is_nte ? new_value : clamp(new_value, -99, 99); } return true; case ConditionType::MISC_AP_BONUSES: if ((unknown_p7 & 4) && !(cond.flags & 2)) { if (is_nte) { int16_t orig_ap = card->ap; card->ap = max(positive_expr_value + card->ap, 0); cond.value = card->ap - orig_ap; } else { int16_t orig_ap = clamp(card->ap, -99, 99); card->ap = clamp(positive_expr_value + card->ap, 0, 99); cond.value = clamp(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)) { if (is_nte) { int16_t orig_tp = card->tp; card->tp = max(positive_expr_value + card->tp, 0); cond.value = card->tp - orig_tp; } else { int16_t orig_tp = clamp(card->tp, -99, 99); card->tp = clamp(positive_expr_value + card->tp, 0, 99); cond.value = clamp(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 (is_nte) { return false; } if (unknown_p7 & 0x20) { card->action_metadata.attack_bonus = clamp( card->action_metadata.attack_bonus - positive_expr_value, 0, 99); } return true; case ConditionType::MOSTLY_HALFGUARDS: case ConditionType::DAMAGE_MODIFIER_2: if (is_nte) { return false; } if (unknown_p7 & 0x40) { card->action_metadata.attack_bonus = positive_expr_value; } return true; case ConditionType::PERIODIC_FIELD: if (is_nte) { return false; } if ((unknown_p7 & 0x40) && (static_cast(attack_medium) == ((s->get_round_num() >> 1) & 1) + 1)) { card->action_metadata.attack_bonus = 0; } return true; case ConditionType::AP_SILENCE: if (is_nte) { return false; } if ((unknown_p7 & 4) && !(cond.flags & 2)) { int16_t prev_ap = clamp(card->ap, -99, 99); card->ap = clamp(card->ap - positive_expr_value, 0, 99); cond.value = clamp(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 (is_nte) { return false; } if ((unknown_p7 & 4) && !(cond.flags & 2)) { int16_t prev_ap = clamp(card->tp, -99, 99); card->tp = clamp(card->tp - positive_expr_value, 0, 99); cond.value = clamp(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 (is_nte) { return false; } if (unknown_p7 & 1) { card->action_chain.chain.tp_effect_bonus = clamp( card->action_chain.chain.tp_effect_bonus - positive_expr_value, -99, 99); } return true; case ConditionType::UNKNOWN_77: if (is_nte) { return false; } if (attacker_sc && (unknown_p7 & 4)) { vector 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 = s->card_for_set_card_ref(card_ref); if (set_card && (set_card->get_current_hp() > 0)) { if (s->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 card, ConditionType cond_type, uint16_t set_card_ref, uint8_t def_effect_index) const { if (this->server()->options.is_nte()) { // The NTE version of this function returns a boolean instead of a pointer; // we always return a pointer for simplicity reasons, even for NTE. for (size_t z = 0; z < 9; z++) { auto& cond = card->action_chain.conditions[z]; auto orig_eff = this->original_definition_for_condition(cond); if (((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)))) { return &cond; } } return nullptr; } else { 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, ConditionType cond_type, uint16_t set_card_ref, uint8_t def_effect_index) const { return const_cast(this->find_condition_with_parameters( static_cast>(card), cond_type, set_card_ref, def_effect_index)); } void CardSpecial::get_card1_loc_with_card2_opposite_direction( Location* out_loc, shared_ptr card1, shared_ptr card2) { if (card1) { if (!card2 || (static_cast(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 card1, uint16_t default_card_id, shared_ptr card2) const { auto s = this->server(); if (s->options.is_nte()) { return default_card_id; } else if (card2 && !(static_cast(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"); } } vector> 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 { auto s = this->server(); auto log = s->log_stack(std::format( "get_targeted_cards_for_condition(@{:04X}, {}, @{:04X}): ", card_ref, def_effect_index, setter_card_ref)); log.debug_f( "card_ref=@{:04X}, def_effect_index={:02X}, setter_card_ref=@{:04X}, as, p_target_type={}, apply_usability_filters={}", card_ref, def_effect_index, setter_card_ref, p_target_type, apply_usability_filters ? "true" : "false"); vector> ret; uint8_t client_id = client_id_for_card_ref(card_ref); auto card1 = s->card_for_set_card_ref(card_ref); if (!card1) { card1 = s->card_for_set_card_ref(setter_card_ref); } log.debug_f("card1=@{:04X}", ref_for_card(card1)); auto card2 = s->card_for_set_card_ref((as.attacker_card_ref == 0xFFFF) ? as.original_attacker_card_ref : as.attacker_card_ref); log.debug_f("card2=@{:04X}", ref_for_card(card2)); 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); string card1_loc_str = card1_loc.str(); log.debug_f("card1_loc={}", card1_loc_str); } AttackMedium attack_medium = card2 ? card2->action_chain.chain.attack_medium : AttackMedium::UNKNOWN; log.debug_f("attack_medium={}", phosg::name_for_enum(attack_medium)); auto add_card_refs = [&](const vector& result_card_refs) -> void { for (uint16_t result_card_ref : result_card_refs) { auto result_card = s->card_for_set_card_ref(result_card_ref); if (result_card) { ret.emplace_back(result_card); } } }; switch (p_target_type) { case 0x01: // p01 case 0x05: { // p05 auto result_card = s->card_for_set_card_ref(setter_card_ref); if (result_card) { log.debug_f("(p01/p05) result_card=@{:04X}", ref_for_card(result_card)); ret.emplace_back(result_card); } else { log.debug_f("(p01/p05) result_card=null"); } break; } case 0x02: // p02 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 = s->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 0x03: // p03 if (card1) { auto ce = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); add_card_refs(ps->get_card_refs_within_range_from_all_players(range, card1_loc, CardType::ITEM)); } } if (card1) { auto ce = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); add_card_refs(ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id())); } } break; case 0x04: // p04 size_t z; for (z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF) && (as.action_card_refs[z] != card_ref); z++) { } for (; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) { auto result_card = s->card_for_set_card_ref(as.action_card_refs[z]); if (result_card) { ret.emplace_back(result_card); } } break; case 0x06: // p06 ret = this->get_attacker_card_and_sc_if_item(as); break; case 0x07: { // p07 auto card = this->get_attacker_card(as); if (card) { ret.emplace_back(card); } break; } case 0x08: { // p08 auto card = this->sc_card_for_client_id(client_id); if (card) { ret.emplace_back(card); } break; } case 0x09: // p09 if (card1) { auto ce = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); add_card_refs(ps->get_all_cards_within_range(range, card1_loc, card1->get_team_id())); } } break; case 0x0A: // p10 ret = this->find_all_cards_on_same_or_other_team(client_id, true); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x0B: // p11 ret = this->find_all_set_cards_on_client_team(client_id); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x0C: // p12 if (s->options.is_nte()) { ret = this->find_cards_by_condition_inc_exc( ConditionType::NONE, ConditionType::AERIAL, AssistEffect::NONE, AssistEffect::FLY); } else { ret = this->find_all_cards_by_aerial_attribute(false); ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x0D: // p13 ret = this->find_cards_by_condition_inc_exc(ConditionType::FREEZE); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x0E: // p14 ret = this->find_cards_in_hp_range(-1000, 3); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x0F: // p15 ret = this->get_all_set_cards(); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x10: { // p16 ret = this->find_cards_in_hp_range(8, 1000); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; } case 0x11: { // p17 auto result_card = s->card_for_set_card_ref(card_ref); if (result_card) { ret.emplace_back(result_card); } break; } case 0x12: { // p18 auto card = this->sc_card_for_client_id(client_id); if (card) { ret.emplace_back(card); } break; } case 0x13: // p19 ret = this->find_all_sc_cards_of_class(CardClass::HU_SC); break; case 0x14: // p20 ret = this->find_all_sc_cards_of_class(CardClass::RA_SC); break; case 0x15: // p21 ret = this->find_all_sc_cards_of_class(CardClass::FO_SC); break; case 0x16: // p22 if (card1) { auto def = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->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 0x17: { // p23 auto log23 = log.sub("(p23) "); if (card1) { auto def = s->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); log23.debug_f("effective range card ID is #{:04X}", range_card_id); parray range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules, &log23); auto result_card_refs = ps->get_all_cards_within_range(range, card1_loc, 0xFF); log23.debug_f("{} result card refs", result_card_refs.size()); for (uint16_t result_card_ref : result_card_refs) { auto result_log = log23.sub(std::format("(result @{:04X}) ", result_card_ref)); auto result_card = s->card_for_set_card_ref(result_card_ref); if (!result_card) { result_log.debug_f("result card not found"); } else if (result_card->get_definition()->def.type == CardType::ITEM) { result_log.debug_f("result card is item"); } else { result_log.debug_f("result card found and is not item"); ret.emplace_back(result_card); } } } else { log23.debug_f("def or ps is missing"); } } else { log23.debug_f("card1 is missing"); } break; } case 0x18: // p24 ret = this->find_cards_by_condition_inc_exc(ConditionType::PARALYZE); break; case 0x19: // p25 if (s->options.is_nte()) { // This appears to be a copy/paste error in NTE that was fixed in the // final version. Presumably include_cond should be ConditionType::FLY // here, not PARALYZE. ret = this->find_cards_by_condition_inc_exc( ConditionType::PARALYZE, ConditionType::NONE, AssistEffect::FLY, AssistEffect::NONE); } else { ret = this->find_all_cards_by_aerial_attribute(true); } break; case 0x1A: // p26 ret = this->find_cards_damaged_by_at_least(1); break; case 0x1B: // p27 ret = this->get_all_set_cards_by_team_and_class(CardClass::NATIVE_CREATURE, 0xFF, false); break; case 0x1C: // p28 ret = this->get_all_set_cards_by_team_and_class(CardClass::A_BEAST_CREATURE, 0xFF, false); break; case 0x1D: // p29 ret = this->get_all_set_cards_by_team_and_class(CardClass::MACHINE_CREATURE, 0xFF, false); break; case 0x1E: // p30 ret = this->get_all_set_cards_by_team_and_class(CardClass::DARK_CREATURE, 0xFF, false); break; case 0x1F: // p31 ret = this->get_all_set_cards_by_team_and_class(CardClass::SWORD_ITEM, 0xFF, false); break; case 0x20: // p32 ret = this->get_all_set_cards_by_team_and_class(CardClass::GUN_ITEM, 0xFF, false); break; case 0x21: // p33 ret = this->get_all_set_cards_by_team_and_class(CardClass::CANE_ITEM, 0xFF, false); break; case 0x22: // p34 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 = s->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 0x23: // p35 if (card1) { auto def = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->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 0x24: { // p36 auto log36 = log.sub("(p36) "); // On NTE, this includes SCs and items; on other versions, it's SCs only static const auto should_include = +[](shared_ptr ce, bool is_nte) -> bool { return (ce && (ce->def.is_sc() || (is_nte ? (ce->def.type == CardType::ITEM) : false))); }; bool is_nte = s->options.is_nte(); if (as.original_attacker_card_ref == 0xFFFF) { log36.debug_f("original_attacker_card_ref missing"); // debug_str_for_card_ref for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { string debug_ref_str = s->debug_str_for_card_ref(as.target_card_refs[z]); log36.debug_f("examining {}", debug_ref_str); auto result_card = s->card_for_set_card_ref(as.target_card_refs[z]); if (result_card && should_include(result_card->get_definition(), is_nte)) { log36.debug_f("adding {}", debug_ref_str); ret.emplace_back(result_card); } else { log36.debug_f("skipping {}", debug_ref_str); } } } else if (card2 && should_include(card2->get_definition(), is_nte)) { string debug_ref_str = s->debug_str_for_card_ref(card2->get_card_ref()); log36.debug_f("original_attacker_card_ref present; adding card2 = {}", debug_ref_str); ret.emplace_back(card2); } else if (card2) { string debug_ref_str = s->debug_str_for_card_ref(card2->get_card_ref()); log36.debug_f("original_attacker_card_ref present and card2 ({}) not eligible", debug_ref_str); } else { log36.debug_f("original_attacker_card_ref present and card2 missing"); } break; } case 0x25: // p37 ret = this->find_all_cards_on_same_or_other_team(client_id, false); if (!s->options.is_nte()) { ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); } break; case 0x26: // p38 if (card1) { auto def = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->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 0x27: // p39 case 0x28: { // p40 auto log3940 = log.sub("(p39/p40) "); ret = this->find_all_set_cards_with_cost_in_range( (p_target_type == 0x27) ? 4 : 0, (p_target_type == 0x27) ? 99 : 3); if (log3940.should_log(phosg::LogLevel::L_DEBUG)) { for (const auto& card : ret) { log3940.debug_f("found target @{:04X} #{:04X}", card->get_card_ref(), card->get_card_id()); } } if (!s->options.is_nte()) { log3940.debug_f("filtering targets"); ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); if (log3940.should_log(phosg::LogLevel::L_DEBUG)) { for (const auto& card : ret) { log3940.debug_f("retained target @{:04X} #{:04X}", card->get_card_ref(), card->get_card_id()); } } } break; } case 0x29: { // p41 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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); auto result_card_refs = ps->get_all_cards_within_range( range, card1_loc, s->options.is_nte() ? card1->get_team_id() : 0xFF); for (uint16_t result_card_ref : result_card_refs) { auto result_card = s->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); } } if (!s->options.is_nte()) { 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 0x2A: { // p42 auto check_card = [&](shared_ptr 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(s->card_for_set_card_ref(as.target_card_refs[z])); } } else if (card2) { check_card(card2); } break; } case 0x2B: // p43 if (s->options.is_nte()) { break; } for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { auto result_card = s->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 0x2C: { // p44 if (s->options.is_nte()) { break; } auto ps = s->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 0x2D: // p45 if (s->options.is_nte()) { break; } this->sum_last_attack_damage(&ret, nullptr, nullptr); ret = this->filter_cards_by_range(ret, card1, card1_loc, card2); break; case 0x2E: // p46 if (s->options.is_nte()) { break; } if (card1) { auto def = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->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 0x2F: { // p47 if (s->options.is_nte()) { break; } 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 0x30: // p48 if (s->options.is_nte()) { break; } if (card1) { auto ce = s->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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->card_for_set_card_ref(result_card_ref); if (result_card) { auto result_ce = result_card->get_definition(); if (result_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); } } } } auto setter_card = s->card_for_set_card_ref(setter_card_ref); if (setter_card) { ret.emplace_back(setter_card); } } break; case 0x31: // p49 if (s->options.is_nte()) { break; } 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 range; compute_effective_range(range, s->options.card_index, range_card_id, card1_loc, s->map_and_rules); 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 = s->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> filtered_ret; for (auto c : ret) { if (s->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); log.debug_f("usability filter: kept card @{:04X}", ref_for_card(c)); } else { log.debug_f("usability filter: removed card @{:04X}", ref_for_card(c)); } } return filtered_ret; } else { return ret; } } vector> 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 card) const { auto s = this->server(); auto log = s->log_stack("is_card_targeted_by_condition: "); if (log.should_log(phosg::LogLevel::L_DEBUG)) { log.debug_f("card=(@{:04X} #{:04X})", card->get_card_ref(), card->get_card_id()); auto cond_str = cond.str(s); auto as_str = as.str(s); log.debug_f("cond = {}", cond_str); log.debug_f("as = {}", as_str); } if (cond.type == ConditionType::NONE) { log.debug_f("condition is NONE (=> true)"); return true; } auto ce = s->definition_for_card_ref(cond.card_ref); auto sc_card = s->card_for_set_card_ref(cond.card_ref); 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) && (s->options.is_nte() || (client_id_for_card_ref(card->get_card_ref()) == client_id_for_card_ref(cond.card_ref)))) { log.debug_f("failed item or SC check (=> false)"); return false; } if (cond.remaining_turns != 102) { log.debug_f("remaining_turns != 102 (=> true)"); return true; } if (sc_card && ((sc_card == card) || !(sc_card->card_flags & 2))) { string arg3_s = ce->def.effects[cond.card_definition_effect_index].arg3.decode(); if (arg3_s.size() < 1) { throw runtime_error("card definition arg3 is missing"); } auto target_cards = this->get_targeted_cards_for_condition( cond.card_ref, cond.card_definition_effect_index, cond.condition_giver_card_ref, as, atoi(arg3_s.c_str() + 1), 0); for (auto c : target_cards) { if (c == card) { log.debug_f("targeted by p condition (=> true)"); return true; } } log.debug_f("not targeted by p condition (=> false)"); return false; } else { log.debug_f("SC check does not apply"); return false; } } void CardSpecial::on_card_set(shared_ptr 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->evaluate_and_apply_effects(EffectWhen::CARD_SET, 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 card, uint16_t attacker_card_ref, uint8_t dice_roll_value, bool unknown_p5) const { G_ApplyConditionEffect_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(card->ap, 0, 99); cmd.effect.current_hp = clamp(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(card->tp, 0, 99); this->server()->send(cmd); } void CardSpecial::send_6xB4x06_for_card_destroyed( shared_ptr destroyed_card, uint16_t attacker_card_ref) const { auto s = this->server(); G_ApplyConditionEffect_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 = s->options.is_nte() ? 0x78 : 0x7E; this->server()->send(cmd); } uint16_t CardSpecial::send_6xB4x06_if_card_ref_invalid(uint16_t card_ref, int16_t value) const { auto s = this->server(); if (!s->options.is_nte() && !s->card_ref_is_empty_or_has_valid_card_id(card_ref)) { if (value != 0) { G_ApplyConditionEffect_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; s->send(cmd); } card_ref = 0xFFFF; } return card_ref; } void CardSpecial::send_6xB4x06_for_stat_delta( shared_ptr 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(hp_delta + card->get_current_hp(), card->get_max_hp()) - card->get_current_hp(); if (hp_delta == 0) { return; } } bool is_nte = this->server()->options.is_nte(); G_ApplyConditionEffect_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 = is_nte ? card->ap : clamp(card->ap, 0, 99); cmd.effect.current_hp = clamp(card->get_current_hp(), 0, 99); cmd.effect.tp = is_nte ? card->tp : clamp(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 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 s = this->server(); if (s->options.is_nte()) { if (this->card_has_condition_with_ref(card, ConditionType::ABILITY_TRAP, 0xFFFF, 0xFFFF)) { return true; } } else { if (card->get_definition()->def.is_sc() && (eff.type == ConditionType::FREEZE)) { return true; } } switch (eff.type) { case ConditionType::GUOM: case ConditionType::CURSE: if (s->options.is_nte()) { return false; } [[fallthrough]]; case ConditionType::IMMOBILE: case ConditionType::HOLD: case ConditionType::PARALYZE: case ConditionType::ACID: case ConditionType::FREEZE: case ConditionType::DROP: { if (s->options.is_nte()) { return (card->find_condition(ConditionType::ANTI_ABNORMALITY_2) != nullptr); } else { const auto* cond = this->find_condition_with_parameters(card, ConditionType::ANTI_ABNORMALITY_2, 0xFFFF, 0xFF); return (cond != nullptr) || s->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 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(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>* out_cards, int32_t* out_damage_sum, size_t* out_damage_count) const { auto log = this->server()->log_stack("sum_last_attack_damage: "); size_t damage_count = 0; auto check_card = [&](shared_ptr c) -> void { if (c && (c->last_attack_final_damage > 0)) { log.debug_f("check_card @{:04X} #{:04X} => {}", c->get_card_ref(), c->get_card_id(), c->last_attack_final_damage); 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) { vector 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 + 1) < cond_indexes.size(); 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 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::apply_effects_after_card_move(shared_ptr card) { ActionState as = this->create_attack_state_from_card_action_chain(card); bool is_nte = this->server()->options.is_nte(); if (!is_nte) { 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, EffectWhen::BEFORE_MOVE_PHASE_AND_AFTER_CARD_MOVE_FINAL, card, 0x04); this->evaluate_and_apply_effects(EffectWhen::BEFORE_MOVE_PHASE_AND_AFTER_CARD_MOVE_FINAL, card->get_card_ref(), as, 0xFFFF); } this->apply_defense_conditions(as, EffectWhen::AFTER_CARD_MOVE, card, is_nte ? 0x1F : 0x04); this->evaluate_and_apply_effects(EffectWhen::AFTER_CARD_MOVE, card->get_card_ref(), as, 0xFFFF); } void CardSpecial::check_for_defense_interference( shared_ptr attacker_card, shared_ptr target_card, int16_t* inout_unknown_p4) { auto s = this->server(); // Note: This check is not part of the original implementation. if (s->options.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 = s->ruler_server->get_ally_sc_card_ref(target_card->get_card_ref()); if (ally_sc_card_ref == 0xFFFF) { return; } auto ally_sc = s->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 = s->ruler_server->get_hand_and_equip_state_for_client_id(target_ally_client_id); if (!ally_hes || (!(s->options.behavior_flags & BehaviorFlag::ALLOW_NON_COM_INTERFERENCE) && !ally_hes->is_cpu_player)) { return; } uint16_t target_card_id = s->card_id_for_card_ref(target_card->get_card_ref()); if (target_card_id == 0xFFFF) { return; } uint16_t ally_sc_card_id = s->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 || (s->get_random(99) >= entry->defense_probability)) { return; } target_ps->unknown_a17++; G_ApplyConditionEffect_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; s->send(cmd); if (inout_unknown_p4) { *inout_unknown_p4 = 0; target_card->action_metadata.set_flags(0x10); } } void CardSpecial::evaluate_and_apply_effects( EffectWhen 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) { auto s = this->server(); auto log = s->log_stack(std::format("evaluate_and_apply_effects({}, @{:04X}, @{:04X}): ", phosg::name_for_enum(when), set_card_ref, sc_card_ref)); bool is_nte = s->options.is_nte(); { string as_str = as.str(s); log.debug_f("when={}, set_card_ref=@{:04X}, as={}, sc_card_ref=@{:04X}, apply_defense_condition_to_all_cards={}, apply_defense_condition_to_card_ref=@{:04X}", phosg::name_for_enum(when), set_card_ref, as_str, sc_card_ref, apply_defense_condition_to_all_cards ? "true" : "false", apply_defense_condition_to_card_ref); } if (!is_nte) { 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) { log.debug_f("ce missing"); return; } if (is_nte) { auto set_card = s->card_for_set_card_ref(set_card_ref); if ((set_card != nullptr) && set_card->get_condition_value(ConditionType::ABILITY_TRAP)) { 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_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 = s->definition_for_card_ref(as.action_card_refs[z]); if (action_ce && (action_ce->def.card_id == 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 = s->get_random(99); 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 : s->player_states.at(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; log.debug_f("inputs: dice_roll={:02X}, random_percent={}, unknown_v1={}", dice_roll.value, random_percent, unknown_v1 ? "true" : "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++) { auto effect_log = log.sub(std::format("(effect:{}) ", def_effect_index)); const auto& card_effect = ce->def.effects[def_effect_index]; effect_log.debug_f("effect: {}", card_effect.str()); if (card_effect.when != when) { effect_log.debug_f("does not apply (effect.when={}, when={})", phosg::name_for_enum(card_effect.when), phosg::name_for_enum(when)); continue; } string arg3_s = card_effect.arg3.decode(); if (arg3_s.size() < 1) { throw runtime_error("card effect arg3 is missing"); } int16_t arg3_value = atoi(arg3_s.c_str() + 1); effect_log.debug_f("arg3_value={}", arg3_value); auto targeted_cards = this->get_targeted_cards_for_condition( set_card_ref, def_effect_index, sc_card_ref, as, arg3_value, 1); string refs_str = refs_str_for_cards_vector(targeted_cards); effect_log.debug_f("targeted_cards=[{}]", refs_str); bool all_targets_matched = false; if (!is_nte && !targeted_cards.empty() && ((card_effect.type == ConditionType::UNKNOWN_64) || (card_effect.type == ConditionType::MISC_DEFENSE_BONUSES) || (card_effect.type == ConditionType::MOSTLY_HALFGUARDS))) { effect_log.debug_f("special targeting applies"); 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.decode(); 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 = s->card_for_set_card_ref(set_card_ref); if (!set_card) { set_card = s->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(); } } else { effect_log.debug_f("special targeting does not apply"); } for (size_t z = 0; z < targeted_cards.size(); z++) { auto target_log = effect_log.sub(std::format("(target:@{:04X}) ", targeted_cards[z]->get_card_ref())); dice_roll.value_used_in_expr = false; string arg2_str = card_effect.arg2.decode(); target_log.debug_f("arg2_str = {}", arg2_str); 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)) { target_log.debug_f("arg2 condition passed"); 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.decode(); int16_t value = this->evaluate_effect_expr(env_stats, expr_str.c_str(), dice_roll); target_log.debug_f("expr = {}, value = {}", expr_str, value); 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]; target_log.debug_f("target card (not replaced) = @{:04X}", target_card->get_card_ref()); } else { target_log.debug_f("target card (replaced) = @{:04X}", target_card->get_card_ref()); } 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); target_log.debug_f("applied abnormal condition"); // 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_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 = is_nte ? 0 : target_card->action_chain.conditions[applied_cond_index].remaining_turns; cmd.effect.operation = static_cast(card_effect.type); s->send(cmd); // Note: The original code has this check outside of the if // (applied_cond_index >= 0) block, but this is a bug since // applied_cond_index can be negative. In Sega's implementation, this // bug probably does nothing in any reasonable scenario, since the // target card refs array immediately precedes the conditions array, // and the target card refs array is excessively long, so OR'ing a // value that is almost certainly already 0xFFFF with 1 would do // nothing. In our implementation, however, we bounds-check // everything, so we've moved this check inside the relevant if block. if (dice_roll.value_used_in_expr) { target_card->action_chain.conditions[applied_cond_index].flags |= 1; } if (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_log.debug_f("applied defense condition"); } } target_card->send_6xB4x4E_4C_4D_if_needed(0); } else { target_log.debug_f("arg2 condition failed"); } 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; s->send(dice_cmd); } } vector> CardSpecial::get_all_set_cards() const { vector> 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> CardSpecial::find_cards_by_condition_inc_exc( ConditionType include_cond, ConditionType exclude_cond, AssistEffect include_eff, AssistEffect exclude_eff) const { vector> ret; auto check_card = [&](uint8_t client_id, shared_ptr 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, 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_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(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; 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; } } } else { current_row_card_id = current_column_card_id; } } return ret_entry; } void CardSpecial::on_card_destroyed(shared_ptr attacker_card, shared_ptr 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->evaluate_and_apply_effects(EffectWhen::CARD_DESTROYED, destroyed_card_ref, defense_as, 0xFFFF); for (size_t z = 0; (z < 8) && (defense_as.action_card_refs[z] != 0xFFFF); z++) { this->evaluate_and_apply_effects( EffectWhen::CARD_DESTROYED, 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) { bool is_nte = this->server()->options.is_nte(); this->execute_effect(cond, attacker_card, 0, 0, ConditionType::CURSE, is_nte ? 0x1F : 0x04, 0xFFFF); } } } this->send_6xB4x06_for_card_destroyed(destroyed_card, attack_as.attacker_card_ref); } vector> CardSpecial::find_cards_in_hp_range(int16_t min, int16_t max) const { vector> 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> CardSpecial::find_all_cards_by_aerial_attribute(bool is_aerial) const { vector> 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> CardSpecial::find_cards_damaged_by_at_least(int16_t damage) const { vector> 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> CardSpecial::find_all_set_cards_on_client_team(uint8_t client_id) const { vector> 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> CardSpecial::find_all_cards_on_same_or_other_team(uint8_t client_id, bool same_team) const { vector> 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 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 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> CardSpecial::get_attacker_card_and_sc_if_item(const ActionState& as) const { vector> 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> CardSpecial::find_all_set_cards_with_cost_in_range(uint8_t min_cost, uint8_t max_cost) const { vector> 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> CardSpecial::filter_cards_by_range( const vector>& cards, shared_ptr card1, const Location& card1_loc, shared_ptr card2) const { auto log = this->server()->log_stack("filter_cards_by_range: "); if (log.should_log(phosg::LogLevel::L_DEBUG)) { auto card1_str = card1 ? std::format("@{:04X} #{:04X}", card1->get_card_ref(), card1->get_card_id()) : "null"; auto card2_str = card2 ? std::format("@{:04X} #{:04X}", card2->get_card_ref(), card2->get_card_id()) : "null"; auto loc_str = card1_loc.str(); log.debug_f("card1=({}), card2=({}), loc={}", card1_str, card2_str, loc_str); for (const auto& card : cards) { if (card) { log.debug_f("input card: @{:04X} #{:04X}", card->get_card_ref(), card->get_card_id()); } else { log.debug_f("input card: null"); } } } vector> ret; if (!card1 || cards.empty()) { log.debug_f("card1 missing or input list is blank"); return ret; } auto ps = card1->player_state(); if (!ps) { log.debug_f("ps is missing"); return ret; } // TODO: Remove hardcoded card ID here (Earthquake) uint16_t card_id = this->get_card_id_with_effective_range(card1, 0x00ED, card2); log.debug_f("card_id = #{:04X}", card_id); parray range; compute_effective_range(range, this->server()->options.card_index, card_id, card1_loc, this->server()->map_and_rules); if (log.should_log(phosg::LogLevel::L_DEBUG)) { auto loc_str = card1_loc.str(); log.debug_f("compute_effective_range(range, ci, #{:04X}, {}, map) =>", card_id, loc_str); for (size_t y = 0; y < 9; y++) { const uint8_t* row = &range[y * 9]; log.debug_f(" range[{}] = {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}", y, row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]); } } auto card_refs_in_range = ps->get_card_refs_within_range_from_all_players(range, card1_loc, CardType::ITEM); if (log.should_log(phosg::LogLevel::L_DEBUG)) { for (uint16_t card_ref : card_refs_in_range) { log.debug_f("ref in range: @{:04X}", card_ref); } } for (auto card : cards) { if (!card || (card->get_card_ref() == 0xFFFF)) { if (card) { log.debug_f("(@{:04X} #{:04X}) out of range", card->get_card_ref(), card->get_card_id()); } else { log.debug_f("(null) card missing"); } continue; } for (uint16_t card_ref_in_range : card_refs_in_range) { if (card_ref_in_range == card->get_card_ref()) { log.debug_f("(@{:04X} #{:04X}) in range", card->get_card_ref(), card->get_card_id()); ret.emplace_back(card); break; } } log.debug_f("(@{:04X} #{:04X}) out of range", card->get_card_ref(), card->get_card_id()); } return ret; } void CardSpecial::apply_effects_after_attack_target_resolution(const ActionState& as) { auto s = this->server(); auto log = s->log_stack("apply_effects_after_attack_target_resolution: "); log.debug_f("as={}", as.str(s)); 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->evaluate_and_apply_effects( EffectWhen::CARD_SET, as.action_card_refs[z], as, this->send_6xB4x06_if_card_ref_invalid(as.attacker_card_ref, 0x21)); this->evaluate_and_apply_effects( EffectWhen::AFTER_ATTACK_TARGET_RESOLUTION, 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->evaluate_and_apply_effects(EffectWhen::CARD_SET, as.action_card_refs[z], as, card_ref); this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_15, 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->evaluate_and_apply_effects(EffectWhen::UNKNOWN_33, 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->evaluate_and_apply_effects(EffectWhen::UNKNOWN_34, 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->evaluate_and_apply_effects(EffectWhen::UNKNOWN_35, as.target_card_refs[z], as, as.attacker_card_ref); } } } void CardSpecial::move_phase_before_for_card(shared_ptr card) { bool is_nte = this->server()->options.is_nte(); ActionState as = this->create_attack_state_from_card_action_chain(card); this->apply_defense_conditions(as, EffectWhen::BEFORE_MOVE_PHASE, card, is_nte ? 0x1F : 0x04); this->evaluate_and_apply_effects(EffectWhen::BEFORE_MOVE_PHASE, card->get_card_ref(), as, 0xFFFF); if (!is_nte) { this->apply_defense_conditions(as, EffectWhen::BEFORE_MOVE_PHASE_AND_AFTER_CARD_MOVE_FINAL, card, 0x04); this->evaluate_and_apply_effects(EffectWhen::BEFORE_MOVE_PHASE_AND_AFTER_CARD_MOVE_FINAL, card->get_card_ref(), as, 0xFFFF); } } void CardSpecial::dice_phase_before_for_card(shared_ptr card) { auto s = this->server(); bool is_nte = s->options.is_nte(); auto ps = card->player_state(); if (is_nte && (!ps || !ps->is_team_turn())) { return; } ActionState as; 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(); } } if (!is_nte) { this->apply_defense_conditions(as, EffectWhen::BEFORE_DICE_PHASE_ALL_TURNS_FINAL, card, 0x04); this->evaluate_and_apply_effects(EffectWhen::BEFORE_DICE_PHASE_ALL_TURNS_FINAL, card->get_card_ref(), as, sc_card_ref); } if (ps->is_team_turn()) { this->apply_defense_conditions(as, EffectWhen::BEFORE_DICE_PHASE_THIS_TEAM_TURN, card, 0x04); this->evaluate_and_apply_effects(EffectWhen::BEFORE_DICE_PHASE_THIS_TEAM_TURN, card->get_card_ref(), as, sc_card_ref); } } template void CardSpecial::apply_effects_on_phase_change_t(shared_ptr unknown_p2, const ActionState* existing_as) { auto s = this->server(); auto log = s->log_stack(std::format( "apply_effects_on_phase_change_t<{}, {}>(@{:04X} #{:04X}): ", phosg::name_for_enum(When1), phosg::name_for_enum(When2), unknown_p2->get_card_ref(), unknown_p2->get_card_id())); bool is_nte = s->options.is_nte(); 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, is_nte ? 0x1F : 0x04); for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { auto card = s->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, is_nte ? 0x1F : 0x04); } } auto card = this->sc_card_for_card(unknown_p2); this->evaluate_and_apply_effects(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->evaluate_and_apply_effects(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 = s->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->evaluate_and_apply_effects(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->evaluate_and_apply_effects(When1, target_as.action_card_refs[w], target_as, card->get_card_ref()); } } } } void CardSpecial::draw_phase_before_for_card(shared_ptr unknown_p2) { this->apply_effects_on_phase_change_t(unknown_p2); } void CardSpecial::action_phase_before_for_card(shared_ptr unknown_p2) { if (unknown_p2->player_state()->is_team_turn()) { this->apply_effects_on_phase_change_t(unknown_p2); } } void CardSpecial::unknown_8024945C(shared_ptr unknown_p2, const ActionState* existing_as) { this->apply_effects_on_phase_change_t( unknown_p2, this->server()->options.is_nte() ? nullptr : existing_as); } void CardSpecial::unknown_8024966C(shared_ptr unknown_p2, const ActionState* existing_as) { auto log = this->server()->log_stack(std::format("unknown_8024966C(@{:04X} #{:04X}): ", unknown_p2->get_card_ref(), unknown_p2->get_card_id())); 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, EffectWhen::ATTACK_STAT_OVERRIDES, unknown_p2, 4); this->apply_defense_conditions(as, EffectWhen::ATTACK_DAMAGE_ADJUSTMENT, unknown_p2, 4); if (defender_card) { this->apply_defense_conditions(as, EffectWhen::UNKNOWN_22, 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, EffectWhen::ATTACK_STAT_OVERRIDES, card, 4); this->apply_defense_conditions(defense_as, EffectWhen::DEFENSE_DAMAGE_ADJUSTMENT, card, 4); } } this->evaluate_and_apply_effects(EffectWhen::ATTACK_STAT_OVERRIDES, unknown_p2->get_card_ref(), as, card_ref); this->evaluate_and_apply_effects(EffectWhen::ATTACK_DAMAGE_ADJUSTMENT, unknown_p2->get_card_ref(), as, card_ref); if (defender_card) { this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_22, defender_card->get_card_ref(), as, card_ref); } for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) { this->evaluate_and_apply_effects( EffectWhen::ATTACK_STAT_OVERRIDES, as.action_card_refs[z], as, unknown_p2->get_card_ref()); this->evaluate_and_apply_effects( EffectWhen::ATTACK_DAMAGE_ADJUSTMENT, 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->evaluate_and_apply_effects( EffectWhen::ATTACK_STAT_OVERRIDES, card->get_card_ref(), defense_as, unknown_p2->get_card_ref()); this->evaluate_and_apply_effects( EffectWhen::DEFENSE_DAMAGE_ADJUSTMENT, card->get_card_ref(), defense_as, unknown_p2->get_card_ref()); } } } shared_ptr CardSpecial::sc_card_for_card(shared_ptr 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 (this->server()->options.is_nte() || (action_card_ref == 0xFFFF) || (action_card_ref == pa.action_card_refs[z])) { if (pa.original_attacker_card_ref == 0xFFFF) { this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_29, pa.action_card_refs[z], pa, pa.attacker_card_ref); this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_2A, pa.action_card_refs[z], pa, pa.attacker_card_ref); } else { this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_29, pa.action_card_refs[z], pa, pa.target_card_refs[0]); this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_2B, pa.action_card_refs[z], pa, pa.target_card_refs[0]); } } } } void CardSpecial::check_for_attack_interference(shared_ptr unknown_p2) { // Note: This check is not part of the original implementation. if (this->server()->options.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 || (!(this->server()->options.behavior_flags & BehaviorFlag::ALLOW_NON_COM_INTERFERENCE) && !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_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 < EffectWhen WhenAllCards, EffectWhen WhenAttackerAndActionCards, EffectWhen WhenAttackerOrHunterSCCard, EffectWhen WhenTargetsAndActionCards> void CardSpecial::apply_effects_before_or_after_attack(shared_ptr unknown_p2) { auto s = this->server(); auto log = s->log_stack(std::format("apply_effects_before_or_after_attack<{}, {}, {}, {}>(@{:04X} #{:04X}): ", phosg::name_for_enum(WhenAllCards), phosg::name_for_enum(WhenAttackerAndActionCards), phosg::name_for_enum(WhenAttackerOrHunterSCCard), phosg::name_for_enum(WhenTargetsAndActionCards), unknown_p2->get_card_ref(), unknown_p2->get_card_id())); 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 attacker_card = unknown_p2; if (unknown_p2->get_definition() && (unknown_p2->get_definition()->def.type == CardType::ITEM) && sc_card) { attacker_card = sc_card; } uint8_t apply_defense_conditions_flags = s->options.is_nte() ? 0x1F : 0x04; this->apply_defense_conditions(as, WhenAllCards, unknown_p2, apply_defense_conditions_flags); this->apply_defense_conditions(as, WhenAttackerAndActionCards, unknown_p2, apply_defense_conditions_flags); if (attacker_card) { this->apply_defense_conditions(as, WhenAttackerOrHunterSCCard, attacker_card, apply_defense_conditions_flags); } for (size_t z = 0; (z < 4 * 9) && (as.target_card_refs[z] != 0xFFFF); z++) { auto set_card = s->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, WhenAllCards, set_card, apply_defense_conditions_flags); this->apply_defense_conditions(target_as, WhenTargetsAndActionCards, set_card, apply_defense_conditions_flags); } } this->evaluate_and_apply_effects(WhenAllCards, unknown_p2->get_card_ref(), as, sc_card_ref); this->evaluate_and_apply_effects(WhenAttackerAndActionCards, unknown_p2->get_card_ref(), as, sc_card_ref); if (attacker_card) { this->evaluate_and_apply_effects(WhenAttackerOrHunterSCCard, attacker_card->get_card_ref(), as, sc_card_ref); } for (size_t z = 0; (z < 8) && (as.action_card_refs[z] != 0xFFFF); z++) { this->evaluate_and_apply_effects(WhenAllCards, as.action_card_refs[z], as, unknown_p2->get_card_ref()); this->evaluate_and_apply_effects( WhenAttackerAndActionCards, 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 = s->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->evaluate_and_apply_effects(WhenAllCards, set_card->get_card_ref(), target_as, unknown_p2->get_card_ref()); this->evaluate_and_apply_effects( WhenTargetsAndActionCards, 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->evaluate_and_apply_effects( WhenAllCards, target_as.action_card_refs[z], target_as, set_card->get_card_ref()); this->evaluate_and_apply_effects( WhenTargetsAndActionCards, target_as.action_card_refs[z], target_as, set_card->get_card_ref()); } } } } void CardSpecial::apply_effects_after_attack(shared_ptr card) { return this->apply_effects_before_or_after_attack< EffectWhen::AFTER_ANY_CARD_ATTACK, EffectWhen::AFTER_THIS_CARD_ATTACK, EffectWhen::AFTER_CREATURE_OR_HUNTER_SC_ATTACK, EffectWhen::AFTER_THIS_CARD_ATTACKED>(card); } void CardSpecial::apply_effects_before_attack(shared_ptr card) { return this->apply_effects_before_or_after_attack< EffectWhen::BEFORE_ANY_CARD_ATTACK, EffectWhen::BEFORE_THIS_CARD_ATTACK, EffectWhen::BEFORE_CREATURE_OR_HUNTER_SC_ATTACK, EffectWhen::BEFORE_THIS_CARD_ATTACKED>(card); } bool CardSpecial::client_has_atk_dice_boost_condition(uint8_t client_id) { auto s = this->server(); bool is_nte = s->options.is_nte(); auto ps = s->get_player_state(client_id); if (ps) { auto card = ps->get_sc_card(); if (card) { for (size_t z = 0; z < 9; z++) { if ((is_nte || !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 ((is_nte || !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 unknown_p2, shared_ptr 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->evaluate_and_apply_effects(EffectWhen::CARD_SET, as.action_card_refs[z], as, unknown_p3->get_card_ref()); this->evaluate_and_apply_effects(EffectWhen::UNKNOWN_15, as.action_card_refs[z], as, unknown_p3->get_card_ref()); } } vector> CardSpecial::find_all_sc_cards_of_class(CardClass card_class) const { vector> 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