Trait IUnitMethods 

pub trait IUnitMethods: IUnit {
    // Provided methods
    fn ctor(self, use_image: impl Into<bool>) { ... }
    fn initialize(self, index: impl Into<i32>) { ... }
    fn create(
        self,
        person: impl Into<PersonData>,
        job: impl Into<JobData>,
        level: impl Into<i32>,
        random: impl Into<Random_2>,
    ) { ... }
    fn create_from_dispos(self, data: impl Into<DisposData>) { ... }
    fn create_challenge_enemy(
        self,
        dispos: impl Into<DisposData>,
        random: impl Into<Random_2>,
        level: impl Into<i32>,
        ejid: impl Into<Il2CppString>,
    ) { ... }
    fn create_encount_enemy(
        self,
        dispos: impl Into<DisposData>,
        unit_rare_type: impl Into<EncountUnitData_RareType>,
        job: impl Into<JobData>,
    ) { ... }
    fn set_encount_hp_stock(
        self,
        dispos: impl Into<DisposData>,
        difficulty: impl Into<Difficulty>,
    ) { ... }
    fn set_hp_stock_count(self, count: impl Into<i32>) { ... }
    fn create_encount_post(
        self,
        dispos: impl Into<DisposData>,
        level: impl Into<i32>,
        offset: impl Into<bool>,
        rare_type: impl Into<EncountUnitData_RareType>,
    ) { ... }
    fn create_encount_mob(
        self,
        pid: impl Into<Il2CppString>,
        jid: impl Into<Il2CppString>,
        equip_weapon_iid: impl Into<Il2CppString>,
    ) { ... }
    fn create_dlc_god_enemy(
        self,
        data: impl Into<DisposData>,
        is_clear_all: impl Into<bool>,
    ) { ... }
    fn create_dlc_god_enemy_impl1(
        self,
        dispos: impl Into<DisposData>,
        level: impl Into<i32>,
        random: impl Into<Random_2>,
    ) { ... }
    fn create_for_vision(
        self,
        original: impl Into<Unit>,
        person: impl Into<PersonData>,
    ) { ... }
    fn create_for_summon(
        self,
        original: impl Into<Unit>,
        rank: impl Into<PersonData_Ranks>,
        person: impl Into<PersonData>,
    ) { ... }
    fn create_for_summon_telop(
        self,
        original: impl Into<Unit>,
        rank: impl Into<PersonData_Ranks>,
        person: impl Into<PersonData>,
    ) { ... }
    fn create_for_summon_common(
        self,
        original: impl Into<Unit>,
        rank: impl Into<PersonData_Ranks>,
        person: impl Into<PersonData>,
    ) { ... }
    fn create_for_arena(
        self,
        emblem: impl Into<GodUnit>,
        level: impl Into<i32>,
        type: impl Into<RingCleaningSequence_GodType>,
    ) { ... }
    fn create_for_versus(self, data: impl Into<DisposData>) { ... }
    fn auto_grow_capability(
        self,
        level: impl Into<i32>,
        target_level: impl Into<i32>,
    ) { ... }
    fn auto_grow_capability_2(
        self,
        level: impl Into<i32>,
        percents: impl Into<CapabilityInt>,
    ) { ... }
    fn clear(self) { ... }
    fn clear_except_map_history_index(self) { ... }
    fn clear_impl(self, is_clear_map_history_index: impl Into<bool>) { ... }
    fn clear_for_rewind_preview(self) -> Il2CppString { ... }
    fn copy_from(self, from: impl Into<Unit>) { ... }
    fn copy_from_for_level_up(self, from: impl Into<Unit>) { ... }
    fn copy_from_for_arena_result(self, from: impl Into<Unit>) { ... }
    fn copy_from_for_versus(self, from: impl Into<Unit>) { ... }
    fn reset_phase_begin(self, phase: impl Into<Force_Type>) { ... }
    fn is_engage_owner(self) -> bool { ... }
    fn reset_phase_begin_after(self, phase: impl Into<Force_Type>) { ... }
    fn reset_phase_end(self, phase: impl Into<Force_Type>) { ... }
    fn reset_sub_phase_charm_confusion_begin(self) { ... }
    fn reset_dead(self) { ... }
    fn reset_map_begin(self) { ... }
    fn reset_map_end(self, is_reset_position: impl Into<bool>) { ... }
    fn map_completed(self) { ... }
    fn fixed(self) { ... }
    fn transfer(self, force: impl Into<Force_Type>, is_last: impl Into<bool>) { ... }
    fn transfer_for_sortie(
        self,
        force: impl Into<Force_Type>,
        is_last: impl Into<bool>,
    ) { ... }
    fn transfer_for_rewind(
        self,
        force: impl Into<Force_Type>,
        prev_unit: impl Into<Unit>,
    ) { ... }
    fn transfer_for_rewind_latest(self, force: impl Into<Force_Type>) { ... }
    fn transfer_impl(
        self,
        force: impl Into<Force_Type>,
        is_last: impl Into<bool>,
        prev_unit: impl Into<Unit>,
        is_delete_actor: impl Into<bool>,
    ) { ... }
    fn update_state(self) { ... }
    fn update_state_with_auto_equip(self) { ... }
    fn update_state_with_equipped(self, equipped: impl Into<UnitItem>) { ... }
    fn try_update_state_with_equipped(
        self,
        equipped: impl Into<UnitItem>,
    ) -> bool { ... }
    fn add_skill(self, array: impl Into<SkillArray>) { ... }
    fn add_skill_2(
        self,
        array: impl Into<SkillArray>,
        category: impl Into<SkillData_Categorys>,
    ) { ... }
    fn add_skill_3(
        self,
        skill: impl Into<SkillData>,
        category: impl Into<SkillData_Categorys>,
        age: impl Into<i32>,
    ) { ... }
    fn add_skill_without_update(
        self,
        skill: impl Into<SkillData>,
        category: impl Into<SkillData_Categorys>,
        age: impl Into<i32>,
    ) -> bool { ... }
    fn is_engaging(self, god_unit: impl Into<GodUnit>) -> bool { ... }
    fn update_state_impl(
        self,
        is_auto_equip: impl Into<bool>,
        equipped: impl Into<UnitItem>,
    ) { ... }
    fn commit_enhance(self, equipped: impl Into<UnitItem>) { ... }
    fn update_place(self) { ... }
    fn create_actor(self) { ... }
    fn try_create_actor(self) -> bool { ... }
    fn reload_actor(self) { ... }
    fn delete_actor(self) { ... }
    fn update_actor(self) { ... }
    fn tick_actor(self) { ... }
    fn check_status(self, status: impl Into<Unit_Status>) -> bool { ... }
    fn not_status(self, status: impl Into<Unit_Status>) -> bool { ... }
    fn set_status(self, status: impl Into<Unit_Status>) { ... }
    fn clear_status(self, status: impl Into<Unit_Status>) { ... }
    fn change_status(self, status: impl Into<Unit_Status>) { ... }
    fn get_status(self) -> Unit_StatusField { ... }
    fn set_dead(self) { ... }
    fn get_name(self) -> Il2CppString { ... }
    fn get_talk_name(self) -> Il2CppString { ... }
    fn get_name_impl(self, is_morph: impl Into<bool>) -> Il2CppString { ... }
    fn get_ascii_name(self) -> Il2CppString { ... }
    fn get_job_name(self) -> Il2CppString { ... }
    fn set_position(self, pos: impl Into<Vector3>, update: impl Into<bool>) { ... }
    fn set_position_2(
        self,
        x: impl Into<i32>,
        z: impl Into<i32>,
        update: impl Into<bool>,
    ) { ... }
    fn set_rotation(self, angle: impl Into<f32>) { ... }
    fn set_force_for_stand_alone(self, force: impl Into<Force>) { ... }
    fn is_hero(self) -> bool { ... }
    fn is_dead(self) -> bool { ... }
    fn get_gender(self) -> Gender { ... }
    fn get_dress_gender(self) -> Gender { ... }
    fn is_female(self) -> bool { ... }
    fn is_leader(self) -> bool { ... }
    fn is_morph(self) -> bool { ... }
    fn has_fang_curse(self) -> bool { ... }
    fn is_enchantment(self) -> bool { ... }
    fn is_move_not_allow(self) -> bool { ... }
    fn is_unique(self) -> bool { ... }
    fn is_show(self) -> bool { ... }
    fn can_sortie(self) -> bool { ... }
    fn is_play_area(self) -> bool { ... }
    fn is_play_area_2(self, x: impl Into<i32>, z: impl Into<i32>) -> bool { ... }
    fn is_allied(self, unit: impl Into<Unit>) -> bool { ... }
    fn is_operate(self) -> bool { ... }
    fn is_efficacy(self, target: impl Into<Unit>) -> bool { ... }
    fn get_attrs(self) -> SkillData_Attrs { ... }
    fn can_transporter(self) -> bool { ... }
    fn can_breakable(self, target: impl Into<Unit>) -> bool { ... }
    fn can_sky_battle(self) -> bool { ... }
    fn get_force_absent_type(self) -> Force_Type { ... }
    fn get_force_dead_type(self) -> Force_Type { ... }
    fn is_same_force_type(self, force_type: impl Into<Force_Type>) -> bool { ... }
    fn set_engage_impl(self, enable: impl Into<bool>, link: impl Into<bool>) { ... }
    fn set_engage_link_simulation(
        self,
        enable: impl Into<bool>,
        link: impl Into<Unit>,
    ) { ... }
    fn set_engage_simulation(
        self,
        enable: impl Into<bool>,
        link: impl Into<Unit>,
    ) { ... }
    fn set_god_link_impl(self, god_link: impl Into<GodUnit>) { ... }
    fn play_engage(self, enable: impl Into<bool>) { ... }
    fn is_engaging_2(self) -> bool { ... }
    fn is_hero_engaging(self) -> bool { ... }
    fn can_engage_heal(self) -> bool { ... }
    fn set_engage_link(
        self,
        enable: impl Into<bool>,
        god_link: impl Into<GodUnit>,
        parent: impl Into<Unit>,
        child: impl Into<Unit>,
    ) { ... }
    fn set_engage(self, enable: impl Into<bool>, link: impl Into<Unit>) { ... }
    fn try_relocation(self) -> bool { ... }
    fn is_active_route(self) -> bool { ... }
    fn get_first_x(self) -> i32 { ... }
    fn get_first_z(self) -> i32 { ... }
    fn force_set_engage_link_for_rewind(self, link_unit: impl Into<Unit>) { ... }
    fn set_engage_attack(self, enable: impl Into<bool>) { ... }
    fn can_engage_impl(self, god_unit: impl Into<GodUnit>) -> bool { ... }
    fn can_engage_cancel(self, pickup: impl Into<bool>) -> bool { ... }
    fn can_engage_start(self) -> bool { ... }
    fn can_engage_link(self) -> bool { ... }
    fn get_linkable_god_unit(self) -> GodUnit { ... }
    fn get_engage_link_unit(self) -> Unit { ... }
    fn pre_start_target_select(self) { ... }
    fn post_start_target_select(self) { ... }
    fn try_add_achieve_engage(self) { ... }
    fn decide_target_select(self, is_redoer: impl Into<bool>) { ... }
    fn cancel_target_select(self) { ... }
    fn can_change_engage(self, target_unit: impl Into<Unit>) -> bool { ... }
    fn try_change_engage(
        self,
        target_unit: impl Into<Unit>,
        item_index: impl Into<i32>,
    ) -> bool { ... }
    fn change_engage(
        self,
        target_unit: impl Into<Unit>,
        item_index: impl Into<i32>,
    ) { ... }
    fn can_engage_attack(self) -> bool { ... }
    fn can_engage_target(self, target: impl Into<Unit>) -> bool { ... }
    fn engage_target_exists(
        self,
        target: impl Into<Unit>,
        skill: impl Into<SkillData>,
    ) -> bool { ... }
    fn can_enemy_engage_attack(self) -> bool { ... }
    fn can_execute_engage_attack(self) -> bool { ... }
    fn can_act(
        self,
        is_fixed: impl Into<bool>,
        is_charged: impl Into<bool>,
    ) -> bool { ... }
    fn can_act_without_engage_charge(self) -> bool { ... }
    fn can_be_target(self) -> bool { ... }
    fn can_external_move(self) -> bool { ... }
    fn is_sight(self, x: impl Into<i32>, z: impl Into<i32>) -> bool { ... }
    fn can_warp(
        self,
        rod_unit: impl Into<Unit>,
        x: impl Into<i32>,
        z: impl Into<i32>,
    ) -> bool { ... }
    fn can_skill(self, skill: impl Into<SkillData>) -> bool { ... }
    fn can_change_god(self) -> bool { ... }
    fn change_god(self) -> bool { ... }
    fn get_cells(self, cells: impl Into<Array<MapPos>>) -> i32 { ... }
    fn get_cells_2(
        self,
        cells: impl Into<Array<MapPos>>,
        base_x: impl Into<i32>,
        base_z: impl Into<i32>,
    ) -> i32 { ... }
    fn set_base_capability(self, index: impl Into<i32>, value: impl Into<i32>) { ... }
    fn add_base_capability(self, index: impl Into<i32>, value: impl Into<i32>) { ... }
    fn set_capability_just(self, index: impl Into<i32>, value: impl Into<i32>) { ... }
    fn get_god_enhance_rating(self, god: impl Into<GodUnit>) -> i32 { ... }
    fn change_hp(self, hp: impl Into<i32>) { ... }
    fn play_set_hp(self, hp: impl Into<i32>) { ... }
    fn play_set_heal(self, heal: impl Into<i32>) { ... }
    fn play_set_damage(
        self,
        damage: impl Into<i32>,
        can_die: impl Into<bool>,
        is_multi: impl Into<bool>,
    ) { ... }
    fn is_changing_hp(self) -> bool { ... }
    fn get_max_hp(self) -> i32 { ... }
    fn get_str(self) -> i32 { ... }
    fn get_tech(self) -> i32 { ... }
    fn get_quick(self) -> i32 { ... }
    fn get_luck(self) -> i32 { ... }
    fn get_def(self) -> i32 { ... }
    fn get_magic(self) -> i32 { ... }
    fn get_mdef(self) -> i32 { ... }
    fn get_phys(self) -> i32 { ... }
    fn get_sight(self) -> i32 { ... }
    fn get_move_power(self) -> i32 { ... }
    fn get_move_power_without_removing(self) -> i32 { ... }
    fn find_skill(self, flags: impl Into<SkillData_Flags>) -> SkillData { ... }
    fn find_skill_2(self, states: impl Into<SkillData_States>) -> SkillData { ... }
    fn get_removable_skill(self) -> SkillData { ... }
    fn get_removable_power(self) -> i32 { ... }
    fn get_capability(
        self,
        index: impl Into<i32>,
        calc_enhance: impl Into<bool>,
    ) -> i32 { ... }
    fn get_capability_2(
        self,
        type: impl Into<CapabilityDefinition_Type>,
        calc_enhance: impl Into<bool>,
    ) -> i32 { ... }
    fn get_capability_grow(
        self,
        index: impl Into<i32>,
        is_auto_grow: impl Into<bool>,
    ) -> i32 { ... }
    fn get_capability_grow_2(
        self,
        type: impl Into<CapabilityDefinition_Type>,
        is_auto_grow: impl Into<bool>,
    ) -> i32 { ... }
    fn get_capability_limit(
        self,
        type: impl Into<CapabilityDefinition_Type>,
    ) -> i32 { ... }
    fn get_capability_limit_2(self, index: impl Into<i32>) -> i32 { ... }
    fn can_capability_grow(
        self,
        type: impl Into<CapabilityDefinition_Type>,
    ) -> bool { ... }
    fn can_capability_grow_2(self, index: impl Into<i32>) -> bool { ... }
    fn get_strength_capability_index(
        self,
        rand: impl Into<Random_2>,
    ) -> CapabilityDefinition_Type { ... }
    fn get_no_enhance_max_hp(self) -> i32 { ... }
    fn get_no_enhance_str(self) -> i32 { ... }
    fn get_no_enhance_tech(self) -> i32 { ... }
    fn get_no_enhance_quick(self) -> i32 { ... }
    fn get_no_enhance_luck(self) -> i32 { ... }
    fn get_no_enhance_def(self) -> i32 { ... }
    fn get_no_enhance_magic(self) -> i32 { ... }
    fn get_no_enhance_mdef(self) -> i32 { ... }
    fn get_no_enhance_phys(self) -> i32 { ... }
    fn get_no_enhance_sight(self) -> i32 { ... }
    fn get_no_enhance_move_power(self) -> i32 { ... }
    fn get_no_enhance_capability(self, index: impl Into<i32>) -> i32 { ... }
    fn get_no_enhance_capability_2(
        self,
        type: impl Into<CapabilityDefinition_Type>,
    ) -> i32 { ... }
    fn get_enhanced_level(self) -> i32 { ... }
    fn add_hp(self, v: impl Into<i32>) { ... }
    fn is_dont_attack(self, unit: impl Into<Unit>) -> bool { ... }
    fn set_dont_attack(self, person: impl Into<PersonData>) { ... }
    fn set_dont_attack_force_mask(self, force_mask: impl Into<u32>) { ... }
    fn get_entrust_for_ai(self) -> UnitEntrust_Type { ... }
    fn can_talk(self) -> bool { ... }
    fn can_dance(self, target: impl Into<Unit>) -> bool { ... }
    fn can_contract(self, target: impl Into<Unit>) -> bool { ... }
    fn can_again(self) -> bool { ... }
    fn can_chain(self, parent: impl Into<Unit>) -> bool { ... }
    fn can_chain_attack(self) -> bool { ... }
    fn is_terrain_invalid(self, terrain: impl Into<TerrainData_2>) -> bool { ... }
    fn can_chain_guard(self) -> bool { ... }
    fn get_guard_type(self) -> Unit_GuardType { ... }
    fn can_ccogitation(self) -> bool { ... }
    fn can_trade(self) -> bool { ... }
    fn can_gain_reliance(self) -> bool { ... }
    fn has_skill(self, skill: impl Into<SkillData>) -> bool { ... }
    fn has_skill_2(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn has_skill_3(self, flags: impl Into<SkillData_Flags>) -> bool { ... }
    fn has_skill_4(self, states: impl Into<SkillData_States>) -> bool { ... }
    fn has_dance_skill(self) -> bool { ... }
    fn has_contract_skill(self) -> bool { ... }
    fn is_standing_die(self) -> bool { ... }
    fn is_immortal(self) -> bool { ... }
    fn is_last_boss(self) -> bool { ... }
    fn get_equip_skill(self, index: impl Into<i32>) -> SkillData { ... }
    fn has_equip_skill(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn has_equip_skill_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn add_equip_skill(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn add_equip_skill_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn remove_equip_skill(self, sid: impl Into<Il2CppString>) { ... }
    fn remove_equip_skill_2(self, skill: impl Into<SkillData>) { ... }
    fn replace_equip_skill(
        self,
        index: impl Into<i32>,
        sid: impl Into<Il2CppString>,
    ) { ... }
    fn replace_equip_skill_2(
        self,
        index: impl Into<i32>,
        skill: impl Into<SkillData>,
    ) { ... }
    fn move_equip_skill(
        self,
        old_index: impl Into<i32>,
        new_index: impl Into<i32>,
    ) { ... }
    fn has_private_skill(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn has_private_skill_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn add_private_skill(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn add_private_skill_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn add_private_skill_3(self, skills: impl Into<SkillArray>) -> bool { ... }
    fn remove_private_skill(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn remove_private_skill_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn remove_private_skill_3(self, skills: impl Into<SkillArray>) -> bool { ... }
    fn get_record(self, kind: impl Into<UnitRecord_Kinds>) -> i32 { ... }
    fn set_record(
        self,
        kind: impl Into<UnitRecord_Kinds>,
        value: impl Into<i32>,
    ) { ... }
    fn add_record(
        self,
        kind: impl Into<UnitRecord_Kinds>,
        value: impl Into<i32>,
    ) { ... }
    fn inc_record(self, kind: impl Into<UnitRecord_Kinds>) { ... }
    fn dec_record(self, kind: impl Into<UnitRecord_Kinds>) { ... }
    fn add_record_with_history(
        self,
        kind: impl Into<UnitRecord_Kinds>,
        value: impl Into<i32>,
    ) { ... }
    fn get_from_equip_skill_pool(self, index: impl Into<i32>) -> SkillData { ... }
    fn add_to_equip_skill_pool(self, sid: impl Into<Il2CppString>) { ... }
    fn add_to_equip_skill_pool_2(self, skill: impl Into<SkillData>) { ... }
    fn remove_from_equip_skill_pool(self, sid: impl Into<Il2CppString>) { ... }
    fn remove_from_equip_skill_pool_2(self, skill: impl Into<SkillData>) { ... }
    fn is_exist_in_equip_skill_pool(self, sid: impl Into<Il2CppString>) -> bool { ... }
    fn is_exist_in_equip_skill_pool_2(self, skill: impl Into<SkillData>) -> bool { ... }
    fn is_inheritance_enable(self, skill: impl Into<SkillData>) -> bool { ... }
    fn is_poison(self) -> bool { ... }
    fn is_stun(self) -> bool { ... }
    fn is_sleep(self) -> bool { ... }
    fn is_silence(self) -> bool { ... }
    fn is_charm(self) -> bool { ... }
    fn is_confusion(self) -> bool { ... }
    fn is_charm_or_confusion(self) -> bool { ... }
    fn is_freeze(self) -> bool { ... }
    fn is_weakness(self) -> bool { ... }
    fn is_not_enhance(self) -> bool { ... }
    fn is_disorder(self) -> bool { ... }
    fn clear_disorder(self, state: impl Into<SkillData_States>) -> bool { ... }
    fn is_vision(self) -> bool { ... }
    fn is_vision_2(self, owner: impl Into<Unit>) -> bool { ... }
    fn can_gain_item(self) -> bool { ... }
    fn get_vision_owner(self) -> Unit { ... }
    fn is_summon(self) -> bool { ... }
    fn is_summon_2(self, owner: impl Into<Unit>) -> bool { ... }
    fn is_summon_god(self) -> bool { ... }
    fn get_summon_owner(self) -> Unit { ... }
    fn is_lockon(self) -> bool { ... }
    fn try_get_lock_target(self) -> (bool, i32, i32) { ... }
    fn set_lock_target(self, x: impl Into<i32>, z: impl Into<i32>) { ... }
    fn reset_lock_target(self) { ... }
    fn is_on_map(self) -> bool { ... }
    fn is_decoy(self) -> bool { ... }
    fn add_exp(self, exp: impl Into<i32>) { ... }
    fn add_skill_point(self, skill_point: impl Into<i32>) { ... }
    fn can_grow(self) -> bool { ... }
    fn normalize_exp(self, exp: impl Into<i32>) -> i32 { ... }
    fn exp_to_skill_point(self, exp: impl Into<i32>) -> i32 { ... }
    fn nomralize_skill_point(self, skill_point: impl Into<i32>) -> i32 { ... }
    fn level_up(self, abort: impl Into<i32>) { ... }
    fn dbg_level_down(self) { ... }
    fn learn_job_skill(self) -> SkillData { ... }
    fn learn_job_skill_for_chart(self, level: impl Into<i32>) -> SkillData { ... }
    fn learn_job_skill_2(
        self,
        level: impl Into<i32>,
        job: impl Into<JobData>,
    ) -> SkillData { ... }
    fn learn_job_skill_3(self, job: impl Into<JobData>) -> SkillData { ... }
    fn cc_check_aptitude(self, job: impl Into<JobData>) -> bool { ... }
    fn class_change(self, job: impl Into<JobData>, item: impl Into<ItemData>) { ... }
    fn class_change_for_chart(
        self,
        job: impl Into<JobData>,
        item: impl Into<ItemData>,
        level: impl Into<i32>,
    ) { ... }
    fn update_difficulty(self) { ... }
    fn reset_weapon_mask(self) { ... }
    fn set_selected_weapon(self, selected_weapon_mask: impl Into<WeaponMask>) { ... }
    fn set_selected_weapon_from_original_aptitude(
        self,
        aptitude: impl Into<WeaponMask>,
    ) { ... }
    fn set_weapon_mask_from_parson(self) { ... }
    fn set_optimal_weapon_for_class_change(
        self,
        weapon_mask: impl Into<WeaponMask>,
        is_bullet: impl Into<bool>,
    ) -> UnitItem { ... }
    fn set_selected_weapon_from_items(
        self,
        items: impl Into<Unit_ItemsForSelectedWeapon>,
    ) { ... }
    fn set_selected_weapon_for_chart(
        self,
        chart_items: impl Into<Array<ChartData_Item>>,
    ) { ... }
    fn set_selected_weapon_from_dispos(self, data: impl Into<DisposData>) { ... }
    fn inherit_aptitude(self, god_unit: impl Into<GodUnit>) { ... }
    fn inherit_aptitude_2(self, god_bond: impl Into<GodBond>) { ... }
    fn add_aptitude_for_chart(self) { ... }
    fn set_aptitude_from_dispos(self, data: impl Into<DisposData>) { ... }
    fn add_aptitude_from_weapon_mask(self) { ... }
    fn update_weapon_mask(self) { ... }
    fn ai_activate(self, attacked: impl Into<bool>) { ... }
    fn ai_activate_cause_attacked(self, longrange: impl Into<bool>) { ... }
    fn ai_set_engage_attack(self) { ... }
    fn ai_clear_engage_attack(self) { ... }
    fn has_item(self, is_exclude_engage: impl Into<bool>) -> bool { ... }
    fn has_rod(self) -> bool { ... }
    fn has_heal_rod(self) -> bool { ... }
    fn has_heal_rod_for_oneself(
        self,
        rod_type: impl Into<ItemData_RodTypes>,
    ) -> bool { ... }
    fn has_support_rod(self) -> bool { ... }
    fn has_support_rod_for_oneself(
        self,
        rod_type: impl Into<ItemData_RodTypes>,
    ) -> bool { ... }
    fn has_interference_rod(self) -> bool { ... }
    fn has_criticale_weapon(self) -> bool { ... }
    fn has_efficacy_weapon(self, target: impl Into<Unit>) -> bool { ... }
    fn has_drop_item(self) -> bool { ... }
    fn has_max_item(self) -> bool { ... }
    fn get_item(self, index: impl Into<i32>) -> UnitItem { ... }
    fn get_item_index(self, iid: impl Into<Il2CppString>) -> i32 { ... }
    fn get_item_index_2(self, item: impl Into<ItemData>) -> i32 { ... }
    fn for_each_unit_item(self, func: impl Into<Unit_FuncUnitItem>) { ... }
    fn for_each_can_equip_item(self, func: impl Into<Unit_FuncUnitItem>) { ... }
    fn get_actual_item(self, unit_item: impl Into<UnitItem>) -> UnitItem { ... }
    fn is_item_equipped(self) -> bool { ... }
    fn get_item_equipped(self) -> UnitItem { ... }
    fn get_item_index_equipped(self) -> i32 { ... }
    fn get_item_hold(self) -> UnitItem { ... }
    fn get_item_index_hold(self) -> i32 { ... }
    fn item_add(self, iid: impl Into<Il2CppString>) -> i32 { ... }
    fn item_add_2(self, iids: impl Into<Array<Il2CppString>>) -> bool { ... }
    fn item_add_3(self, item: impl Into<ItemData>) -> i32 { ... }
    fn item_add_4(self, unit_item: impl Into<UnitItem>) -> i32 { ... }
    fn item_add_on_dlc_evil(
        self,
        iids: impl Into<Array<Il2CppString>>,
        chapter: impl Into<ChapterData>,
        level: impl Into<i32>,
    ) { ... }
    fn equipable_item_add(self, iids: impl Into<Array<Il2CppString>>) -> bool { ... }
    fn item_move(self, from: impl Into<i32>, to: impl Into<i32>) { ... }
    fn item_close_up(self) { ... }
    fn item_equip(self) -> bool { ... }
    fn item_equip_2(
        self,
        index: impl Into<i32>,
        reoder: impl Into<bool>,
    ) -> bool { ... }
    fn item_reorder(self) { ... }
    fn item_equip_3(self, unit_item: impl Into<UnitItem>) -> bool { ... }
    fn item_equip_4(self, item_data: impl Into<ItemData>) -> bool { ... }
    fn item_take_off(self, index: impl Into<i32>) { ... }
    fn item_take_off_2(self, unit_item: impl Into<UnitItem>) { ... }
    fn item_put_off(self, index: impl Into<i32>, closeup: impl Into<bool>) { ... }
    fn item_put_off_2(
        self,
        unit_item: impl Into<UnitItem>,
        closeup: impl Into<bool>,
    ) { ... }
    fn item_put_off_all(self) { ... }
    fn has_item_2(self, item: impl Into<ItemData>) -> bool { ... }
    fn get_item_count(self) -> i32 { ... }
    fn get_item_selected(self) -> UnitItem { ... }
    fn set_item_selected(self, unit_item: impl Into<UnitItem>) { ... }
    fn has_equipable_item(self) -> bool { ... }
    fn has_equipable_item_2(self, range: impl Into<i32>) -> bool { ... }
    fn has_equipable_item_3(self, kind: impl Into<ItemData_Kinds>) -> bool { ... }
    fn can_item_equip(
        self,
        unit_item: impl Into<UnitItem>,
        rod: impl Into<bool>,
        exp: impl Into<bool>,
    ) -> bool { ... }
    fn can_item_equip_2(
        self,
        item: impl Into<ItemData>,
        rod: impl Into<bool>,
        weapon_level: impl Into<bool>,
    ) -> bool { ... }
    fn can_item_equip_3(
        self,
        index: impl Into<i32>,
        rod: impl Into<bool>,
        exp: impl Into<bool>,
    ) -> bool { ... }
    fn can_item_kind_equip(
        self,
        kind: impl Into<ItemData_Kinds>,
        rod: impl Into<bool>,
        weapon_mask: impl Into<bool>,
    ) -> bool { ... }
    fn can_use_cannon(self, x: impl Into<i32>, z: impl Into<i32>) -> bool { ... }
    fn can_use_cannon_2(self, terrain: impl Into<TerrainData_2>) -> bool { ... }
    fn next_item_equip(self, reverse: impl Into<bool>) -> bool { ... }
    fn is_item_sealed(self, unit_item: impl Into<UnitItem>) -> bool { ... }
    fn is_item_sealed_2(self, item: impl Into<ItemData>) -> bool { ... }
    fn is_item_sealed_3(self, index: impl Into<i32>) -> bool { ... }
    fn get_item_index_key_door(self) -> i32 { ... }
    fn can_unlock_door(self, enable_item: impl Into<bool>) -> bool { ... }
    fn can_unlock_treasure_box(self, enable_item: impl Into<bool>) -> bool { ... }
    fn get_range_i(
        self,
        index: impl Into<i32>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_i_2(
        self,
        item: impl Into<ItemData>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_i_3(
        self,
        unit_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_o(
        self,
        index: impl Into<i32>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_o_2(
        self,
        item: impl Into<ItemData>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_o_3(
        self,
        unit_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> i32 { ... }
    fn get_range_io(
        self,
        index: impl Into<i32>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_range_io_2(
        self,
        item: impl Into<ItemData>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_range_io_3(
        self,
        unit_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_item_distance(self, item: impl Into<ItemData>) -> i32 { ... }
    fn get_rod_range_extend(self, item: impl Into<ItemData>) -> i32 { ... }
    fn get_item_range(
        self,
        item: impl Into<ItemData>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_skill_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32) { ... }
    fn get_item_range_2(
        self,
        equip_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_item_range_3(
        self,
        item_mask: impl Into<u32>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_engage_range(self) -> (bool, i32, i32) { ... }
    fn get_attack_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32) { ... }
    fn get_rod_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32) { ... }
    fn get_attack_range_2(
        self,
        equip_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_rod_range_2(
        self,
        equip_item: impl Into<UnitItem>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_revenge_weapon(
        self,
        target: impl Into<Unit>,
        target_item: impl Into<UnitItem>,
        range: impl Into<i32>,
    ) -> UnitItem { ... }
    fn get_rod_heal_power(self, unit_item: impl Into<UnitItem>) -> i32 { ... }
    fn can_item_use(self, item: impl Into<ItemData>) -> bool { ... }
    fn can_item_use_2(
        self,
        item: impl Into<ItemData>,
        target_unit: impl Into<Unit>,
    ) -> bool { ... }
    fn item_use_impl(
        self,
        item: impl Into<ItemData>,
        use_type: impl Into<ItemData_UseTypes>,
        power: impl Into<i32>,
        give_skills: impl Into<SkillArray>,
    ) { ... }
    fn item_use(self, item: impl Into<ItemData>) { ... }
    fn item_enchant(self, unit: impl Into<Unit>, item: impl Into<ItemData>) { ... }
    fn is_item_enhance_having(self, item_data: impl Into<ItemData>) -> bool { ... }
    fn is_draw_active_color(self, unit_item: impl Into<UnitItem>) -> bool { ... }
    fn get_accessory_list(self) -> UnitAccessoryList { ... }
    fn set_ring(self, ring: impl Into<UnitRing>) { ... }
    fn set_ring_impl(self, ring: impl Into<UnitRing>) { ... }
    fn clear_ring(self) { ... }
    fn clear_ring_impl(self) { ... }
    fn get_ring(self) -> UnitRing { ... }
    fn get_power(self) -> i32 { ... }
    fn set_god_unit(self, god_unit: impl Into<GodUnit>) { ... }
    fn set_god_unit_to_copy(self, god_unit: impl Into<GodUnit>) { ... }
    fn clear_god_unit(self) { ... }
    fn clear_god_unit_from_copy(self) { ... }
    fn can_god_equip(self, god_unit: impl Into<GodUnit>) -> bool { ... }
    fn reset_engage_count(self) { ... }
    fn play_engage_cancel(self) { ... }
    fn reset_engaing(self) { ... }
    fn try_connect_god_unit(self, god_unit: impl Into<GodUnit>) -> GodUnit { ... }
    fn try_connect_god_unit_to_copy(
        self,
        god_unit: impl Into<GodUnit>,
    ) -> GodUnit { ... }
    fn try_disconnect_god_unit(self) -> GodUnit { ... }
    fn try_disconnect_ring(self) -> UnitRing { ... }
    fn try_disconnect_god_unit_from_copy(self) -> GodUnit { ... }
    fn try_disconnect_god_link_from_copy(self) -> GodUnit { ... }
    fn sight_up(self, unit: impl Into<Unit>, item: impl Into<ItemData>) -> bool { ... }
    fn can_revive(self) -> bool { ... }
    fn is_asphyxiation(self) -> bool { ... }
    fn revive(self) { ... }
    fn revive_for_rewind_v0(self, hp_stock_count: impl Into<u8>) { ... }
    fn revive_for_rewind_v1(
        self,
        plain_hp_stock_count: impl Into<u8>,
        extra_hp_stock_count: impl Into<u8>,
        extra_hp_stock_count_max: impl Into<u8>,
    ) { ... }
    fn set_god_state(self, index: impl Into<i32>, state: impl Into<GodState>) { ... }
    fn get_god_state(self, index: impl Into<i32>) -> GodState { ... }
    fn get_god_state_count(self) -> i32 { ... }
    fn is_default_god_states(self) -> bool { ... }
    fn get_current_god_state_index(self) -> i32 { ... }
    fn get_current_god_state(self) -> GodState { ... }
    fn can_set_extra_hp_stock(self) -> bool { ... }
    fn has_extra_hp_stock(self) -> bool { ... }
    fn set_extra_hp_stock(self) { ... }
    fn clear_extra_hp_stock(self) { ... }
    fn extra_hp_stock_for_rewind(
        self,
        is_set: impl Into<bool>,
        extra_hp_stock_count: impl Into<u8>,
        extra_hp_stock_count_max: impl Into<u8>,
    ) { ... }
    fn dbg_set_hp_stock_count(self, count: impl Into<i32>) { ... }
    fn update_god_unit_for_god_state(
        self,
        new_god_state: impl Into<GodState>,
        old_god_state: impl Into<GodState>,
    ) { ... }
    fn serialize(self, stream: impl Into<Stream_2>) { ... }
    fn deserialize(self, stream: impl Into<Stream_2>) { ... }
    fn get_prev(self) -> Unit { ... }
    fn set_prev(self, value: impl Into<Unit>) { ... }
    fn get_next(self) -> Unit { ... }
    fn set_next(self, value: impl Into<Unit>) { ... }
    fn get_ai(self) -> UnitAI { ... }
    fn get_edit(self) -> UnitEdit { ... }
    fn get_person(self) -> PersonData { ... }
    fn set_person(self, value: impl Into<PersonData>) { ... }
    fn get_pid(self) -> Il2CppString { ... }
    fn get_prefixless_pid(self) -> Il2CppString { ... }
    fn get_job(self) -> JobData { ... }
    fn set_job(self, value: impl Into<JobData>) { ... }
    fn get_jid(self) -> Il2CppString { ... }
    fn get_prefixless_jid(self) -> Il2CppString { ... }
    fn get_force(self) -> Force { ... }
    fn set_force(self, value: impl Into<Force>) { ... }
    fn get_force_type(self) -> Force_Type { ... }
    fn get_force_mask(self) -> u32 { ... }
    fn get_base_capability(self) -> UnitBaseCapability { ... }
    fn get_grow_capability(self) -> Capability { ... }
    fn get_level_capability(self) -> UnitBaseCapability { ... }
    fn get_grow_seed(self) -> u32 { ... }
    fn set_grow_seed(self, value: impl Into<u32>) { ... }
    fn get_drop_seed(self) -> u32 { ... }
    fn set_drop_seed(self, value: impl Into<u32>) { ... }
    fn get_actor(self) -> UnitActor { ... }
    fn set_actor(self, value: impl Into<UnitActor>) { ... }
    fn get_info(self) -> MapInfoRoot { ... }
    fn set_info(self, value: impl Into<MapInfoRoot>) { ... }
    fn get_unit_model(self) -> UnitModel { ... }
    fn get_god_model(self) -> UnitModel { ... }
    fn get_position(self) -> Vector3 { ... }
    fn get_cell_center_position(self) -> Vector3 { ... }
    fn get_direction(self) -> Vector3 { ... }
    fn get_index(self) -> i32 { ... }
    fn set_index(self, value: impl Into<i32>) { ... }
    fn get_bmap_size(self) -> i32 { ... }
    fn get_style(self) -> BattleStyle_Types { ... }
    fn get_x(self) -> i32 { ... }
    fn set_x(self, value: impl Into<i32>) { ... }
    fn get_z(self) -> i32 { ... }
    fn set_z(self, value: impl Into<i32>) { ... }
    fn get_dispos_x(self) -> i32 { ... }
    fn set_dispos_x(self, value: impl Into<i32>) { ... }
    fn get_dispos_z(self) -> i32 { ... }
    fn set_dispos_z(self, value: impl Into<i32>) { ... }
    fn get_center_x(self) -> i32 { ... }
    fn get_center_z(self) -> i32 { ... }
    fn get_angle(self) -> f32 { ... }
    fn set_angle(self, value: impl Into<f32>) { ... }
    fn get_dispos_sound(self) -> i32 { ... }
    fn get_move_type(self) -> JobData_MoveTypes { ... }
    fn get_level(self) -> i32 { ... }
    fn set_level(self, value: impl Into<i32>) { ... }
    fn get_limit_level(self) -> i32 { ... }
    fn get_exp(self) -> i32 { ... }
    fn set_exp(self, value: impl Into<i32>) { ... }
    fn get_skill_point(self) -> i32 { ... }
    fn set_skill_point(self, value: impl Into<i32>) { ... }
    fn get_hp(self) -> i32 { ... }
    fn set_hp(self, value: impl Into<i32>) { ... }
    fn get_display_hp(self) -> i32 { ... }
    fn get_hp_stock_count(self) -> i32 { ... }
    fn get_hp_stock_count_max(self) -> i32 { ... }
    fn get_plain_hp_stock_count(self) -> i32 { ... }
    fn set_plain_hp_stock_count(self, value: impl Into<i32>) { ... }
    fn get_plain_hp_stock_count_max(self) -> i32 { ... }
    fn get_extra_hp_stock_count(self) -> i32 { ... }
    fn get_extra_hp_stock_count_max(self) -> i32 { ... }
    fn get_base_move_power(self) -> i32 { ... }
    fn get_item_list(self) -> UnitItemList { ... }
    fn get_god_unit(self) -> GodUnit { ... }
    fn get_actual_god_unit(self) -> GodUnit { ... }
    fn get_extra_sight(self) -> i32 { ... }
    fn set_extra_sight(self, value: impl Into<i32>) { ... }
    fn get_move_distance(self) -> i32 { ... }
    fn get_mask_skill_lock(self) -> Object { ... }
    fn get_mask_skill(self) -> SkillArray { ... }
    fn get_equip_skill_2(self) -> SkillArray { ... }
    fn get_private_skill(self) -> SkillArray { ... }
    fn get_supported_skill(self) -> SkillArray { ... }
    fn get_receive_skill(self) -> SkillArray { ... }
    fn get_equip_skill_pool(self) -> SkillArray { ... }
    fn get_learned_job_skill(self) -> SkillData { ... }
    fn set_learned_job_skill(self, value: impl Into<SkillData>) { ... }
    fn get_original_aptitude(self) -> WeaponMask { ... }
    fn get_aptitude(self) -> WeaponMask { ... }
    fn get_weapon_mask(self) -> WeaponMask { ... }
    fn get_selected_weapon_mask(self) -> WeaponMask { ... }
    fn get_enhance_factors(self) -> UnitEnhanceFactors { ... }
    fn get_internal_level(self) -> i32 { ... }
    fn set_internal_level(self, value: impl Into<i32>) { ... }
    fn get_last_pick_voice(self) -> i8 { ... }
    fn set_last_pick_voice(self, value: impl Into<i8>) { ... }
    fn get_max_stun(self) -> i32 { ... }
    fn get_stun(self) -> i32 { ... }
    fn get_engage_count(self) -> i32 { ... }
    fn set_engage_count(self, value: impl Into<i32>) { ... }
    fn play_set_engage_count(
        self,
        engage_count: impl Into<i32>,
        target_unit: impl Into<Unit>,
    ) { ... }
    fn play_set_engage_count_2(
        self,
        start: impl Into<Vector3>,
        goal: impl Into<Vector3>,
        count: impl Into<i32>,
    ) { ... }
    fn get_engage_count_view(self) -> i32 { ... }
    fn set_engage_count_view(self, count: impl Into<i32>) { ... }
    fn get_engage_count_limit(self) -> i32 { ... }
    fn get_engage_turn(self) -> i32 { ... }
    fn set_engage_turn(self, value: impl Into<i32>) { ... }
    fn get_remaining_engage_turn(self) -> i32 { ... }
    fn get_engage_turn_limit(self) -> i32 { ... }
    fn get_alpha(self) -> f32 { ... }
    fn get_ident(self) -> i32 { ... }
    fn set_ident(self, value: impl Into<i32>) { ... }
    fn get_record_2(self) -> UnitRecord { ... }
    fn get_map_history_index(self) -> i32 { ... }
    fn set_map_history_index(self, value: impl Into<i32>) { ... }
    fn get_relay_player_index(self) -> i32 { ... }
    fn set_relay_player_index(self, value: impl Into<i32>) { ... }
    fn create_impl1(
        self,
        person: impl Into<PersonData>,
        job: impl Into<JobData>,
        level: impl Into<i32>,
        random: impl Into<Random_2>,
    ) { ... }
    fn try_copy_edit(self) { ... }
    fn create_impl2(self) { ... }
    fn set_dispos(self, data: impl Into<DisposData>) { ... }
    fn set_dispos_weapon_mask(self, data: impl Into<DisposData>) { ... }
    fn set_dispos_skill(self, data: impl Into<DisposData>) { ... }
    fn set_dispos_god(self, data: impl Into<DisposData>) { ... }
    fn add_person_item(self, person: impl Into<PersonData>) -> bool { ... }
    fn add_dispos_item(self, data: impl Into<DisposData>) -> bool { ... }
    fn set_dispos_belong(self, data: impl Into<DisposData>) { ... }
    fn set_dispos_ai(self, data: impl Into<DisposData>) { ... }
    fn create_god_states(self, data: impl Into<DisposData>) -> Array<GodState> { ... }
    fn get_god_state_2(
        self,
        data: impl Into<DisposData>,
        index: impl Into<i32>,
        prev_state: impl Into<GodState>,
    ) -> GodState { ... }
    fn dispos_state2_god_state(
        self,
        dispos_state: impl Into<DisposData_State>,
    ) -> GodState { ... }
    fn setup_for_vision(self, original: impl Into<Unit>) { ... }
    fn create_for_summon_impl1(
        self,
        person: impl Into<PersonData>,
        original: impl Into<Unit>,
        rank: impl Into<PersonData_Ranks>,
    ) { ... }
    fn setup_for_summon(
        self,
        owner: impl Into<Unit>,
        rank: impl Into<PersonData_Ranks>,
    ) { ... }
    fn create_impl2_exclude_internal_level(self) { ... }
    fn setup_capability_for_vision(self, original: impl Into<Unit>) { ... }
    fn get_safe_person(self) -> PersonData { ... }
    fn get_safe_job(self) -> JobData { ... }
    fn calculate_auto_grow_capability(self, percents: impl Into<CapabilityInt>) { ... }
    fn get_max_hp_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_str_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_tech_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_quick_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_luck_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_def_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_magic_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_mdef_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_phys_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_sight_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_move_power_impl(self, calc_enhance: impl Into<bool>) -> i32 { ... }
    fn get_capability_impl(
        self,
        type: impl Into<CapabilityDefinition_Type>,
        calc_enhance: impl Into<bool>,
    ) -> i32 { ... }
    fn get_total_level(self) -> i32 { ... }
    fn get_order(self) -> i32 { ... }
    fn calc_item_range(
        self,
        item: impl Into<ItemData>,
        skill: impl Into<SkillData>,
    ) -> (bool, i32, i32) { ... }
    fn get_item_grow_capability(
        self,
        item: impl Into<ItemData>,
    ) -> CapabilitySbyte { ... }
    fn get_attack_image(self) -> MapDeployAttackImage { ... }
    fn get_rod_image(self) -> MapDeployRodImage { ... }
    fn get_heal_image(self) -> MapDeployHealImage { ... }
    fn get_support_image(self) -> MapDeploySupportImage { ... }
    fn get_interference_image(self) -> MapDeployInterferenceImage { ... }
    fn get_total_order(self) -> i32 { ... }
    fn set_total_order(self, value: impl Into<i32>) { ... }
    fn get_total_action(self) -> i32 { ... }
    fn set_total_action(self, value: impl Into<i32>) { ... }
    fn get_total_attack(self) -> i32 { ... }
    fn set_total_attack(self, value: impl Into<i32>) { ... }
    fn get_total_damage(self) -> i32 { ... }
    fn set_total_damage(self, value: impl Into<i32>) { ... }
    fn get_total_result(self) -> BattleScene_Result { ... }
    fn set_total_result(self, value: impl Into<BattleScene_Result>) { ... }
    fn get_side_type(self) -> BattleSide_Type { ... }
    fn set_side_type(self, value: impl Into<BattleSide_Type>) { ... }
    fn update_image(self, deploy: impl Into<MapDnagerDeploy>) { ... }
    fn clear_image(self) { ... }
    fn try_get_engage_mind(self) -> (bool, MapMind_Type) { ... }
    fn get_engage_attack(self) -> SkillData { ... }
    fn get_engage_skills(self) -> SkillArray { ... }
    fn get_engage_skill(self, index: impl Into<i32>) -> SkillData { ... }
    fn get_support_skill(self) -> SkillData { ... }
    fn add_cannon_skill(self, inspector: impl Into<CannonInspector>) { ... }
    fn remove_cannon_skill(self, inspector: impl Into<CannonInspector>) { ... }
    fn add_command_skill(self, skill: impl Into<SkillData>) { ... }
    fn remove_command_skill(self, skill: impl Into<SkillData>) { ... }
    fn add_give_skill(self, give: impl Into<SkillData>) { ... }
    fn add_give_skill_2(self, gives: impl Into<SkillArray>) { ... }
    fn get_battle_temporary(self) -> i32 { ... }
    fn set_battle_temporary(self, value: impl Into<i32>) { ... }
    fn is_exist_die(self) -> bool { ... }
    fn update_move_distance(self) { ... }
    fn update_move_distance_2(self, x: impl Into<i32>, z: impl Into<i32>) { ... }
    fn update_move_distance_3(
        self,
        route: impl Into<MapRoute>,
        x: impl Into<i32>,
        z: impl Into<i32>,
    ) { ... }
    fn clear_move_distance(self) { ... }
    fn can_grow_up(self, type: impl Into<CapabilityDefinition_Type>) -> bool { ... }
    fn get_simple_power(self) -> i32 { ... }
    fn get_simple_physical_power(self) -> i32 { ... }
    fn get_simple_magic_power(self) -> i32 { ... }
    fn get_simple_physical_defense(self) -> i32 { ... }
    fn get_simple_magic_defense(self) -> i32 { ... }
    fn get_simple_hit(self) -> i32 { ... }
    fn get_simple_avoid(self) -> i32 { ... }
    fn get_simple_critical(self) -> i32 { ... }
    fn get_simple_secure(self) -> i32 { ... }
    fn get_simple_continuous(self) -> i32 { ... }
    fn reset_param(self) { ... }
    fn get_fortune_seed(self) -> u32 { ... }
    fn set_fortune_seed(self, value: impl Into<u32>) { ... }
    fn get_fortune_target(self) -> PersonData { ... }
    fn set_fortune_target(self, value: impl Into<PersonData>) { ... }
    fn get_fortune_random_value(self, update: impl Into<bool>) -> i32 { ... }
    fn get_weapon_level(
        self,
        kind: impl Into<ItemData_Kinds>,
        calc_enhance: impl Into<bool>,
    ) -> WeaponLevel_Kind { ... }
    fn get_skill_equip(
        self,
        skill: impl Into<SkillData>,
        index: impl Into<i32>,
    ) -> UnitItem { ... }
    fn get_engage_equip(
        self,
        skill: impl Into<SkillData>,
        target: impl Into<Unit>,
    ) -> UnitItem { ... }
    fn get_effect_position(self) -> Vector3 { ... }
    fn can_stay_without_god(self) -> bool { ... }
}

Provided Methods

fn ctor(self, use_image: impl Into<bool>)

.ctor(bool) overload

fn initialize(self, index: impl Into<i32>)

Initialize(i32) overload

fn create( self, person: impl Into<PersonData>, job: impl Into<JobData>, level: impl Into<i32>, random: impl Into<Random_2>, )

Create(crate::app::persondata::PersonData, crate::app::jobdata::JobData, i32, crate::app::random_2::Random_2) overload

fn create_from_dispos(self, data: impl Into<DisposData>)

CreateFromDispos(crate::app::disposdata::DisposData) overload

fn create_challenge_enemy( self, dispos: impl Into<DisposData>, random: impl Into<Random_2>, level: impl Into<i32>, ejid: impl Into<Il2CppString>, )

CreateChallengeEnemy(crate::app::disposdata::DisposData, crate::app::random_2::Random_2, i32, ::unity::Il2CppString) overload

fn create_encount_enemy( self, dispos: impl Into<DisposData>, unit_rare_type: impl Into<EncountUnitData_RareType>, job: impl Into<JobData>, )

CreateEncountEnemy(crate::app::disposdata::DisposData, crate::app::encountunitdata::EncountUnitData_RareType, crate::app::jobdata::JobData) overload

fn set_encount_hp_stock( self, dispos: impl Into<DisposData>, difficulty: impl Into<Difficulty>, )

SetEncountHpStock(crate::app::disposdata::DisposData, crate::app::difficulty::Difficulty) overload

fn set_hp_stock_count(self, count: impl Into<i32>)

SetHpStockCount(i32) overload

fn create_encount_post( self, dispos: impl Into<DisposData>, level: impl Into<i32>, offset: impl Into<bool>, rare_type: impl Into<EncountUnitData_RareType>, )

CreateEncountPost(crate::app::disposdata::DisposData, i32, bool, crate::app::encountunitdata::EncountUnitData_RareType) overload

fn create_encount_mob( self, pid: impl Into<Il2CppString>, jid: impl Into<Il2CppString>, equip_weapon_iid: impl Into<Il2CppString>, )

CreateEncountMob(::unity::Il2CppString, ::unity::Il2CppString, ::unity::Il2CppString) overload

fn create_dlc_god_enemy( self, data: impl Into<DisposData>, is_clear_all: impl Into<bool>, )

CreateDlcGodEnemy(crate::app::disposdata::DisposData, bool) overload

fn create_dlc_god_enemy_impl1( self, dispos: impl Into<DisposData>, level: impl Into<i32>, random: impl Into<Random_2>, )

CreateDlcGodEnemyImpl1(crate::app::disposdata::DisposData, i32, crate::app::random_2::Random_2) overload

fn create_for_vision( self, original: impl Into<Unit>, person: impl Into<PersonData>, )

CreateForVision(crate::app::unit::Unit, crate::app::persondata::PersonData) overload

fn create_for_summon( self, original: impl Into<Unit>, rank: impl Into<PersonData_Ranks>, person: impl Into<PersonData>, )

CreateForSummon(crate::app::unit::Unit, crate::app::persondata::PersonData_Ranks, crate::app::persondata::PersonData) overload

fn create_for_summon_telop( self, original: impl Into<Unit>, rank: impl Into<PersonData_Ranks>, person: impl Into<PersonData>, )

CreateForSummonTelop(crate::app::unit::Unit, crate::app::persondata::PersonData_Ranks, crate::app::persondata::PersonData) overload

fn create_for_summon_common( self, original: impl Into<Unit>, rank: impl Into<PersonData_Ranks>, person: impl Into<PersonData>, )

CreateForSummonCommon(crate::app::unit::Unit, crate::app::persondata::PersonData_Ranks, crate::app::persondata::PersonData) overload

fn create_for_arena( self, emblem: impl Into<GodUnit>, level: impl Into<i32>, type: impl Into<RingCleaningSequence_GodType>, )

CreateForArena(crate::app::godunit::GodUnit, i32, crate::app::ringcleaningsequence::RingCleaningSequence_GodType) overload

fn create_for_versus(self, data: impl Into<DisposData>)

CreateForVersus(crate::app::disposdata::DisposData) overload

fn auto_grow_capability( self, level: impl Into<i32>, target_level: impl Into<i32>, )

AutoGrowCapability(i32, i32) overload

fn auto_grow_capability_2( self, level: impl Into<i32>, percents: impl Into<CapabilityInt>, )

AutoGrowCapability(i32, crate::app::capabilityint::CapabilityInt) overload

fn clear(self)

Clear() overload

fn clear_except_map_history_index(self)

ClearExceptMapHistoryIndex() overload

fn clear_impl(self, is_clear_map_history_index: impl Into<bool>)

ClearImpl(bool) overload

fn clear_for_rewind_preview(self) -> Il2CppString

ClearForRewindPreview(*mut::unity::Il2CppString) overload

fn copy_from(self, from: impl Into<Unit>)

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

fn copy_from_for_level_up(self, from: impl Into<Unit>)

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

fn copy_from_for_arena_result(self, from: impl Into<Unit>)

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

fn copy_from_for_versus(self, from: impl Into<Unit>)

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

fn reset_phase_begin(self, phase: impl Into<Force_Type>)

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

fn is_engage_owner(self) -> bool

IsEngageOwner() overload

fn reset_phase_begin_after(self, phase: impl Into<Force_Type>)

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

fn reset_phase_end(self, phase: impl Into<Force_Type>)

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

fn reset_sub_phase_charm_confusion_begin(self)

ResetSubPhaseCharmConfusionBegin() overload

fn reset_dead(self)

ResetDead() overload

fn reset_map_begin(self)

ResetMapBegin() overload

fn reset_map_end(self, is_reset_position: impl Into<bool>)

ResetMapEnd(bool) overload

fn map_completed(self)

MapCompleted() overload

fn fixed(self)

Fixed() overload

fn transfer(self, force: impl Into<Force_Type>, is_last: impl Into<bool>)

Transfer(crate::app::force::Force_Type, bool) overload

fn transfer_for_sortie( self, force: impl Into<Force_Type>, is_last: impl Into<bool>, )

TransferForSortie(crate::app::force::Force_Type, bool) overload

fn transfer_for_rewind( self, force: impl Into<Force_Type>, prev_unit: impl Into<Unit>, )

TransferForRewind(crate::app::force::Force_Type, crate::app::unit::Unit) overload

fn transfer_for_rewind_latest(self, force: impl Into<Force_Type>)

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

fn transfer_impl( self, force: impl Into<Force_Type>, is_last: impl Into<bool>, prev_unit: impl Into<Unit>, is_delete_actor: impl Into<bool>, )

TransferImpl(crate::app::force::Force_Type, bool, crate::app::unit::Unit, bool) overload

fn update_state(self)

UpdateState() overload

fn update_state_with_auto_equip(self)

UpdateStateWithAutoEquip() overload

fn update_state_with_equipped(self, equipped: impl Into<UnitItem>)

UpdateStateWithEquipped(crate::app::unititem::UnitItem) overload

fn try_update_state_with_equipped(self, equipped: impl Into<UnitItem>) -> bool

TryUpdateStateWithEquipped(crate::app::unititem::UnitItem) overload

fn add_skill(self, array: impl Into<SkillArray>)

AddSkill(crate::app::skillarray::SkillArray) overload

fn add_skill_2( self, array: impl Into<SkillArray>, category: impl Into<SkillData_Categorys>, )

AddSkill(crate::app::skillarray::SkillArray, crate::app::skilldata::SkillData_Categorys) overload

fn add_skill_3( self, skill: impl Into<SkillData>, category: impl Into<SkillData_Categorys>, age: impl Into<i32>, )

AddSkill(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Categorys, i32) overload

fn add_skill_without_update( self, skill: impl Into<SkillData>, category: impl Into<SkillData_Categorys>, age: impl Into<i32>, ) -> bool

AddSkillWithoutUpdate(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Categorys, i32) overload

fn is_engaging(self, god_unit: impl Into<GodUnit>) -> bool

IsEngaging(crate::app::godunit::GodUnit) overload

fn update_state_impl( self, is_auto_equip: impl Into<bool>, equipped: impl Into<UnitItem>, )

UpdateStateImpl(bool, crate::app::unititem::UnitItem) overload

fn commit_enhance(self, equipped: impl Into<UnitItem>)

CommitEnhance(crate::app::unititem::UnitItem) overload

fn update_place(self)

UpdatePlace() overload

fn create_actor(self)

CreateActor() overload

fn try_create_actor(self) -> bool

TryCreateActor() overload

fn reload_actor(self)

ReloadActor() overload

fn delete_actor(self)

DeleteActor() overload

fn update_actor(self)

UpdateActor() overload

fn tick_actor(self)

TickActor() overload

fn check_status(self, status: impl Into<Unit_Status>) -> bool

CheckStatus(crate::app::unit::Unit_Status) overload

fn not_status(self, status: impl Into<Unit_Status>) -> bool

NotStatus(crate::app::unit::Unit_Status) overload

fn set_status(self, status: impl Into<Unit_Status>)

SetStatus(crate::app::unit::Unit_Status) overload

fn clear_status(self, status: impl Into<Unit_Status>)

ClearStatus(crate::app::unit::Unit_Status) overload

fn change_status(self, status: impl Into<Unit_Status>)

ChangeStatus(crate::app::unit::Unit_Status) overload

fn get_status(self) -> Unit_StatusField

GetStatus() overload

fn set_dead(self)

SetDead() overload

fn get_name(self) -> Il2CppString

GetName() overload

fn get_talk_name(self) -> Il2CppString

GetTalkName() overload

fn get_name_impl(self, is_morph: impl Into<bool>) -> Il2CppString

GetNameImpl(bool) overload

fn get_ascii_name(self) -> Il2CppString

GetAsciiName() overload

fn get_job_name(self) -> Il2CppString

GetJobName() overload

fn set_position(self, pos: impl Into<Vector3>, update: impl Into<bool>)

SetPosition(crate::unity_engine::vector3::Vector3, bool) overload

fn set_position_2( self, x: impl Into<i32>, z: impl Into<i32>, update: impl Into<bool>, )

SetPosition(i32, i32, bool) overload

fn set_rotation(self, angle: impl Into<f32>)

SetRotation(f32) overload

fn set_force_for_stand_alone(self, force: impl Into<Force>)

SetForceForStandAlone(crate::app::force::Force) overload

fn is_hero(self) -> bool

IsHero() overload

fn is_dead(self) -> bool

IsDead() overload

fn get_gender(self) -> Gender

GetGender() overload

fn get_dress_gender(self) -> Gender

GetDressGender() overload

fn is_female(self) -> bool

IsFemale() overload

fn is_leader(self) -> bool

IsLeader() overload

fn is_morph(self) -> bool

IsMorph() overload

fn has_fang_curse(self) -> bool

HasFangCurse() overload

fn is_enchantment(self) -> bool

IsEnchantment() overload

fn is_move_not_allow(self) -> bool

IsMoveNotAllow() overload

fn is_unique(self) -> bool

IsUnique() overload

fn is_show(self) -> bool

IsShow() overload

fn can_sortie(self) -> bool

CanSortie() overload

fn is_play_area(self) -> bool

IsPlayArea() overload

fn is_play_area_2(self, x: impl Into<i32>, z: impl Into<i32>) -> bool

IsPlayArea(i32, i32) overload

fn is_allied(self, unit: impl Into<Unit>) -> bool

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

fn is_operate(self) -> bool

IsOperate() overload

fn is_efficacy(self, target: impl Into<Unit>) -> bool

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

fn get_attrs(self) -> SkillData_Attrs

GetAttrs() overload

fn can_transporter(self) -> bool

CanTransporter() overload

fn can_breakable(self, target: impl Into<Unit>) -> bool

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

fn can_sky_battle(self) -> bool

CanSkyBattle() overload

fn get_force_absent_type(self) -> Force_Type

GetForceAbsentType() overload

fn get_force_dead_type(self) -> Force_Type

GetForceDeadType() overload

fn is_same_force_type(self, force_type: impl Into<Force_Type>) -> bool

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

fn set_engage_impl(self, enable: impl Into<bool>, link: impl Into<bool>)

SetEngageImpl(bool, bool) overload

fn set_engage_link_simulation( self, enable: impl Into<bool>, link: impl Into<Unit>, )

SetEngageLinkSimulation(bool, crate::app::unit::Unit) overload

fn set_engage_simulation(self, enable: impl Into<bool>, link: impl Into<Unit>)

SetEngageSimulation(bool, crate::app::unit::Unit) overload

fn set_god_link_impl(self, god_link: impl Into<GodUnit>)

SetGodLinkImpl(crate::app::godunit::GodUnit) overload

fn play_engage(self, enable: impl Into<bool>)

PlayEngage(bool) overload

fn is_engaging_2(self) -> bool

IsEngaging() overload

fn is_hero_engaging(self) -> bool

IsHeroEngaging() overload

fn can_engage_heal(self) -> bool

CanEngageHeal() overload

fn set_engage_link( self, enable: impl Into<bool>, god_link: impl Into<GodUnit>, parent: impl Into<Unit>, child: impl Into<Unit>, )

SetEngageLink(bool, crate::app::godunit::GodUnit, crate::app::unit::Unit, crate::app::unit::Unit) overload

fn set_engage(self, enable: impl Into<bool>, link: impl Into<Unit>)

SetEngage(bool, crate::app::unit::Unit) overload

fn try_relocation(self) -> bool

TryRelocation() overload

fn is_active_route(self) -> bool

IsActiveRoute() overload

fn get_first_x(self) -> i32

get_FirstX() overload

fn get_first_z(self) -> i32

get_FirstZ() overload

fn force_set_engage_link_for_rewind(self, link_unit: impl Into<Unit>)

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

fn set_engage_attack(self, enable: impl Into<bool>)

SetEngageAttack(bool) overload

fn can_engage_impl(self, god_unit: impl Into<GodUnit>) -> bool

CanEngageImpl(crate::app::godunit::GodUnit) overload

fn can_engage_cancel(self, pickup: impl Into<bool>) -> bool

CanEngageCancel(bool) overload

fn can_engage_start(self) -> bool

CanEngageStart() overload

fn can_engage_link(self) -> bool

CanEngageLink() overload

fn get_linkable_god_unit(self) -> GodUnit

GetLinkableGodUnit() overload

fn get_engage_link_unit(self) -> Unit

GetEngageLinkUnit() overload

fn pre_start_target_select(self)

PreStartTargetSelect() overload

fn post_start_target_select(self)

PostStartTargetSelect() overload

fn try_add_achieve_engage(self)

TryAddAchieveEngage() overload

fn decide_target_select(self, is_redoer: impl Into<bool>)

DecideTargetSelect(bool) overload

fn cancel_target_select(self)

CancelTargetSelect() overload

fn can_change_engage(self, target_unit: impl Into<Unit>) -> bool

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

fn try_change_engage( self, target_unit: impl Into<Unit>, item_index: impl Into<i32>, ) -> bool

TryChangeEngage(crate::app::unit::Unit, i32) overload

fn change_engage(self, target_unit: impl Into<Unit>, item_index: impl Into<i32>)

ChangeEngage(crate::app::unit::Unit, i32) overload

fn can_engage_attack(self) -> bool

CanEngageAttack() overload

fn can_engage_target(self, target: impl Into<Unit>) -> bool

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

fn engage_target_exists( self, target: impl Into<Unit>, skill: impl Into<SkillData>, ) -> bool

EngageTargetExists(crate::app::unit::Unit, crate::app::skilldata::SkillData) overload

fn can_enemy_engage_attack(self) -> bool

CanEnemyEngageAttack() overload

fn can_execute_engage_attack(self) -> bool

CanExecuteEngageAttack() overload

fn can_act(self, is_fixed: impl Into<bool>, is_charged: impl Into<bool>) -> bool

CanAct(bool, bool) overload

fn can_act_without_engage_charge(self) -> bool

CanActWithoutEngageCharge() overload

fn can_be_target(self) -> bool

CanBeTarget() overload

fn can_external_move(self) -> bool

CanExternalMove() overload

fn is_sight(self, x: impl Into<i32>, z: impl Into<i32>) -> bool

IsSight(i32, i32) overload

fn can_warp( self, rod_unit: impl Into<Unit>, x: impl Into<i32>, z: impl Into<i32>, ) -> bool

CanWarp(crate::app::unit::Unit, i32, i32) overload

fn can_skill(self, skill: impl Into<SkillData>) -> bool

CanSkill(crate::app::skilldata::SkillData) overload

fn can_change_god(self) -> bool

CanChangeGod() overload

fn change_god(self) -> bool

ChangeGod() overload

fn get_cells(self, cells: impl Into<Array<MapPos>>) -> i32

GetCells(::unity::Array<crate::app::mappos::MapPos>) overload

fn get_cells_2( self, cells: impl Into<Array<MapPos>>, base_x: impl Into<i32>, base_z: impl Into<i32>, ) -> i32

GetCells(::unity::Array<crate::app::mappos::MapPos>, i32, i32) overload

fn set_base_capability(self, index: impl Into<i32>, value: impl Into<i32>)

SetBaseCapability(i32, i32) overload

fn add_base_capability(self, index: impl Into<i32>, value: impl Into<i32>)

AddBaseCapability(i32, i32) overload

fn set_capability_just(self, index: impl Into<i32>, value: impl Into<i32>)

SetCapabilityJust(i32, i32) overload

fn get_god_enhance_rating(self, god: impl Into<GodUnit>) -> i32

GetGodEnhanceRating(crate::app::godunit::GodUnit) overload

fn change_hp(self, hp: impl Into<i32>)

ChangeHp(i32) overload

fn play_set_hp(self, hp: impl Into<i32>)

PlaySetHp(i32) overload

fn play_set_heal(self, heal: impl Into<i32>)

PlaySetHeal(i32) overload

fn play_set_damage( self, damage: impl Into<i32>, can_die: impl Into<bool>, is_multi: impl Into<bool>, )

PlaySetDamage(i32, bool, bool) overload

fn is_changing_hp(self) -> bool

IsChangingHp() overload

fn get_max_hp(self) -> i32

GetMaxHp() overload

fn get_str(self) -> i32

GetStr() overload

fn get_tech(self) -> i32

GetTech() overload

fn get_quick(self) -> i32

GetQuick() overload

fn get_luck(self) -> i32

GetLuck() overload

fn get_def(self) -> i32

GetDef() overload

fn get_magic(self) -> i32

GetMagic() overload

fn get_mdef(self) -> i32

GetMdef() overload

fn get_phys(self) -> i32

GetPhys() overload

fn get_sight(self) -> i32

GetSight() overload

fn get_move_power(self) -> i32

GetMovePower() overload

fn get_move_power_without_removing(self) -> i32

GetMovePowerWithoutRemoving() overload

fn find_skill(self, flags: impl Into<SkillData_Flags>) -> SkillData

FindSkill(crate::app::skilldata::SkillData_Flags) overload

fn find_skill_2(self, states: impl Into<SkillData_States>) -> SkillData

FindSkill(crate::app::skilldata::SkillData_States) overload

fn get_removable_skill(self) -> SkillData

GetRemovableSkill() overload

fn get_removable_power(self) -> i32

GetRemovablePower() overload

fn get_capability( self, index: impl Into<i32>, calc_enhance: impl Into<bool>, ) -> i32

GetCapability(i32, bool) overload

fn get_capability_2( self, type: impl Into<CapabilityDefinition_Type>, calc_enhance: impl Into<bool>, ) -> i32

GetCapability(crate::app::capabilitydefinition::CapabilityDefinition_Type, bool) overload

fn get_capability_grow( self, index: impl Into<i32>, is_auto_grow: impl Into<bool>, ) -> i32

GetCapabilityGrow(i32, bool) overload

fn get_capability_grow_2( self, type: impl Into<CapabilityDefinition_Type>, is_auto_grow: impl Into<bool>, ) -> i32

GetCapabilityGrow(crate::app::capabilitydefinition::CapabilityDefinition_Type, bool) overload

fn get_capability_limit(self, type: impl Into<CapabilityDefinition_Type>) -> i32

GetCapabilityLimit(crate::app::capabilitydefinition::CapabilityDefinition_Type) overload

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

GetCapabilityLimit(i32) overload

fn can_capability_grow(self, type: impl Into<CapabilityDefinition_Type>) -> bool

CanCapabilityGrow(crate::app::capabilitydefinition::CapabilityDefinition_Type) overload

fn can_capability_grow_2(self, index: impl Into<i32>) -> bool

CanCapabilityGrow(i32) overload

fn get_strength_capability_index( self, rand: impl Into<Random_2>, ) -> CapabilityDefinition_Type

GetStrengthCapabilityIndex(crate::app::random_2::Random_2) overload

fn get_no_enhance_max_hp(self) -> i32

GetNoEnhanceMaxHp() overload

fn get_no_enhance_str(self) -> i32

GetNoEnhanceStr() overload

fn get_no_enhance_tech(self) -> i32

GetNoEnhanceTech() overload

fn get_no_enhance_quick(self) -> i32

GetNoEnhanceQuick() overload

fn get_no_enhance_luck(self) -> i32

GetNoEnhanceLuck() overload

fn get_no_enhance_def(self) -> i32

GetNoEnhanceDef() overload

fn get_no_enhance_magic(self) -> i32

GetNoEnhanceMagic() overload

fn get_no_enhance_mdef(self) -> i32

GetNoEnhanceMdef() overload

fn get_no_enhance_phys(self) -> i32

GetNoEnhancePhys() overload

fn get_no_enhance_sight(self) -> i32

GetNoEnhanceSight() overload

fn get_no_enhance_move_power(self) -> i32

GetNoEnhanceMovePower() overload

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

GetNoEnhanceCapability(i32) overload

fn get_no_enhance_capability_2( self, type: impl Into<CapabilityDefinition_Type>, ) -> i32

GetNoEnhanceCapability(crate::app::capabilitydefinition::CapabilityDefinition_Type) overload

fn get_enhanced_level(self) -> i32

GetEnhancedLevel() overload

fn add_hp(self, v: impl Into<i32>)

AddHp(i32) overload

fn is_dont_attack(self, unit: impl Into<Unit>) -> bool

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

fn set_dont_attack(self, person: impl Into<PersonData>)

SetDontAttack(crate::app::persondata::PersonData) overload

fn set_dont_attack_force_mask(self, force_mask: impl Into<u32>)

SetDontAttackForceMask(u32) overload

fn get_entrust_for_ai(self) -> UnitEntrust_Type

GetEntrustForAI() overload

fn can_talk(self) -> bool

CanTalk() overload

fn can_dance(self, target: impl Into<Unit>) -> bool

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

fn can_contract(self, target: impl Into<Unit>) -> bool

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

fn can_again(self) -> bool

CanAgain() overload

fn can_chain(self, parent: impl Into<Unit>) -> bool

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

fn can_chain_attack(self) -> bool

CanChainAttack() overload

fn is_terrain_invalid(self, terrain: impl Into<TerrainData_2>) -> bool

IsTerrainInvalid(crate::app::terraindata_2::TerrainData_2) overload

fn can_chain_guard(self) -> bool

CanChainGuard() overload

fn get_guard_type(self) -> Unit_GuardType

GetGuardType() overload

fn can_ccogitation(self) -> bool

CanCcogitation() overload

fn can_trade(self) -> bool

CanTrade() overload

fn can_gain_reliance(self) -> bool

CanGainReliance() overload

fn has_skill(self, skill: impl Into<SkillData>) -> bool

HasSkill(crate::app::skilldata::SkillData) overload

fn has_skill_2(self, sid: impl Into<Il2CppString>) -> bool

HasSkill(::unity::Il2CppString) overload

fn has_skill_3(self, flags: impl Into<SkillData_Flags>) -> bool

HasSkill(crate::app::skilldata::SkillData_Flags) overload

fn has_skill_4(self, states: impl Into<SkillData_States>) -> bool

HasSkill(crate::app::skilldata::SkillData_States) overload

fn has_dance_skill(self) -> bool

HasDanceSkill() overload

fn has_contract_skill(self) -> bool

HasContractSkill() overload

fn is_standing_die(self) -> bool

IsStandingDie() overload

fn is_immortal(self) -> bool

IsImmortal() overload

fn is_last_boss(self) -> bool

IsLastBoss() overload

fn get_equip_skill(self, index: impl Into<i32>) -> SkillData

GetEquipSkill(i32) overload

fn has_equip_skill(self, sid: impl Into<Il2CppString>) -> bool

HasEquipSkill(::unity::Il2CppString) overload

fn has_equip_skill_2(self, skill: impl Into<SkillData>) -> bool

HasEquipSkill(crate::app::skilldata::SkillData) overload

fn add_equip_skill(self, sid: impl Into<Il2CppString>) -> bool

AddEquipSkill(::unity::Il2CppString) overload

fn add_equip_skill_2(self, skill: impl Into<SkillData>) -> bool

AddEquipSkill(crate::app::skilldata::SkillData) overload

fn remove_equip_skill(self, sid: impl Into<Il2CppString>)

RemoveEquipSkill(::unity::Il2CppString) overload

fn remove_equip_skill_2(self, skill: impl Into<SkillData>)

RemoveEquipSkill(crate::app::skilldata::SkillData) overload

fn replace_equip_skill( self, index: impl Into<i32>, sid: impl Into<Il2CppString>, )

ReplaceEquipSkill(i32, ::unity::Il2CppString) overload

fn replace_equip_skill_2( self, index: impl Into<i32>, skill: impl Into<SkillData>, )

ReplaceEquipSkill(i32, crate::app::skilldata::SkillData) overload

fn move_equip_skill(self, old_index: impl Into<i32>, new_index: impl Into<i32>)

MoveEquipSkill(i32, i32) overload

fn has_private_skill(self, sid: impl Into<Il2CppString>) -> bool

HasPrivateSkill(::unity::Il2CppString) overload

fn has_private_skill_2(self, skill: impl Into<SkillData>) -> bool

HasPrivateSkill(crate::app::skilldata::SkillData) overload

fn add_private_skill(self, sid: impl Into<Il2CppString>) -> bool

AddPrivateSkill(::unity::Il2CppString) overload

fn add_private_skill_2(self, skill: impl Into<SkillData>) -> bool

AddPrivateSkill(crate::app::skilldata::SkillData) overload

fn add_private_skill_3(self, skills: impl Into<SkillArray>) -> bool

AddPrivateSkill(crate::app::skillarray::SkillArray) overload

fn remove_private_skill(self, sid: impl Into<Il2CppString>) -> bool

RemovePrivateSkill(::unity::Il2CppString) overload

fn remove_private_skill_2(self, skill: impl Into<SkillData>) -> bool

RemovePrivateSkill(crate::app::skilldata::SkillData) overload

fn remove_private_skill_3(self, skills: impl Into<SkillArray>) -> bool

RemovePrivateSkill(crate::app::skillarray::SkillArray) overload

fn get_record(self, kind: impl Into<UnitRecord_Kinds>) -> i32

GetRecord(crate::app::unitrecord::UnitRecord_Kinds) overload

fn set_record(self, kind: impl Into<UnitRecord_Kinds>, value: impl Into<i32>)

SetRecord(crate::app::unitrecord::UnitRecord_Kinds, i32) overload

fn add_record(self, kind: impl Into<UnitRecord_Kinds>, value: impl Into<i32>)

AddRecord(crate::app::unitrecord::UnitRecord_Kinds, i32) overload

fn inc_record(self, kind: impl Into<UnitRecord_Kinds>)

IncRecord(crate::app::unitrecord::UnitRecord_Kinds) overload

fn dec_record(self, kind: impl Into<UnitRecord_Kinds>)

DecRecord(crate::app::unitrecord::UnitRecord_Kinds) overload

fn add_record_with_history( self, kind: impl Into<UnitRecord_Kinds>, value: impl Into<i32>, )

AddRecordWithHistory(crate::app::unitrecord::UnitRecord_Kinds, i32) overload

fn get_from_equip_skill_pool(self, index: impl Into<i32>) -> SkillData

GetFromEquipSkillPool(i32) overload

fn add_to_equip_skill_pool(self, sid: impl Into<Il2CppString>)

AddToEquipSkillPool(::unity::Il2CppString) overload

fn add_to_equip_skill_pool_2(self, skill: impl Into<SkillData>)

AddToEquipSkillPool(crate::app::skilldata::SkillData) overload

fn remove_from_equip_skill_pool(self, sid: impl Into<Il2CppString>)

RemoveFromEquipSkillPool(::unity::Il2CppString) overload

fn remove_from_equip_skill_pool_2(self, skill: impl Into<SkillData>)

RemoveFromEquipSkillPool(crate::app::skilldata::SkillData) overload

fn is_exist_in_equip_skill_pool(self, sid: impl Into<Il2CppString>) -> bool

IsExistInEquipSkillPool(::unity::Il2CppString) overload

fn is_exist_in_equip_skill_pool_2(self, skill: impl Into<SkillData>) -> bool

IsExistInEquipSkillPool(crate::app::skilldata::SkillData) overload

fn is_inheritance_enable(self, skill: impl Into<SkillData>) -> bool

IsInheritanceEnable(crate::app::skilldata::SkillData) overload

fn is_poison(self) -> bool

IsPoison() overload

fn is_stun(self) -> bool

IsStun() overload

fn is_sleep(self) -> bool

IsSleep() overload

fn is_silence(self) -> bool

IsSilence() overload

fn is_charm(self) -> bool

IsCharm() overload

fn is_confusion(self) -> bool

IsConfusion() overload

fn is_charm_or_confusion(self) -> bool

IsCharmOrConfusion() overload

fn is_freeze(self) -> bool

IsFreeze() overload

fn is_weakness(self) -> bool

IsWeakness() overload

fn is_not_enhance(self) -> bool

IsNotEnhance() overload

fn is_disorder(self) -> bool

IsDisorder() overload

fn clear_disorder(self, state: impl Into<SkillData_States>) -> bool

ClearDisorder(crate::app::skilldata::SkillData_States) overload

fn is_vision(self) -> bool

IsVision() overload

fn is_vision_2(self, owner: impl Into<Unit>) -> bool

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

fn can_gain_item(self) -> bool

CanGainItem() overload

fn get_vision_owner(self) -> Unit

GetVisionOwner() overload

fn is_summon(self) -> bool

IsSummon() overload

fn is_summon_2(self, owner: impl Into<Unit>) -> bool

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

fn is_summon_god(self) -> bool

IsSummonGod() overload

fn get_summon_owner(self) -> Unit

GetSummonOwner() overload

fn is_lockon(self) -> bool

IsLockon() overload

fn try_get_lock_target(self) -> (bool, i32, i32)

TryGetLockTarget(*muti32, *muti32) overload

fn set_lock_target(self, x: impl Into<i32>, z: impl Into<i32>)

SetLockTarget(i32, i32) overload

fn reset_lock_target(self)

ResetLockTarget() overload

fn is_on_map(self) -> bool

IsOnMap() overload

fn is_decoy(self) -> bool

IsDecoy() overload

fn add_exp(self, exp: impl Into<i32>)

AddExp(i32) overload

fn add_skill_point(self, skill_point: impl Into<i32>)

AddSkillPoint(i32) overload

fn can_grow(self) -> bool

CanGrow() overload

fn normalize_exp(self, exp: impl Into<i32>) -> i32

NormalizeExp(i32) overload

fn exp_to_skill_point(self, exp: impl Into<i32>) -> i32

ExpToSkillPoint(i32) overload

fn nomralize_skill_point(self, skill_point: impl Into<i32>) -> i32

NomralizeSkillPoint(i32) overload

fn level_up(self, abort: impl Into<i32>)

LevelUp(i32) overload

fn dbg_level_down(self)

DbgLevelDown() overload

fn learn_job_skill(self) -> SkillData

LearnJobSkill() overload

fn learn_job_skill_for_chart(self, level: impl Into<i32>) -> SkillData

LearnJobSkillForChart(i32) overload

fn learn_job_skill_2( self, level: impl Into<i32>, job: impl Into<JobData>, ) -> SkillData

LearnJobSkill(i32, crate::app::jobdata::JobData) overload

fn learn_job_skill_3(self, job: impl Into<JobData>) -> SkillData

LearnJobSkill(crate::app::jobdata::JobData) overload

fn cc_check_aptitude(self, job: impl Into<JobData>) -> bool

CCCheckAptitude(crate::app::jobdata::JobData) overload

fn class_change(self, job: impl Into<JobData>, item: impl Into<ItemData>)

ClassChange(crate::app::jobdata::JobData, crate::app::itemdata::ItemData) overload

fn class_change_for_chart( self, job: impl Into<JobData>, item: impl Into<ItemData>, level: impl Into<i32>, )

ClassChangeForChart(crate::app::jobdata::JobData, crate::app::itemdata::ItemData, i32) overload

fn update_difficulty(self)

UpdateDifficulty() overload

fn reset_weapon_mask(self)

ResetWeaponMask() overload

fn set_selected_weapon(self, selected_weapon_mask: impl Into<WeaponMask>)

SetSelectedWeapon(crate::app::weaponmask::WeaponMask) overload

fn set_selected_weapon_from_original_aptitude( self, aptitude: impl Into<WeaponMask>, )

SetSelectedWeaponFromOriginalAptitude(crate::app::weaponmask::WeaponMask) overload

fn set_weapon_mask_from_parson(self)

SetWeaponMaskFromParson() overload

fn set_optimal_weapon_for_class_change( self, weapon_mask: impl Into<WeaponMask>, is_bullet: impl Into<bool>, ) -> UnitItem

SetOptimalWeaponForClassChange(crate::app::weaponmask::WeaponMask, bool) overload

fn set_selected_weapon_from_items( self, items: impl Into<Unit_ItemsForSelectedWeapon>, )

SetSelectedWeaponFromItems(crate::app::unit::Unit_ItemsForSelectedWeapon) overload

fn set_selected_weapon_for_chart( self, chart_items: impl Into<Array<ChartData_Item>>, )

SetSelectedWeaponForChart(::unity::Array<crate::app::chartdata::ChartData_Item>) overload

fn set_selected_weapon_from_dispos(self, data: impl Into<DisposData>)

SetSelectedWeaponFromDispos(crate::app::disposdata::DisposData) overload

fn inherit_aptitude(self, god_unit: impl Into<GodUnit>)

InheritAptitude(crate::app::godunit::GodUnit) overload

fn inherit_aptitude_2(self, god_bond: impl Into<GodBond>)

InheritAptitude(crate::app::godbond::GodBond) overload

fn add_aptitude_for_chart(self)

AddAptitudeForChart() overload

fn set_aptitude_from_dispos(self, data: impl Into<DisposData>)

SetAptitudeFromDispos(crate::app::disposdata::DisposData) overload

fn add_aptitude_from_weapon_mask(self)

AddAptitudeFromWeaponMask() overload

fn update_weapon_mask(self)

UpdateWeaponMask() overload

fn ai_activate(self, attacked: impl Into<bool>)

AIActivate(bool) overload

fn ai_activate_cause_attacked(self, longrange: impl Into<bool>)

AIActivate_CauseAttacked(bool) overload

fn ai_set_engage_attack(self)

AISetEngageAttack() overload

fn ai_clear_engage_attack(self)

AIClearEngageAttack() overload

fn has_item(self, is_exclude_engage: impl Into<bool>) -> bool

HasItem(bool) overload

fn has_rod(self) -> bool

HasRod() overload

fn has_heal_rod(self) -> bool

HasHealRod() overload

fn has_heal_rod_for_oneself( self, rod_type: impl Into<ItemData_RodTypes>, ) -> bool

HasHealRodForOneself(crate::app::itemdata::ItemData_RodTypes) overload

fn has_support_rod(self) -> bool

HasSupportRod() overload

fn has_support_rod_for_oneself( self, rod_type: impl Into<ItemData_RodTypes>, ) -> bool

HasSupportRodForOneself(crate::app::itemdata::ItemData_RodTypes) overload

fn has_interference_rod(self) -> bool

HasInterferenceRod() overload

fn has_criticale_weapon(self) -> bool

HasCriticaleWeapon() overload

fn has_efficacy_weapon(self, target: impl Into<Unit>) -> bool

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

fn has_drop_item(self) -> bool

HasDropItem() overload

fn has_max_item(self) -> bool

HasMaxItem() overload

fn get_item(self, index: impl Into<i32>) -> UnitItem

GetItem(i32) overload

fn get_item_index(self, iid: impl Into<Il2CppString>) -> i32

GetItemIndex(::unity::Il2CppString) overload

fn get_item_index_2(self, item: impl Into<ItemData>) -> i32

GetItemIndex(crate::app::itemdata::ItemData) overload

fn for_each_unit_item(self, func: impl Into<Unit_FuncUnitItem>)

ForEachUnitItem(crate::app::unit::Unit_FuncUnitItem) overload

fn for_each_can_equip_item(self, func: impl Into<Unit_FuncUnitItem>)

ForEachCanEquipItem(crate::app::unit::Unit_FuncUnitItem) overload

fn get_actual_item(self, unit_item: impl Into<UnitItem>) -> UnitItem

GetActualItem(crate::app::unititem::UnitItem) overload

fn is_item_equipped(self) -> bool

IsItemEquipped() overload

fn get_item_equipped(self) -> UnitItem

GetItemEquipped() overload

fn get_item_index_equipped(self) -> i32

GetItemIndexEquipped() overload

fn get_item_hold(self) -> UnitItem

GetItemHold() overload

fn get_item_index_hold(self) -> i32

GetItemIndexHold() overload

fn item_add(self, iid: impl Into<Il2CppString>) -> i32

ItemAdd(::unity::Il2CppString) overload

fn item_add_2(self, iids: impl Into<Array<Il2CppString>>) -> bool

ItemAdd(::unity::Array<::unity::Il2CppString>) overload

fn item_add_3(self, item: impl Into<ItemData>) -> i32

ItemAdd(crate::app::itemdata::ItemData) overload

fn item_add_4(self, unit_item: impl Into<UnitItem>) -> i32

ItemAdd(crate::app::unititem::UnitItem) overload

fn item_add_on_dlc_evil( self, iids: impl Into<Array<Il2CppString>>, chapter: impl Into<ChapterData>, level: impl Into<i32>, )

ItemAddOnDlcEvil(::unity::Array<::unity::Il2CppString>, crate::app::chapterdata::ChapterData, i32) overload

fn equipable_item_add(self, iids: impl Into<Array<Il2CppString>>) -> bool

EquipableItemAdd(::unity::Array<::unity::Il2CppString>) overload

fn item_move(self, from: impl Into<i32>, to: impl Into<i32>)

ItemMove(i32, i32) overload

fn item_close_up(self)

ItemCloseUp() overload

fn item_equip(self) -> bool

ItemEquip() overload

fn item_equip_2(self, index: impl Into<i32>, reoder: impl Into<bool>) -> bool

ItemEquip(i32, bool) overload

fn item_reorder(self)

ItemReorder() overload

fn item_equip_3(self, unit_item: impl Into<UnitItem>) -> bool

ItemEquip(crate::app::unititem::UnitItem) overload

fn item_equip_4(self, item_data: impl Into<ItemData>) -> bool

ItemEquip(crate::app::itemdata::ItemData) overload

fn item_take_off(self, index: impl Into<i32>)

ItemTakeOff(i32) overload

fn item_take_off_2(self, unit_item: impl Into<UnitItem>)

ItemTakeOff(crate::app::unititem::UnitItem) overload

fn item_put_off(self, index: impl Into<i32>, closeup: impl Into<bool>)

ItemPutOff(i32, bool) overload

fn item_put_off_2( self, unit_item: impl Into<UnitItem>, closeup: impl Into<bool>, )

ItemPutOff(crate::app::unititem::UnitItem, bool) overload

fn item_put_off_all(self)

ItemPutOffAll() overload

fn has_item_2(self, item: impl Into<ItemData>) -> bool

HasItem(crate::app::itemdata::ItemData) overload

fn get_item_count(self) -> i32

GetItemCount() overload

fn get_item_selected(self) -> UnitItem

GetItemSelected() overload

fn set_item_selected(self, unit_item: impl Into<UnitItem>)

SetItemSelected(crate::app::unititem::UnitItem) overload

fn has_equipable_item(self) -> bool

HasEquipableItem() overload

fn has_equipable_item_2(self, range: impl Into<i32>) -> bool

HasEquipableItem(i32) overload

fn has_equipable_item_3(self, kind: impl Into<ItemData_Kinds>) -> bool

HasEquipableItem(crate::app::itemdata::ItemData_Kinds) overload

fn can_item_equip( self, unit_item: impl Into<UnitItem>, rod: impl Into<bool>, exp: impl Into<bool>, ) -> bool

CanItemEquip(crate::app::unititem::UnitItem, bool, bool) overload

fn can_item_equip_2( self, item: impl Into<ItemData>, rod: impl Into<bool>, weapon_level: impl Into<bool>, ) -> bool

CanItemEquip(crate::app::itemdata::ItemData, bool, bool) overload

fn can_item_equip_3( self, index: impl Into<i32>, rod: impl Into<bool>, exp: impl Into<bool>, ) -> bool

CanItemEquip(i32, bool, bool) overload

fn can_item_kind_equip( self, kind: impl Into<ItemData_Kinds>, rod: impl Into<bool>, weapon_mask: impl Into<bool>, ) -> bool

CanItemKindEquip(crate::app::itemdata::ItemData_Kinds, bool, bool) overload

fn can_use_cannon(self, x: impl Into<i32>, z: impl Into<i32>) -> bool

CanUseCannon(i32, i32) overload

fn can_use_cannon_2(self, terrain: impl Into<TerrainData_2>) -> bool

CanUseCannon(crate::app::terraindata_2::TerrainData_2) overload

fn next_item_equip(self, reverse: impl Into<bool>) -> bool

NextItemEquip(bool) overload

fn is_item_sealed(self, unit_item: impl Into<UnitItem>) -> bool

IsItemSealed(crate::app::unititem::UnitItem) overload

fn is_item_sealed_2(self, item: impl Into<ItemData>) -> bool

IsItemSealed(crate::app::itemdata::ItemData) overload

fn is_item_sealed_3(self, index: impl Into<i32>) -> bool

IsItemSealed(i32) overload

fn get_item_index_key_door(self) -> i32

GetItemIndexKeyDoor() overload

fn can_unlock_door(self, enable_item: impl Into<bool>) -> bool

CanUnlockDoor(bool) overload

fn can_unlock_treasure_box(self, enable_item: impl Into<bool>) -> bool

CanUnlockTreasureBox(bool) overload

fn get_range_i(self, index: impl Into<i32>, skill: impl Into<SkillData>) -> i32

GetRangeI(i32, crate::app::skilldata::SkillData) overload

fn get_range_i_2( self, item: impl Into<ItemData>, skill: impl Into<SkillData>, ) -> i32

GetRangeI(crate::app::itemdata::ItemData, crate::app::skilldata::SkillData) overload

fn get_range_i_3( self, unit_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> i32

GetRangeI(crate::app::unititem::UnitItem, crate::app::skilldata::SkillData) overload

fn get_range_o(self, index: impl Into<i32>, skill: impl Into<SkillData>) -> i32

GetRangeO(i32, crate::app::skilldata::SkillData) overload

fn get_range_o_2( self, item: impl Into<ItemData>, skill: impl Into<SkillData>, ) -> i32

GetRangeO(crate::app::itemdata::ItemData, crate::app::skilldata::SkillData) overload

fn get_range_o_3( self, unit_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> i32

GetRangeO(crate::app::unititem::UnitItem, crate::app::skilldata::SkillData) overload

fn get_range_io( self, index: impl Into<i32>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetRangeIO(i32, *muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_range_io_2( self, item: impl Into<ItemData>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetRangeIO(crate::app::itemdata::ItemData, *muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_range_io_3( self, unit_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetRangeIO(crate::app::unititem::UnitItem, *muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_item_distance(self, item: impl Into<ItemData>) -> i32

GetItemDistance(crate::app::itemdata::ItemData) overload

fn get_rod_range_extend(self, item: impl Into<ItemData>) -> i32

GetRodRangeExtend(crate::app::itemdata::ItemData) overload

fn get_item_range( self, item: impl Into<ItemData>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetItemRange(*muti32, *muti32, crate::app::itemdata::ItemData, crate::app::skilldata::SkillData) overload

fn get_skill_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32)

GetSkillRange(*muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_item_range_2( self, equip_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetItemRange(*muti32, *muti32, crate::app::unititem::UnitItem, crate::app::skilldata::SkillData) overload

fn get_item_range_3( self, item_mask: impl Into<u32>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetItemRange(*muti32, *muti32, u32, crate::app::skilldata::SkillData) overload

fn get_engage_range(self) -> (bool, i32, i32)

GetEngageRange(*muti32, *muti32) overload

fn get_attack_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32)

GetAttackRange(*muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_rod_range(self, skill: impl Into<SkillData>) -> (bool, i32, i32)

GetRodRange(*muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_attack_range_2( self, equip_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetAttackRange(*muti32, *muti32, crate::app::unititem::UnitItem, crate::app::skilldata::SkillData) overload

fn get_rod_range_2( self, equip_item: impl Into<UnitItem>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

GetRodRange(*muti32, *muti32, crate::app::unititem::UnitItem, crate::app::skilldata::SkillData) overload

fn get_revenge_weapon( self, target: impl Into<Unit>, target_item: impl Into<UnitItem>, range: impl Into<i32>, ) -> UnitItem

GetRevengeWeapon(crate::app::unit::Unit, crate::app::unititem::UnitItem, i32) overload

fn get_rod_heal_power(self, unit_item: impl Into<UnitItem>) -> i32

GetRodHealPower(crate::app::unititem::UnitItem) overload

fn can_item_use(self, item: impl Into<ItemData>) -> bool

CanItemUse(crate::app::itemdata::ItemData) overload

fn can_item_use_2( self, item: impl Into<ItemData>, target_unit: impl Into<Unit>, ) -> bool

CanItemUse(crate::app::itemdata::ItemData, crate::app::unit::Unit) overload

fn item_use_impl( self, item: impl Into<ItemData>, use_type: impl Into<ItemData_UseTypes>, power: impl Into<i32>, give_skills: impl Into<SkillArray>, )

ItemUseImpl(crate::app::itemdata::ItemData, crate::app::itemdata::ItemData_UseTypes, i32, crate::app::skillarray::SkillArray) overload

fn item_use(self, item: impl Into<ItemData>)

ItemUse(crate::app::itemdata::ItemData) overload

fn item_enchant(self, unit: impl Into<Unit>, item: impl Into<ItemData>)

ItemEnchant(crate::app::unit::Unit, crate::app::itemdata::ItemData) overload

fn is_item_enhance_having(self, item_data: impl Into<ItemData>) -> bool

IsItemEnhanceHaving(crate::app::itemdata::ItemData) overload

fn is_draw_active_color(self, unit_item: impl Into<UnitItem>) -> bool

IsDrawActiveColor(crate::app::unititem::UnitItem) overload

fn get_accessory_list(self) -> UnitAccessoryList

get_AccessoryList() overload

fn set_ring(self, ring: impl Into<UnitRing>)

SetRing(crate::app::unitring::UnitRing) overload

fn set_ring_impl(self, ring: impl Into<UnitRing>)

SetRingImpl(crate::app::unitring::UnitRing) overload

fn clear_ring(self)

ClearRing() overload

fn clear_ring_impl(self)

ClearRingImpl() overload

fn get_ring(self) -> UnitRing

get_Ring() overload

fn get_power(self) -> i32

GetPower() overload

fn set_god_unit(self, god_unit: impl Into<GodUnit>)

SetGodUnit(crate::app::godunit::GodUnit) overload

fn set_god_unit_to_copy(self, god_unit: impl Into<GodUnit>)

SetGodUnitToCopy(crate::app::godunit::GodUnit) overload

fn clear_god_unit(self)

ClearGodUnit() overload

fn clear_god_unit_from_copy(self)

ClearGodUnitFromCopy() overload

fn can_god_equip(self, god_unit: impl Into<GodUnit>) -> bool

CanGodEquip(crate::app::godunit::GodUnit) overload

fn reset_engage_count(self)

ResetEngageCount() overload

fn play_engage_cancel(self)

PlayEngageCancel() overload

fn reset_engaing(self)

ResetEngaing() overload

fn try_connect_god_unit(self, god_unit: impl Into<GodUnit>) -> GodUnit

TryConnectGodUnit(crate::app::godunit::GodUnit) overload

fn try_connect_god_unit_to_copy(self, god_unit: impl Into<GodUnit>) -> GodUnit

TryConnectGodUnitToCopy(crate::app::godunit::GodUnit) overload

fn try_disconnect_god_unit(self) -> GodUnit

TryDisconnectGodUnit() overload

fn try_disconnect_ring(self) -> UnitRing

TryDisconnectRing() overload

fn try_disconnect_god_unit_from_copy(self) -> GodUnit

TryDisconnectGodUnitFromCopy() overload

fn try_disconnect_god_link_from_copy(self) -> GodUnit

TryDisconnectGodLinkFromCopy() overload

fn sight_up(self, unit: impl Into<Unit>, item: impl Into<ItemData>) -> bool

SightUp(crate::app::unit::Unit, crate::app::itemdata::ItemData) overload

fn can_revive(self) -> bool

CanRevive() overload

fn is_asphyxiation(self) -> bool

IsAsphyxiation() overload

fn revive(self)

Revive() overload

fn revive_for_rewind_v0(self, hp_stock_count: impl Into<u8>)

ReviveForRewindV0(u8) overload

fn revive_for_rewind_v1( self, plain_hp_stock_count: impl Into<u8>, extra_hp_stock_count: impl Into<u8>, extra_hp_stock_count_max: impl Into<u8>, )

ReviveForRewindV1(u8, u8, u8) overload

fn set_god_state(self, index: impl Into<i32>, state: impl Into<GodState>)

SetGodState(i32, crate::app::godstate::GodState) overload

fn get_god_state(self, index: impl Into<i32>) -> GodState

GetGodState(i32) overload

fn get_god_state_count(self) -> i32

GetGodStateCount() overload

fn is_default_god_states(self) -> bool

IsDefaultGodStates() overload

fn get_current_god_state_index(self) -> i32

GetCurrentGodStateIndex() overload

fn get_current_god_state(self) -> GodState

GetCurrentGodState() overload

fn can_set_extra_hp_stock(self) -> bool

CanSetExtraHpStock() overload

fn has_extra_hp_stock(self) -> bool

HasExtraHpStock() overload

fn set_extra_hp_stock(self)

SetExtraHpStock() overload

fn clear_extra_hp_stock(self)

ClearExtraHpStock() overload

fn extra_hp_stock_for_rewind( self, is_set: impl Into<bool>, extra_hp_stock_count: impl Into<u8>, extra_hp_stock_count_max: impl Into<u8>, )

ExtraHpStockForRewind(bool, u8, u8) overload

fn dbg_set_hp_stock_count(self, count: impl Into<i32>)

DbgSetHpStockCount(i32) overload

fn update_god_unit_for_god_state( self, new_god_state: impl Into<GodState>, old_god_state: impl Into<GodState>, )

UpdateGodUnitForGodState(crate::app::godstate::GodState, crate::app::godstate::GodState) overload

fn serialize(self, stream: impl Into<Stream_2>)

Serialize(crate::app::stream_2::Stream_2) overload

fn deserialize(self, stream: impl Into<Stream_2>)

Deserialize(crate::app::stream_2::Stream_2) overload

fn get_prev(self) -> Unit

get_Prev() overload

fn set_prev(self, value: impl Into<Unit>)

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

fn get_next(self) -> Unit

get_Next() overload

fn set_next(self, value: impl Into<Unit>)

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

fn get_ai(self) -> UnitAI

get_Ai() overload

fn get_edit(self) -> UnitEdit

get_Edit() overload

fn get_person(self) -> PersonData

get_Person() overload

fn set_person(self, value: impl Into<PersonData>)

set_Person(crate::app::persondata::PersonData) overload

fn get_pid(self) -> Il2CppString

get_Pid() overload

fn get_prefixless_pid(self) -> Il2CppString

get_PrefixlessPid() overload

fn get_job(self) -> JobData

get_Job() overload

fn set_job(self, value: impl Into<JobData>)

set_Job(crate::app::jobdata::JobData) overload

fn get_jid(self) -> Il2CppString

get_Jid() overload

fn get_prefixless_jid(self) -> Il2CppString

get_PrefixlessJid() overload

fn get_force(self) -> Force

get_Force() overload

fn set_force(self, value: impl Into<Force>)

set_Force(crate::app::force::Force) overload

fn get_force_type(self) -> Force_Type

get_ForceType() overload

fn get_force_mask(self) -> u32

get_ForceMask() overload

fn get_base_capability(self) -> UnitBaseCapability

get_BaseCapability() overload

fn get_grow_capability(self) -> Capability

get_GrowCapability() overload

fn get_level_capability(self) -> UnitBaseCapability

get_LevelCapability() overload

fn get_grow_seed(self) -> u32

get_GrowSeed() overload

fn set_grow_seed(self, value: impl Into<u32>)

set_GrowSeed(u32) overload

fn get_drop_seed(self) -> u32

get_DropSeed() overload

fn set_drop_seed(self, value: impl Into<u32>)

set_DropSeed(u32) overload

fn get_actor(self) -> UnitActor

get_Actor() overload

fn set_actor(self, value: impl Into<UnitActor>)

set_Actor(crate::app::unitactor::UnitActor) overload

fn get_info(self) -> MapInfoRoot

get_Info() overload

fn set_info(self, value: impl Into<MapInfoRoot>)

set_Info(crate::app::mapinforoot::MapInfoRoot) overload

fn get_unit_model(self) -> UnitModel

get_UnitModel() overload

fn get_god_model(self) -> UnitModel

get_GodModel() overload

fn get_position(self) -> Vector3

get_Position() overload

fn get_cell_center_position(self) -> Vector3

get_CellCenterPosition() overload

fn get_direction(self) -> Vector3

get_Direction() overload

fn get_index(self) -> i32

get_Index() overload

fn set_index(self, value: impl Into<i32>)

set_Index(i32) overload

fn get_bmap_size(self) -> i32

get_BmapSize() overload

fn get_style(self) -> BattleStyle_Types

get_Style() overload

fn get_x(self) -> i32

get_X() overload

fn set_x(self, value: impl Into<i32>)

set_X(i32) overload

fn get_z(self) -> i32

get_Z() overload

fn set_z(self, value: impl Into<i32>)

set_Z(i32) overload

fn get_dispos_x(self) -> i32

get_DisposX() overload

fn set_dispos_x(self, value: impl Into<i32>)

set_DisposX(i32) overload

fn get_dispos_z(self) -> i32

get_DisposZ() overload

fn set_dispos_z(self, value: impl Into<i32>)

set_DisposZ(i32) overload

fn get_center_x(self) -> i32

get_CenterX() overload

fn get_center_z(self) -> i32

get_CenterZ() overload

fn get_angle(self) -> f32

get_Angle() overload

fn set_angle(self, value: impl Into<f32>)

set_Angle(f32) overload

fn get_dispos_sound(self) -> i32

get_DisposSound() overload

fn get_move_type(self) -> JobData_MoveTypes

get_MoveType() overload

fn get_level(self) -> i32

get_Level() overload

fn set_level(self, value: impl Into<i32>)

set_Level(i32) overload

fn get_limit_level(self) -> i32

get_LimitLevel() overload

fn get_exp(self) -> i32

get_Exp() overload

fn set_exp(self, value: impl Into<i32>)

set_Exp(i32) overload

fn get_skill_point(self) -> i32

get_SkillPoint() overload

fn set_skill_point(self, value: impl Into<i32>)

set_SkillPoint(i32) overload

fn get_hp(self) -> i32

get_Hp() overload

fn set_hp(self, value: impl Into<i32>)

set_Hp(i32) overload

fn get_display_hp(self) -> i32

get_DisplayHp() overload

fn get_hp_stock_count(self) -> i32

get_HpStockCount() overload

fn get_hp_stock_count_max(self) -> i32

get_HpStockCountMax() overload

fn get_plain_hp_stock_count(self) -> i32

get_PlainHpStockCount() overload

fn set_plain_hp_stock_count(self, value: impl Into<i32>)

set_PlainHpStockCount(i32) overload

fn get_plain_hp_stock_count_max(self) -> i32

get_PlainHpStockCountMax() overload

fn get_extra_hp_stock_count(self) -> i32

get_ExtraHpStockCount() overload

fn get_extra_hp_stock_count_max(self) -> i32

get_ExtraHpStockCountMax() overload

fn get_base_move_power(self) -> i32

get_BaseMovePower() overload

fn get_item_list(self) -> UnitItemList

get_ItemList() overload

fn get_god_unit(self) -> GodUnit

get_GodUnit() overload

fn get_actual_god_unit(self) -> GodUnit

get_ActualGodUnit() overload

fn get_extra_sight(self) -> i32

get_ExtraSight() overload

fn set_extra_sight(self, value: impl Into<i32>)

set_ExtraSight(i32) overload

fn get_move_distance(self) -> i32

get_MoveDistance() overload

fn get_mask_skill_lock(self) -> Object

get_MaskSkillLock() overload

fn get_mask_skill(self) -> SkillArray

get_MaskSkill() overload

fn get_equip_skill_2(self) -> SkillArray

get_EquipSkill() overload

fn get_private_skill(self) -> SkillArray

get_PrivateSkill() overload

fn get_supported_skill(self) -> SkillArray

get_SupportedSkill() overload

fn get_receive_skill(self) -> SkillArray

get_ReceiveSkill() overload

fn get_equip_skill_pool(self) -> SkillArray

get_EquipSkillPool() overload

fn get_learned_job_skill(self) -> SkillData

get_LearnedJobSkill() overload

fn set_learned_job_skill(self, value: impl Into<SkillData>)

set_LearnedJobSkill(crate::app::skilldata::SkillData) overload

fn get_original_aptitude(self) -> WeaponMask

get_OriginalAptitude() overload

fn get_aptitude(self) -> WeaponMask

get_Aptitude() overload

fn get_weapon_mask(self) -> WeaponMask

get_WeaponMask() overload

fn get_selected_weapon_mask(self) -> WeaponMask

get_SelectedWeaponMask() overload

fn get_enhance_factors(self) -> UnitEnhanceFactors

get_EnhanceFactors() overload

fn get_internal_level(self) -> i32

get_InternalLevel() overload

fn set_internal_level(self, value: impl Into<i32>)

set_InternalLevel(i32) overload

fn get_last_pick_voice(self) -> i8

get_LastPickVoice() overload

fn set_last_pick_voice(self, value: impl Into<i8>)

set_LastPickVoice(i8) overload

fn get_max_stun(self) -> i32

GetMaxStun() overload

fn get_stun(self) -> i32

GetStun() overload

fn get_engage_count(self) -> i32

get_EngageCount() overload

fn set_engage_count(self, value: impl Into<i32>)

set_EngageCount(i32) overload

fn play_set_engage_count( self, engage_count: impl Into<i32>, target_unit: impl Into<Unit>, )

PlaySetEngageCount(i32, crate::app::unit::Unit) overload

fn play_set_engage_count_2( self, start: impl Into<Vector3>, goal: impl Into<Vector3>, count: impl Into<i32>, )

PlaySetEngageCount(crate::unity_engine::vector3::Vector3, crate::unity_engine::vector3::Vector3, i32) overload

fn get_engage_count_view(self) -> i32

GetEngageCountView() overload

fn set_engage_count_view(self, count: impl Into<i32>)

SetEngageCountView(i32) overload

fn get_engage_count_limit(self) -> i32

GetEngageCountLimit() overload

fn get_engage_turn(self) -> i32

get_EngageTurn() overload

fn set_engage_turn(self, value: impl Into<i32>)

set_EngageTurn(i32) overload

fn get_remaining_engage_turn(self) -> i32

GetRemainingEngageTurn() overload

fn get_engage_turn_limit(self) -> i32

GetEngageTurnLimit() overload

fn get_alpha(self) -> f32

GetAlpha() overload

fn get_ident(self) -> i32

get_Ident() overload

fn set_ident(self, value: impl Into<i32>)

set_Ident(i32) overload

fn get_record_2(self) -> UnitRecord

get_Record() overload

fn get_map_history_index(self) -> i32

get_MapHistoryIndex() overload

fn set_map_history_index(self, value: impl Into<i32>)

set_MapHistoryIndex(i32) overload

fn get_relay_player_index(self) -> i32

get_RelayPlayerIndex() overload

fn set_relay_player_index(self, value: impl Into<i32>)

set_RelayPlayerIndex(i32) overload

fn create_impl1( self, person: impl Into<PersonData>, job: impl Into<JobData>, level: impl Into<i32>, random: impl Into<Random_2>, )

CreateImpl1(crate::app::persondata::PersonData, crate::app::jobdata::JobData, i32, crate::app::random_2::Random_2) overload

fn try_copy_edit(self)

TryCopyEdit() overload

fn create_impl2(self)

CreateImpl2() overload

fn set_dispos(self, data: impl Into<DisposData>)

SetDispos(crate::app::disposdata::DisposData) overload

fn set_dispos_weapon_mask(self, data: impl Into<DisposData>)

SetDisposWeaponMask(crate::app::disposdata::DisposData) overload

fn set_dispos_skill(self, data: impl Into<DisposData>)

SetDisposSkill(crate::app::disposdata::DisposData) overload

fn set_dispos_god(self, data: impl Into<DisposData>)

SetDisposGod(crate::app::disposdata::DisposData) overload

fn add_person_item(self, person: impl Into<PersonData>) -> bool

AddPersonItem(crate::app::persondata::PersonData) overload

fn add_dispos_item(self, data: impl Into<DisposData>) -> bool

AddDisposItem(crate::app::disposdata::DisposData) overload

fn set_dispos_belong(self, data: impl Into<DisposData>)

SetDisposBelong(crate::app::disposdata::DisposData) overload

fn set_dispos_ai(self, data: impl Into<DisposData>)

SetDisposAi(crate::app::disposdata::DisposData) overload

fn create_god_states(self, data: impl Into<DisposData>) -> Array<GodState>

CreateGodStates(crate::app::disposdata::DisposData) overload

fn get_god_state_2( self, data: impl Into<DisposData>, index: impl Into<i32>, prev_state: impl Into<GodState>, ) -> GodState

GetGodState(crate::app::disposdata::DisposData, i32, crate::app::godstate::GodState) overload

fn dispos_state2_god_state( self, dispos_state: impl Into<DisposData_State>, ) -> GodState

DisposState2GodState(crate::app::disposdata::DisposData_State) overload

fn setup_for_vision(self, original: impl Into<Unit>)

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

fn create_for_summon_impl1( self, person: impl Into<PersonData>, original: impl Into<Unit>, rank: impl Into<PersonData_Ranks>, )

CreateForSummonImpl1(crate::app::persondata::PersonData, crate::app::unit::Unit, crate::app::persondata::PersonData_Ranks) overload

fn setup_for_summon( self, owner: impl Into<Unit>, rank: impl Into<PersonData_Ranks>, )

SetupForSummon(crate::app::unit::Unit, crate::app::persondata::PersonData_Ranks) overload

fn create_impl2_exclude_internal_level(self)

CreateImpl2ExcludeInternalLevel() overload

fn setup_capability_for_vision(self, original: impl Into<Unit>)

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

fn get_safe_person(self) -> PersonData

GetSafePerson() overload

fn get_safe_job(self) -> JobData

GetSafeJob() overload

fn calculate_auto_grow_capability(self, percents: impl Into<CapabilityInt>)

CalculateAutoGrowCapability(crate::app::capabilityint::CapabilityInt) overload

fn get_max_hp_impl(self, calc_enhance: impl Into<bool>) -> i32

GetMaxHpImpl(bool) overload

fn get_str_impl(self, calc_enhance: impl Into<bool>) -> i32

GetStrImpl(bool) overload

fn get_tech_impl(self, calc_enhance: impl Into<bool>) -> i32

GetTechImpl(bool) overload

fn get_quick_impl(self, calc_enhance: impl Into<bool>) -> i32

GetQuickImpl(bool) overload

fn get_luck_impl(self, calc_enhance: impl Into<bool>) -> i32

GetLuckImpl(bool) overload

fn get_def_impl(self, calc_enhance: impl Into<bool>) -> i32

GetDefImpl(bool) overload

fn get_magic_impl(self, calc_enhance: impl Into<bool>) -> i32

GetMagicImpl(bool) overload

fn get_mdef_impl(self, calc_enhance: impl Into<bool>) -> i32

GetMdefImpl(bool) overload

fn get_phys_impl(self, calc_enhance: impl Into<bool>) -> i32

GetPhysImpl(bool) overload

fn get_sight_impl(self, calc_enhance: impl Into<bool>) -> i32

GetSightImpl(bool) overload

fn get_move_power_impl(self, calc_enhance: impl Into<bool>) -> i32

GetMovePowerImpl(bool) overload

fn get_capability_impl( self, type: impl Into<CapabilityDefinition_Type>, calc_enhance: impl Into<bool>, ) -> i32

GetCapabilityImpl(crate::app::capabilitydefinition::CapabilityDefinition_Type, bool) overload

fn get_total_level(self) -> i32

GetTotalLevel() overload

fn get_order(self) -> i32

GetOrder() overload

fn calc_item_range( self, item: impl Into<ItemData>, skill: impl Into<SkillData>, ) -> (bool, i32, i32)

CalcItemRange(crate::app::itemdata::ItemData, *muti32, *muti32, crate::app::skilldata::SkillData) overload

fn get_item_grow_capability(self, item: impl Into<ItemData>) -> CapabilitySbyte

GetItemGrowCapability(crate::app::itemdata::ItemData) overload

fn get_attack_image(self) -> MapDeployAttackImage

get_AttackImage() overload

fn get_rod_image(self) -> MapDeployRodImage

get_RodImage() overload

fn get_heal_image(self) -> MapDeployHealImage

get_HealImage() overload

fn get_support_image(self) -> MapDeploySupportImage

get_SupportImage() overload

fn get_interference_image(self) -> MapDeployInterferenceImage

get_InterferenceImage() overload

fn get_total_order(self) -> i32

get_TotalOrder() overload

fn set_total_order(self, value: impl Into<i32>)

set_TotalOrder(i32) overload

fn get_total_action(self) -> i32

get_TotalAction() overload

fn set_total_action(self, value: impl Into<i32>)

set_TotalAction(i32) overload

fn get_total_attack(self) -> i32

get_TotalAttack() overload

fn set_total_attack(self, value: impl Into<i32>)

set_TotalAttack(i32) overload

fn get_total_damage(self) -> i32

get_TotalDamage() overload

fn set_total_damage(self, value: impl Into<i32>)

set_TotalDamage(i32) overload

fn get_total_result(self) -> BattleScene_Result

get_TotalResult() overload

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

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

fn get_side_type(self) -> BattleSide_Type

get_SideType() overload

fn set_side_type(self, value: impl Into<BattleSide_Type>)

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

fn update_image(self, deploy: impl Into<MapDnagerDeploy>)

UpdateImage(crate::app::mapdnagerdeploy::MapDnagerDeploy) overload

fn clear_image(self)

ClearImage() overload

fn try_get_engage_mind(self) -> (bool, MapMind_Type)

TryGetEngageMind(*mutcrate::app::mapmind::MapMind_Type) overload

fn get_engage_attack(self) -> SkillData

GetEngageAttack() overload

fn get_engage_skills(self) -> SkillArray

GetEngageSkills() overload

fn get_engage_skill(self, index: impl Into<i32>) -> SkillData

GetEngageSkill(i32) overload

fn get_support_skill(self) -> SkillData

GetSupportSkill() overload

fn add_cannon_skill(self, inspector: impl Into<CannonInspector>)

AddCannonSkill(crate::app::cannoninspector::CannonInspector) overload

fn remove_cannon_skill(self, inspector: impl Into<CannonInspector>)

RemoveCannonSkill(crate::app::cannoninspector::CannonInspector) overload

fn add_command_skill(self, skill: impl Into<SkillData>)

AddCommandSkill(crate::app::skilldata::SkillData) overload

fn remove_command_skill(self, skill: impl Into<SkillData>)

RemoveCommandSkill(crate::app::skilldata::SkillData) overload

fn add_give_skill(self, give: impl Into<SkillData>)

AddGiveSkill(crate::app::skilldata::SkillData) overload

fn add_give_skill_2(self, gives: impl Into<SkillArray>)

AddGiveSkill(crate::app::skillarray::SkillArray) overload

fn get_battle_temporary(self) -> i32

get_BattleTemporary() overload

fn set_battle_temporary(self, value: impl Into<i32>)

set_BattleTemporary(i32) overload

fn is_exist_die(self) -> bool

IsExistDie() overload

fn update_move_distance(self)

UpdateMoveDistance() overload

fn update_move_distance_2(self, x: impl Into<i32>, z: impl Into<i32>)

UpdateMoveDistance(i32, i32) overload

fn update_move_distance_3( self, route: impl Into<MapRoute>, x: impl Into<i32>, z: impl Into<i32>, )

UpdateMoveDistance(crate::app::maproute::MapRoute, i32, i32) overload

fn clear_move_distance(self)

ClearMoveDistance() overload

fn can_grow_up(self, type: impl Into<CapabilityDefinition_Type>) -> bool

CanGrowUp(crate::app::capabilitydefinition::CapabilityDefinition_Type) overload

fn get_simple_power(self) -> i32

GetSimplePower() overload

fn get_simple_physical_power(self) -> i32

GetSimplePhysicalPower() overload

fn get_simple_magic_power(self) -> i32

GetSimpleMagicPower() overload

fn get_simple_physical_defense(self) -> i32

GetSimplePhysicalDefense() overload

fn get_simple_magic_defense(self) -> i32

GetSimpleMagicDefense() overload

fn get_simple_hit(self) -> i32

GetSimpleHit() overload

fn get_simple_avoid(self) -> i32

GetSimpleAvoid() overload

fn get_simple_critical(self) -> i32

GetSimpleCritical() overload

fn get_simple_secure(self) -> i32

GetSimpleSecure() overload

fn get_simple_continuous(self) -> i32

GetSimpleContinuous() overload

fn reset_param(self)

ResetParam() overload

fn get_fortune_seed(self) -> u32

get_FortuneSeed() overload

fn set_fortune_seed(self, value: impl Into<u32>)

set_FortuneSeed(u32) overload

fn get_fortune_target(self) -> PersonData

get_FortuneTarget() overload

fn set_fortune_target(self, value: impl Into<PersonData>)

set_FortuneTarget(crate::app::persondata::PersonData) overload

fn get_fortune_random_value(self, update: impl Into<bool>) -> i32

GetFortuneRandomValue(bool) overload

fn get_weapon_level( self, kind: impl Into<ItemData_Kinds>, calc_enhance: impl Into<bool>, ) -> WeaponLevel_Kind

GetWeaponLevel(crate::app::itemdata::ItemData_Kinds, bool) overload

fn get_skill_equip( self, skill: impl Into<SkillData>, index: impl Into<i32>, ) -> UnitItem

GetSkillEquip(crate::app::skilldata::SkillData, i32) overload

fn get_engage_equip( self, skill: impl Into<SkillData>, target: impl Into<Unit>, ) -> UnitItem

GetEngageEquip(crate::app::skilldata::SkillData, crate::app::unit::Unit) overload

fn get_effect_position(self) -> Vector3

GetEffectPosition() overload

fn can_stay_without_god(self) -> bool

CanStayWithoutGod() 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: IUnit> IUnitMethods for __T

Available on crate feature app-unit only.