Config/YesNo Dialog Expansion, Fully defined Structs, Stream additions, DynValue fix and more (#42)

* Dictionary Changes + SpriteAtlas Update

* Typo in AtlasManager struct name and Dictionary for CommonRewardSequence

* DVC additions

* DVC additions

* update

* Stream, ConfigBasicMenu Addition, Keyboard

* update cargo toml to version 0.11.0

---------

Co-authored-by: Raytwo <[email protected]>

Author: triabolicals

Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 name = "engage"
-version = "0.10.0"
+version = "0.11.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+num-traits = "0.2"
+num-derive = "0.4"
 skyline = "0.5"
 unity = { version = "0.3.0", git = "https://github.com/DivineDragonFanClub/unity" }
 modular-bitfield = "0.11.2"
-once_cell = "1.17.0"
 bitflags = "2.4.0"
-lazysimd = { git = "https://github.com/Raytwo/lazysimd" }
+lazysimd = { git = "https://github.com/Raytwo/lazysimd" }

src/ai.rs

@@ -1,6 +1,6 @@
 use unity::il2cpp::object::Array;
 use unity::prelude::*;
-use crate::gamedata::{item::UnitItem, terrain::TerrainData, unit::Unit, WeaponMask};
+use crate::gamedata::{item::UnitItem, terrain::TerrainData, unit::Unit, WeaponMask, skill::SkillArray};
 
 #[unity::class("App", "CapabilityInt")]
 pub struct CapabilityInt {
@@ -15,39 +15,74 @@ pub struct BattleDetail {
 #[unity::class("App", "BattleInfoSide")]
 pub struct BattleInfoSide {
     //junk : [u8; 0x48],
-    info: u64,
+    info: &'static mut BattleInfo,
     pub side_type : i32,
     __ : i32,
     pub unit: Option<&'static Unit>,
-    pub unit_item: &'static UnitItem,
+    pub unit_item: Option<&'static UnitItem>,
     pub specified_item: &'static UnitItem,
     pub x: i32,
     pub z: i32,
     pub terrain: &'static TerrainData,
     pub overlap: &'static TerrainData,
-    pub status: &'static WeaponMask,
+    pub status: &'static mut WeaponMask,
     pub detail: &'static BattleDetail,
     hierarchy: u64,
     support: u64,
     pub parent: &'static BattleInfoSide,
     pub reverse: &'static BattleInfoSide,
+    destroy: *const u8,
+    pub mask_skill: &'static SkillArray,
+    pub level: i32,
+    pub hp: i32,
+    pub gain_exp: i32,
+    pub gain_gold: i32,
+    pub drop_item_ratio: f32,
+    pub pick_up_item: i32,
+    pub damage: i32,
+    pub heal: i32,
+    pub battle_times: i32,
+    pub total_order: i32,
+    pub total_action: i32,
+    pub total_attack: i32,
+    pub total_damage: i32,
+    pub total_result: i32,
+    pub temporary: i32,
+    pub stun: i32,
+    pub engage_count: i32,
+    pub engage_first_count: i32,
+    pub blown_distance: i32,
+    pub weapon_expend: i32,
+    pub expend_count: i32,
 }
 
 #[unity::class("App", "BattleInfo")]
 pub struct BattleInfo {}
 
+impl BattleInfo {
+    pub fn get_unit(&self, side: i32) -> Option<&'static Unit> {
+        unsafe {
+            battle_info_get_unit(self, side, None)
+        }
+    }
+}
 #[unity::class("App", "BattleCalculator")]
 pub struct BattleCalculator {
     pub mode: i32,
     pub info: &'static BattleInfo,
 }
 impl BattleCalculator {
     pub fn get_dead_side(&self) -> i32 { unsafe { battlecalcultor_get_deadside(self, None) }}
+    pub fn get_side(&self, side: i32) -> Option<&'static mut BattleInfoSide> {
+        unsafe { battle_calculator_get_side(self, side, None) }
+    }
 }
 
 #[unity::from_offset("App", "BattleCalculator", "GetDeadSide")]
 fn battlecalcultor_get_deadside(this: &BattleCalculator,method_info: OptionalMethod) -> i32;
 
-
 #[skyline::from_offset(0x01e7f750)]
-pub fn battle_info_get_unit(this: &BattleInfo, index: i32,  method_info: OptionalMethod) -> &Unit; 
+pub fn battle_info_get_unit(this: &BattleInfo, index: i32,  method_info: OptionalMethod) -> Option<&'static Unit>;
+
+#[skyline::from_offset(0x0246f1a0)]
+pub fn battle_calculator_get_side(this: &BattleCalculator, side: i32, method_info: OptionalMethod) -> Option<&'static mut BattleInfoSide>;

src/battle.rs

@@ -0,0 +1,29 @@
+use unity::il2cpp::object::Array;
+use unity::prelude::*;
+
+#[unity::class("App", "BitStruct")]
+pub struct BitStruct {
+    pub bits: &'static Array<u8>,
+}
+
+// BitStructFields is the only part of the whole class that gets used in functions
+impl BitStructFields {
+    pub fn get(&self, index: i32) -> bool {
+        unsafe { bitstruct_get(&self, index, None) }
+    }
+    pub fn set(&self, index: i32, value: bool) {
+        unsafe { bitstruct_set(&self, index, value, None); }
+    }
+    pub fn set_by_toggle(&self, index: i32) {
+        unsafe { bitstruct_set_toggle(&self, index, None); }
+    }
+}
+
+#[skyline::from_offset(0x02988ee0)]
+fn bitstruct_get(this: &BitStructFields, index: i32, method_info: OptionalMethod) -> bool;
+
+#[skyline::from_offset(0x2988f30)]
+fn bitstruct_set(this: &BitStructFields, index: i32, enable: bool, method_info: OptionalMethod) -> bool;
+
+#[skyline::from_offset(0x02988fb0)]
+fn bitstruct_set_toggle(this: &BitStructFields, index: i32, method_info: OptionalMethod) -> bool;

src/bit.rs

@@ -1,6 +1,14 @@
 //! Types and methods to query the state of [`Unit`](crate::gamedata::unit::Unit)s in battle.
 
+use unity::engine::Color;
+use unity::il2cpp::object::Array;
 use unity::prelude::*;
+use unity::system::List;
+use crate::battle::BattleCalculator;
+use crate::force::Force;
+use crate::gamedata::{JobData, PersonData};
+use crate::gamedata::assettable::{AssetTableResult, AssetTableSound};
+use crate::gamedata::item::UnitItem;
 use crate::gamedata::unit::Unit;
 
 #[unity::class("Combat", "Character")]
@@ -116,11 +124,86 @@ bitflags::bitflags! {
 
 #[unity::class("Combat", "CharacterGameStatus")]
 pub struct CharacterGameStatus {
-    appearance: [u8; 0x18],
-    pub unit: &'static mut Unit,
+    pub appearance: &'static mut CharacterAppearance,
+    pub emblem_identifier: Option<&'static Il2CppString>,
+    pub side: i32,
+    pub stun: bool,
+    pub unit: Option<&'static Unit>,
+    pub person: Option<&'static PersonData>,
+    pub job: Option<&'static JobData>,
+    pub force: Option<&'static Force>,
+    pub name: Option<&'static Il2CppString>,
+    pub max_hp: i32,
+    pub hp: i32,
+    pub max_stun: i32,
+    pub stun_value: i32,
+    pub engage_count: i32,
+    pub map_x: i32,
+    pub map_y: i32,
+    pub battle_x: i32,
+    pub battle_y: i32,
+    pub weapon: Option<&'static UnitItem>,
     // too lazy to do the rest for now
 }
+impl CharacterGameStatus {
+    pub fn import(&self, side: i32, calc: &BattleCalculator, side_type: i32, map_distance: i32) {
+        unsafe {
+            combat_character_game_status_import(self, side, calc, side_type, map_distance, None);
+        }
+    }
+}
+
+#[unity::class("Combat", "CombatRecord")]
+pub struct CombatRecord {
+    pub is_enemy_attack: i32,
+    pub combat_style: i32,
+    pub calculator: &'static BattleCalculator,
+    pub sim_calculator: &'static BattleCalculator,
+    pub game_status: &'static mut Array<&'static mut CharacterGameStatus>,
+    pub chain_atk: &'static mut Array<&'static mut CharacterGameStatus>,
+    pub dragonize: &'static mut Array<&'static mut CharacterGameStatus>,
+    location: *const u8,
+    passive_skills: *const u8,
+    phase_array: &'static Array<&'static Phase>,
+    pub map_distance: i32,
+    pub chain_attack_count: i32,
+    pub finish_style: i32,
+}
+
+#[unity::class("Combat", "CharacterAppearance")]
+pub struct CharacterAppearance {
+    pub assets: &'static Array<CharacterAssetT>,
+    pub animset_names: &'static List<Il2CppString>,
+    pub acc_target: &'static Array<&'static Il2CppString>,
+    pub mask_color_100: Color,
+    pub mask_color_075: Color,
+    pub mask_color_050: Color,
+    pub mask_color_025: Color,
+    pub skin_color: Color,
+    pub grad_color: Color,
+    pub hair_color: Color,
+    pub toon_shadow_color: Color,
+    pub sound: AssetTableSound,
+    proporion: *const u8,
+    animset: *const u8,
+    weapon_style: i32,
+}
 
+impl CharacterAppearance {
+    pub fn create_from_result(result: &AssetTableResult, distance: i32) -> &'static mut CharacterAppearance {
+        unsafe {
+            create_from_result(result, distance, None)
+        }
+    }
+}
+
+#[unity::class("Combat", "CharacterAsset")]
+pub struct CharacterAssetT {
+    pub asset_type: i32,
+    pub name: Option<&'static Il2CppString>,
+    pub addr_path: Option<&'static Il2CppString>,
+    //...
+}
 #[repr(C)]
 #[derive(Debug)]
 /// Used by the game to determine the sound effects to play during damage for zoomed-in combat.
@@ -250,3 +333,9 @@ pub fn side_is_master(i: i32, method_info: OptionalMethod) -> bool;
 // Combat.Side$$IsChainAtk	710247cb00	bool Combat.Side$$IsChainAtk(int32_t i, MethodInfo * method)	16
 #[unity::from_offset("Combat", "Side", "IsChainAtk")]
 pub fn side_is_chain_atk(i: i32, method_info: OptionalMethod) -> bool;
+
+#[skyline::from_offset(0x027e0880)]
+fn combat_character_game_status_import(this:&CharacterGameStatus, side: i32, calc: &BattleCalculator, side_type: i32, distance: i32, method_info: OptionalMethod);
+
+#[skyline::from_offset(0x02b0ed80)]
+fn create_from_result(result: &AssetTableResult, map_distance: i32, method_info: OptionalMethod) -> &'static mut CharacterAppearance;

src/combat.rs

@@ -1,7 +1,7 @@
 use unity::prelude::*;
 
 use super::{BasicDialogItem, BasicDialogItemFields};
-use crate::{menu::BasicMenuResult, proc::Bindable};
+use crate::{mess::Mess, menu::BasicMenuResult, proc::Bindable};
 
 #[repr(C)]
 pub struct YesNoDialog(super::BasicDialog<BasicDialogItem>);
@@ -20,12 +20,21 @@ impl YesNoDialog {
             .get_class_mut()
             .get_virtual_method_mut("ACall")
             .map(|method| method.method_ptr = Methods::on_first_choice as _);
+        first_item
+            .get_class_mut()
+            .get_virtual_method_mut("BCall")
+            .map(|method| method.method_ptr = Methods::bcall_first as _);
 
         second_item
             .get_class_mut()
             .get_virtual_method_mut("ACall")
             .map(|method| method.method_ptr = Methods::on_second_choice as _);
 
+        second_item
+            .get_class_mut()
+            .get_virtual_method_mut("BCall")
+            .map(|method| method.method_ptr = Methods::bcall_second as _);
+
         unsafe {
             yesnodialog_createbind(proc, message.as_ref().into(), first_item, second_item, None);
         }
@@ -39,10 +48,16 @@ pub trait TwoChoiceDialogMethods {
     extern "C" fn on_second_choice(_this: &mut BasicDialogItemNo, _method_info: OptionalMethod) -> BasicMenuResult {
         BasicMenuResult::new().with_close_this(true)
     }
+    extern "C" fn bcall_first(_this: &mut BasicDialogItemYes, _method_info: OptionalMethod) -> BasicMenuResult {
+        BasicMenuResult::new().with_close_this(true).with_se_cancel(true)
+    }
+    extern "C" fn bcall_second(_this: &mut BasicDialogItemNo, _method_info: OptionalMethod) -> BasicMenuResult {
+        BasicMenuResult::new().with_close_this(true).with_se_cancel(true)
+    }
 }
 
 #[unity::from_offset("App", "YesNoDialog", "CreateBind")]
-extern "C" fn yesnodialog_createbind<P: Bindable>(
+pub extern "C" fn yesnodialog_createbind<P: Bindable>(
     proc: &P,
     mess: &Il2CppString,
     yes_item: &BasicDialogItemYes,
@@ -66,10 +81,12 @@ impl BasicDialogItemYes {
     pub fn new(text: impl AsRef<str>) -> &'static mut BasicDialogItemYes {
         let item = BasicDialogItemYes::instantiate().unwrap();
 
-        unsafe {
-            dialog_item_yes_ctor(item, text.into(), None);
-        }
-
+        unsafe { dialog_item_yes_ctor(item, text.into(), None); }
+        item
+    }
+    pub fn new_from_mess(mess: impl AsRef<str>) -> &'static mut BasicDialogItemYes {
+        let item = BasicDialogItemYes::instantiate().unwrap();
+        unsafe { dialog_item_yes_ctor(item, Mess::get(mess), None); }
         item
     }
 }
@@ -83,11 +100,12 @@ pub struct BasicDialogItemNo {
 impl BasicDialogItemNo {
     pub fn new(text: impl AsRef<str>) -> &'static mut BasicDialogItemNo {
         let item = BasicDialogItemNo::instantiate().unwrap();
-
-        unsafe {
-            dialog_item_no_ctor(item, text.into(), None);
-        }
-
+        unsafe { dialog_item_no_ctor(item, text.into(), None); }
+        item
+    }
+    pub fn new_from_mess(mess: impl AsRef<str>) -> &'static mut BasicDialogItemNo {
+        let item = BasicDialogItemNo::instantiate().unwrap();
+        unsafe { dialog_item_no_ctor(item, Mess::get(mess), None); }
         item
     }
 }