Trait IBattleCalculatorMethods 

pub trait IBattleCalculatorMethods: IBattleCalculator {
    // Provided methods
    fn ctor(self, info: impl Into<BattleInfo>) { ... }
    fn dispose(self) { ... }
    fn get_mode(self) -> BattleCalculator_Mode { ... }
    fn calc_battle(self) -> BattleCalculator { ... }
    fn dump(self) { ... }
    fn try_add_skill_scene(
        self,
        kind: impl Into<BattleScene_Kind>,
        side: impl Into<BattleSide_Type>,
        skill: impl Into<SkillData>,
    ) -> bool { ... }
    fn calc_engage_start(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_invoke_skill(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_engage_end(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_detail_skill(self) { ... }
    fn calc_branch(self) { ... }
    fn is_late_order(self) -> bool { ... }
    fn separator_total_order(self) { ... }
    fn calc_normal_battle(self) { ... }
    fn calc_destroy(self) { ... }
    fn add_skill_scene_result(self, result: impl Into<BattleScene_Result>) { ... }
    fn calc_destroy_attack(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_warmup(self) -> BattleCalculator { ... }
    fn calc_simulation(self) -> BattleCalculator { ... }
    fn calc_job_intro(self) -> BattleCalculator { ... }
    fn calc_class_change(self) -> BattleCalculator { ... }
    fn get_hp(self, side: impl Into<BattleSide_Type>) -> i32 { ... }
    fn get_status(
        self,
        side: impl Into<BattleSide_Type>,
    ) -> BattleInfoSide_BitFieldStatus { ... }
    fn get_info(self) -> BattleInfo { ... }
    fn get_scene_list(self) -> BattleSceneList { ... }
    fn calc_active_skill(
        self,
        timing: impl Into<SkillData_Timings>,
        side: impl Into<BattleSide_Type>,
    ) -> BattleScene_Result { ... }
    fn can_attack(self, side: impl Into<BattleInfoSide>) -> bool { ... }
    fn add_skill_scene(
        self,
        skill: impl Into<SkillData>,
        action: impl Into<SkillData_Actions>,
        current: impl Into<BattleInfoSide>,
    ) { ... }
    fn get_breaked(
        self,
        target: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn add_give_scene(
        self,
        give: impl Into<SkillData>,
        current: impl Into<BattleInfoSide>,
        target: impl Into<BattleInfoSide>,
        kind: impl Into<BattleScene_Kind>,
    ) -> BattleScene_Result { ... }
    fn add_give_scene_2(
        self,
        give: impl Into<SkillData>,
        current: impl Into<BattleInfoSide>,
        target: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn add_gives_scene(
        self,
        skill: impl Into<SkillData>,
        current: impl Into<BattleInfoSide>,
        target: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn add_gives_scene_2(
        self,
        skill: impl Into<SkillData>,
        action: impl Into<SkillData_Actions>,
        current: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn calc_hit_skill(
        self,
        current: impl Into<BattleInfoSide>,
        unit_item: impl Into<UnitItem>,
    ) -> BattleScene_Result { ... }
    fn calc_active_skill_2(
        self,
        timing: impl Into<SkillData_Timings>,
        action: impl Into<SkillData_Actions>,
        current: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn can_oreder_skill(
        self,
        skill: impl Into<SkillData>,
        current: impl Into<BattleInfoSide>,
    ) -> bool { ... }
    fn calc_active_skill_3(
        self,
        skill: impl Into<SkillData>,
        action: impl Into<SkillData_Actions>,
        current: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn calc_hit_skill_2(
        self,
        current: impl Into<BattleInfoSide>,
        reverse: impl Into<BattleInfoSide>,
    ) -> BattleScene_Result { ... }
    fn calc_hit_skill_3(
        self,
        current: impl Into<BattleInfoSide>,
        action: impl Into<SkillData_Actions>,
        skill: impl Into<SkillData>,
    ) { ... }
    fn calc_result_skill(self, current: impl Into<BattleInfoSide>) { ... }
    fn calc_result_skill_2(self) { ... }
    fn calc_chain_attack_sides(
        self,
        current: impl Into<BattleInfoSide>,
    ) -> List_1<BattleInfoSide> { ... }
    fn calc_chain_guard_side(
        self,
        reverse: impl Into<BattleInfoSide>,
    ) -> BattleSide_Type { ... }
    fn can_chain_attack(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_chain_attack(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_orders(self, orders: impl Into<BattleCalculator_OrderList>) -> bool { ... }
    fn calc_interrupt_order(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_interrupt(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn add_engage_count(self, current: impl Into<BattleInfoSide>) { ... }
    fn add_engage_count_2(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_orders_2(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_assist_skill(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_order(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn calc_action(self, side: impl Into<BattleSide_Type>) -> bool { ... }
    fn random_check_hit(self, ratio: impl Into<i32>) -> bool { ... }
    fn calc_attack(self, side_type: impl Into<BattleSide_Type>) -> bool { ... }
    fn can_enter(
        self,
        side: impl Into<BattleInfoSide>,
        x: impl Into<i32>,
        z: impl Into<i32>,
    ) -> bool { ... }
    fn can_blow(
        self,
        current: impl Into<BattleInfoSide>,
        reverse: impl Into<BattleInfoSide>,
    ) -> bool { ... }
    fn calc_attack_hit(
        self,
        current: impl Into<BattleInfoSide>,
        reverse: impl Into<BattleInfoSide>,
    ) -> (BattleScene_Result, i32) { ... }
    fn try_add_dead_scene(
        self,
        side: impl Into<BattleInfoSide>,
        result: impl Into<BattleScene_Result>,
    ) -> bool { ... }
    fn calc_attack_post(
        self,
        side_type: impl Into<BattleSide_Type>,
        damage: impl Into<i32>,
        result: impl Into<BattleScene_Result>,
    ) -> bool { ... }
    fn get_scene_result(self) -> BattleScene_Result { ... }
    fn set_scene_result(self, value: impl Into<BattleScene_Result>) { ... }
    fn calc_rod(self) { ... }
    fn calc_rod_order(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_rod_action(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_rod_attack(self, side: impl Into<BattleSide_Type>) { ... }
    fn calc_dance(self) { ... }
    fn calc_dance_order(self) { ... }
    fn calc_dance_action(self) { ... }
    fn calc_dance_attack(self) { ... }
    fn calc_enchant(self) { ... }
    fn calc_rod_hit(
        self,
        current: impl Into<BattleInfoSide>,
        reverse: impl Into<BattleInfoSide>,
        unit_item: impl Into<UnitItem>,
        item: impl Into<ItemData>,
    ) { ... }
    fn calc_result(self) { ... }
    fn can_battle_record(self, side: impl Into<BattleInfoSide>) -> bool { ... }
    fn calc_record(self) { ... }
    fn get_side(self, force: impl Into<Force_Type>) -> BattleInfoSide { ... }
    fn calc_achieve(self) { ... }
    fn calc_expend_count(self) { ... }
    fn is_chain_attack_dead(self) -> bool { ... }
    fn calc_exp(
        self,
        func: impl Into<BattleCalculator_FuncExp1>,
        current: impl Into<BattleInfoSide>,
    ) { ... }
    fn calc_exp_2(
        self,
        func: impl Into<BattleCalculator_FuncExp2>,
        current: impl Into<BattleInfoSide>,
        reverse: impl Into<BattleInfoSide>,
    ) { ... }
    fn calc_result_gain(self) { ... }
    fn calc_exp_count(self) { ... }
    fn commit_hp(self, side: impl Into<BattleInfoSide>, hp: impl Into<i32>) { ... }
    fn commit_engage_count(
        self,
        side: impl Into<BattleInfoSide>,
        count: impl Into<i32>,
    ) { ... }
    fn update_scene(self) { ... }
    fn update_scene_2(
        self,
        index: impl Into<i32>,
        is_engae_count: impl Into<bool>,
    ) { ... }
    fn update_scene_3(
        self,
        scene: impl Into<BattleScene>,
        is_engae_count: impl Into<bool>,
    ) { ... }
    fn commit_unit(self) { ... }
    fn commit_skill(self) { ... }
    fn commit_destroy(self) { ... }
    fn commit_battle(self) { ... }
    fn map_history_commit_skill(self, unit: impl Into<Unit>) { ... }
    fn is_training(self) -> bool { ... }
    fn is_rod(self) -> bool { ... }
    fn get_unit(self, index: impl Into<i32>) -> Unit { ... }
    fn get_unit_2(self, side: impl Into<BattleSide_Type>) -> Unit { ... }
    fn get_side_2(self, index: impl Into<i32>) -> BattleInfoSide { ... }
    fn get_side_3(self, side: impl Into<BattleSide_Type>) -> BattleInfoSide { ... }
    fn get_dead_side(self) -> BattleSide_Type { ... }
    fn get_dead_unit(self) -> Unit { ... }
    fn get_expend_count(self, side: impl Into<BattleInfoSide>) -> i32 { ... }
    fn can_sky_battle(self) -> bool { ... }
    fn is_multi_battle(self) -> bool { ... }
    fn is_cannon_battle(self) -> bool { ... }
    fn is_fire_cannon(self) -> bool { ... }
    fn is_full_bullet(self) -> bool { ... }
    fn is_last_boss_die(self) -> bool { ... }
    fn is_battle_grow(self) -> bool { ... }
    fn is_combat_die(self) -> bool { ... }
    fn is_combat_grow(self) -> bool { ... }
    fn get_asset_conditions(
        self,
        side_type: impl Into<BattleSide_Type>,
    ) -> Array<Il2CppString> { ... }
}

Provided Methods

fn ctor(self, info: impl Into<BattleInfo>)

.ctor(crate::app::battleinfo::BattleInfo) overload

fn dispose(self)

Dispose() overload

fn get_mode(self) -> BattleCalculator_Mode

GetMode() overload

fn calc_battle(self) -> BattleCalculator

CalcBattle() overload

fn dump(self)

Dump() overload

fn try_add_skill_scene( self, kind: impl Into<BattleScene_Kind>, side: impl Into<BattleSide_Type>, skill: impl Into<SkillData>, ) -> bool

TryAddSkillScene(crate::app::battlescene::BattleScene_Kind, crate::app::battleside::BattleSide_Type, crate::app::skilldata::SkillData) overload

fn calc_engage_start(self, side: impl Into<BattleSide_Type>)

CalcEngageStart(crate::app::battleside::BattleSide_Type) overload

fn calc_invoke_skill(self, side: impl Into<BattleSide_Type>)

CalcInvokeSkill(crate::app::battleside::BattleSide_Type) overload

fn calc_engage_end(self, side: impl Into<BattleSide_Type>)

CalcEngageEnd(crate::app::battleside::BattleSide_Type) overload

fn calc_detail_skill(self)

CalcDetailSkill() overload

fn calc_branch(self)

CalcBranch() overload

fn is_late_order(self) -> bool

IsLateOrder() overload

fn separator_total_order(self)

SeparatorTotalOrder() overload

fn calc_normal_battle(self)

CalcNormalBattle() overload

fn calc_destroy(self)

CalcDestroy() overload

fn add_skill_scene_result(self, result: impl Into<BattleScene_Result>)

AddSkillSceneResult(crate::app::battlescene::BattleScene_Result) overload

fn calc_destroy_attack(self, side: impl Into<BattleSide_Type>) -> bool

CalcDestroyAttack(crate::app::battleside::BattleSide_Type) overload

fn calc_warmup(self) -> BattleCalculator

CalcWarmup() overload

fn calc_simulation(self) -> BattleCalculator

CalcSimulation() overload

fn calc_job_intro(self) -> BattleCalculator

CalcJobIntro() overload

fn calc_class_change(self) -> BattleCalculator

CalcClassChange() overload

fn get_hp(self, side: impl Into<BattleSide_Type>) -> i32

GetHp(crate::app::battleside::BattleSide_Type) overload

fn get_status( self, side: impl Into<BattleSide_Type>, ) -> BattleInfoSide_BitFieldStatus

GetStatus(crate::app::battleside::BattleSide_Type) overload

fn get_info(self) -> BattleInfo

get_Info() overload

fn get_scene_list(self) -> BattleSceneList

get_SceneList() overload

fn calc_active_skill( self, timing: impl Into<SkillData_Timings>, side: impl Into<BattleSide_Type>, ) -> BattleScene_Result

CalcActiveSkill(crate::app::skilldata::SkillData_Timings, crate::app::battleside::BattleSide_Type) overload

fn can_attack(self, side: impl Into<BattleInfoSide>) -> bool

CanAttack(crate::app::battleinfoside::BattleInfoSide) overload

fn add_skill_scene( self, skill: impl Into<SkillData>, action: impl Into<SkillData_Actions>, current: impl Into<BattleInfoSide>, )

AddSkillScene(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide) overload

fn get_breaked(self, target: impl Into<BattleInfoSide>) -> BattleScene_Result

GetBreaked(crate::app::battleinfoside::BattleInfoSide) overload

fn add_give_scene( self, give: impl Into<SkillData>, current: impl Into<BattleInfoSide>, target: impl Into<BattleInfoSide>, kind: impl Into<BattleScene_Kind>, ) -> BattleScene_Result

AddGiveScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, crate::app::battlescene::BattleScene_Kind) overload

fn add_give_scene_2( self, give: impl Into<SkillData>, current: impl Into<BattleInfoSide>, target: impl Into<BattleInfoSide>, ) -> BattleScene_Result

AddGiveScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide) overload

fn add_gives_scene( self, skill: impl Into<SkillData>, current: impl Into<BattleInfoSide>, target: impl Into<BattleInfoSide>, ) -> BattleScene_Result

AddGivesScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide) overload

fn add_gives_scene_2( self, skill: impl Into<SkillData>, action: impl Into<SkillData_Actions>, current: impl Into<BattleInfoSide>, ) -> BattleScene_Result

AddGivesScene(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_hit_skill( self, current: impl Into<BattleInfoSide>, unit_item: impl Into<UnitItem>, ) -> BattleScene_Result

CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::unititem::UnitItem) overload

fn calc_active_skill_2( self, timing: impl Into<SkillData_Timings>, action: impl Into<SkillData_Actions>, current: impl Into<BattleInfoSide>, ) -> BattleScene_Result

CalcActiveSkill(crate::app::skilldata::SkillData_Timings, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide) overload

fn can_oreder_skill( self, skill: impl Into<SkillData>, current: impl Into<BattleInfoSide>, ) -> bool

CanOrederSkill(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_active_skill_3( self, skill: impl Into<SkillData>, action: impl Into<SkillData_Actions>, current: impl Into<BattleInfoSide>, ) -> BattleScene_Result

CalcActiveSkill(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_hit_skill_2( self, current: impl Into<BattleInfoSide>, reverse: impl Into<BattleInfoSide>, ) -> BattleScene_Result

CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_hit_skill_3( self, current: impl Into<BattleInfoSide>, action: impl Into<SkillData_Actions>, skill: impl Into<SkillData>, )

CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::skilldata::SkillData_Actions, crate::app::skilldata::SkillData) overload

fn calc_result_skill(self, current: impl Into<BattleInfoSide>)

CalcResultSkill(crate::app::battleinfoside::BattleInfoSide) overload

fn calc_result_skill_2(self)

CalcResultSkill() overload

fn calc_chain_attack_sides( self, current: impl Into<BattleInfoSide>, ) -> List_1<BattleInfoSide>

CalcChainAttackSides(crate::app::battleinfoside::BattleInfoSide) overload

fn calc_chain_guard_side( self, reverse: impl Into<BattleInfoSide>, ) -> BattleSide_Type

CalcChainGuardSide(crate::app::battleinfoside::BattleInfoSide) overload

fn can_chain_attack(self, side: impl Into<BattleSide_Type>) -> bool

CanChainAttack(crate::app::battleside::BattleSide_Type) overload

fn calc_chain_attack(self, side: impl Into<BattleSide_Type>) -> bool

CalcChainAttack(crate::app::battleside::BattleSide_Type) overload

fn calc_orders(self, orders: impl Into<BattleCalculator_OrderList>) -> bool

CalcOrders(crate::app::battlecalculator::BattleCalculator_OrderList) overload

fn calc_interrupt_order(self, side: impl Into<BattleSide_Type>) -> bool

CalcInterruptOrder(crate::app::battleside::BattleSide_Type) overload

fn calc_interrupt(self, side: impl Into<BattleSide_Type>) -> bool

CalcInterrupt(crate::app::battleside::BattleSide_Type) overload

fn add_engage_count(self, current: impl Into<BattleInfoSide>)

AddEngageCount(crate::app::battleinfoside::BattleInfoSide) overload

fn add_engage_count_2(self, side: impl Into<BattleSide_Type>)

AddEngageCount(crate::app::battleside::BattleSide_Type) overload

fn calc_orders_2(self, side: impl Into<BattleSide_Type>) -> bool

CalcOrders(crate::app::battleside::BattleSide_Type) overload

fn calc_assist_skill(self, side: impl Into<BattleSide_Type>)

CalcAssistSkill(crate::app::battleside::BattleSide_Type) overload

fn calc_order(self, side: impl Into<BattleSide_Type>) -> bool

CalcOrder(crate::app::battleside::BattleSide_Type) overload

fn calc_action(self, side: impl Into<BattleSide_Type>) -> bool

CalcAction(crate::app::battleside::BattleSide_Type) overload

fn random_check_hit(self, ratio: impl Into<i32>) -> bool

RandomCheckHit(i32) overload

fn calc_attack(self, side_type: impl Into<BattleSide_Type>) -> bool

CalcAttack(crate::app::battleside::BattleSide_Type) overload

fn can_enter( self, side: impl Into<BattleInfoSide>, x: impl Into<i32>, z: impl Into<i32>, ) -> bool

CanEnter(crate::app::battleinfoside::BattleInfoSide, i32, i32) overload

fn can_blow( self, current: impl Into<BattleInfoSide>, reverse: impl Into<BattleInfoSide>, ) -> bool

CanBlow(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_attack_hit( self, current: impl Into<BattleInfoSide>, reverse: impl Into<BattleInfoSide>, ) -> (BattleScene_Result, i32)

CalcAttackHit(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, *muti32) overload

fn try_add_dead_scene( self, side: impl Into<BattleInfoSide>, result: impl Into<BattleScene_Result>, ) -> bool

TryAddDeadScene(crate::app::battleinfoside::BattleInfoSide, crate::app::battlescene::BattleScene_Result) overload

fn calc_attack_post( self, side_type: impl Into<BattleSide_Type>, damage: impl Into<i32>, result: impl Into<BattleScene_Result>, ) -> bool

CalcAttackPost(crate::app::battleside::BattleSide_Type, i32, crate::app::battlescene::BattleScene_Result) overload

fn get_scene_result(self) -> BattleScene_Result

get_SceneResult() overload

fn set_scene_result(self, value: impl Into<BattleScene_Result>)

set_SceneResult(crate::app::battlescene::BattleScene_Result) overload

fn calc_rod(self)

CalcRod() overload

fn calc_rod_order(self, side: impl Into<BattleSide_Type>)

CalcRodOrder(crate::app::battleside::BattleSide_Type) overload

fn calc_rod_action(self, side: impl Into<BattleSide_Type>)

CalcRodAction(crate::app::battleside::BattleSide_Type) overload

fn calc_rod_attack(self, side: impl Into<BattleSide_Type>)

CalcRodAttack(crate::app::battleside::BattleSide_Type) overload

fn calc_dance(self)

CalcDance() overload

fn calc_dance_order(self)

CalcDanceOrder() overload

fn calc_dance_action(self)

CalcDanceAction() overload

fn calc_dance_attack(self)

CalcDanceAttack() overload

fn calc_enchant(self)

CalcEnchant() overload

fn calc_rod_hit( self, current: impl Into<BattleInfoSide>, reverse: impl Into<BattleInfoSide>, unit_item: impl Into<UnitItem>, item: impl Into<ItemData>, )

CalcRodHit(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, crate::app::unititem::UnitItem, crate::app::itemdata::ItemData) overload

fn calc_result(self)

CalcResult() overload

fn can_battle_record(self, side: impl Into<BattleInfoSide>) -> bool

CanBattleRecord(crate::app::battleinfoside::BattleInfoSide) overload

fn calc_record(self)

CalcRecord() overload

fn get_side(self, force: impl Into<Force_Type>) -> BattleInfoSide

GetSide(crate::app::force::Force_Type) overload

fn calc_achieve(self)

CalcAchieve() overload

fn calc_expend_count(self)

CalcExpendCount() overload

fn is_chain_attack_dead(self) -> bool

IsChainAttackDead() overload

fn calc_exp( self, func: impl Into<BattleCalculator_FuncExp1>, current: impl Into<BattleInfoSide>, )

CalcExp(crate::app::battlecalculator::BattleCalculator_FuncExp1, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_exp_2( self, func: impl Into<BattleCalculator_FuncExp2>, current: impl Into<BattleInfoSide>, reverse: impl Into<BattleInfoSide>, )

CalcExp(crate::app::battlecalculator::BattleCalculator_FuncExp2, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide) overload

fn calc_result_gain(self)

CalcResultGain() overload

fn calc_exp_count(self)

CalcExpCount() overload

fn commit_hp(self, side: impl Into<BattleInfoSide>, hp: impl Into<i32>)

CommitHP(crate::app::battleinfoside::BattleInfoSide, i32) overload

fn commit_engage_count( self, side: impl Into<BattleInfoSide>, count: impl Into<i32>, )

CommitEngageCount(crate::app::battleinfoside::BattleInfoSide, i32) overload

fn update_scene(self)

UpdateScene() overload

fn update_scene_2(self, index: impl Into<i32>, is_engae_count: impl Into<bool>)

UpdateScene(i32, bool) overload

fn update_scene_3( self, scene: impl Into<BattleScene>, is_engae_count: impl Into<bool>, )

UpdateScene(crate::app::battlescene::BattleScene, bool) overload

fn commit_unit(self)

CommitUnit() overload

fn commit_skill(self)

CommitSkill() overload

fn commit_destroy(self)

CommitDestroy() overload

fn commit_battle(self)

CommitBattle() overload

fn map_history_commit_skill(self, unit: impl Into<Unit>)

MapHistoryCommitSkill(crate::app::unit::Unit) overload

fn is_training(self) -> bool

IsTraining() overload

fn is_rod(self) -> bool

IsRod() overload

fn get_unit(self, index: impl Into<i32>) -> Unit

GetUnit(i32) overload

fn get_unit_2(self, side: impl Into<BattleSide_Type>) -> Unit

GetUnit(crate::app::battleside::BattleSide_Type) overload

fn get_side_2(self, index: impl Into<i32>) -> BattleInfoSide

GetSide(i32) overload

fn get_side_3(self, side: impl Into<BattleSide_Type>) -> BattleInfoSide

GetSide(crate::app::battleside::BattleSide_Type) overload

fn get_dead_side(self) -> BattleSide_Type

GetDeadSide() overload

fn get_dead_unit(self) -> Unit

GetDeadUnit() overload

fn get_expend_count(self, side: impl Into<BattleInfoSide>) -> i32

GetExpendCount(crate::app::battleinfoside::BattleInfoSide) overload

fn can_sky_battle(self) -> bool

CanSkyBattle() overload

fn is_multi_battle(self) -> bool

IsMultiBattle() overload

fn is_cannon_battle(self) -> bool

IsCannonBattle() overload

fn is_fire_cannon(self) -> bool

IsFireCannon() overload

fn is_full_bullet(self) -> bool

IsFullBullet() overload

fn is_last_boss_die(self) -> bool

IsLastBossDie() overload

fn is_battle_grow(self) -> bool

IsBattleGrow() overload

fn is_combat_die(self) -> bool

IsCombatDie() overload

fn is_combat_grow(self) -> bool

IsCombatGrow() overload

fn get_asset_conditions( self, side_type: impl Into<BattleSide_Type>, ) -> Array<Il2CppString>

GetAssetConditions(crate::app::battleside::BattleSide_Type) overload

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<__T: IBattleCalculator> IBattleCalculatorMethods for __T

Available on crate feature app-battlecalculator only.