Moved vtables

Author: WuBoytH

dynamic/src/ext.rs

@@ -1519,142 +1519,19 @@ pub struct MappedInputs {
     pub rstick_y: i8,
 }
 
-pub type StatusFunc = unsafe extern "C" fn(&mut L2CFighterCommon) -> L2CValue;
-
 #[repr(C)]
-pub struct StatusInfo {
-    pub pre: Option<StatusFunc>,
-    pub main: Option<StatusFunc>,
-    pub end: Option<StatusFunc>,
-    pub init: Option<StatusFunc>,
-    pub exec: Option<StatusFunc>,
-    pub exec_stop: Option<StatusFunc>,
-    pub exec_post: Option<StatusFunc>,
-    pub exit: Option<StatusFunc>,
-    pub map_correction: Option<StatusFunc>,
-    pub fix_camera: Option<StatusFunc>,
-    pub fix_pos_slow: Option<StatusFunc>,
-    pub check_damage: Option<StatusFunc>,
-    pub check_attack: Option<StatusFunc>,
-    pub on_change_lr: Option<StatusFunc>,
-    pub leave_stop: Option<StatusFunc>,
-    pub notify_event_gimmick: Option<StatusFunc>,
-    pub calc_param: Option<StatusFunc>,
-}
-
-impl StatusInfo {
-    pub fn new() -> StatusInfo {
-        StatusInfo {
-            pre: None,
-            main: None,
-            end: None,
-            init: None,
-            exec: None,
-            exec_stop: None,
-            exec_post: None,
-            exit: None,
-            map_correction: None,
-            fix_camera: None,
-            fix_pos_slow: None,
-            check_damage: None,
-            check_attack: None,
-            on_change_lr: None,
-            leave_stop: None,
-            notify_event_gimmick: None,
-            calc_param: None,
-        }
-    }
-
-    pub fn with_pre(mut self, pre: StatusFunc) -> Self {
-        self.pre = Some(pre);
-        self
-    }
-
-    pub fn with_main(mut self, main: StatusFunc) -> Self {
-        self.main = Some(main);
-        self
-    }
-
-    pub fn with_end(mut self, end: StatusFunc) -> Self {
-        self.end = Some(end);
-        self
-    }
-
-    pub fn with_init(mut self, init: StatusFunc) -> Self {
-        self.init = Some(init);
-        self
-    }
-
-    pub fn with_exec(mut self, exec: StatusFunc) -> Self {
-        self.exec = Some(exec);
-        self
-    }
-
-    pub fn with_exec_stop(mut self, exec_stop: StatusFunc) -> Self {
-        self.exec_stop = Some(exec_stop);
-        self
-    }
-
-    pub fn with_exec_post(mut self, exec_post: StatusFunc) -> Self {
-        self.exec_post = Some(exec_post);
-        self
-    }
-
-    pub fn with_exit(mut self, exit: StatusFunc) -> Self {
-        self.exit = Some(exit);
-        self
-    }
-
-    pub fn with_map_correction(mut self, map_correction: StatusFunc) -> Self {
-        self.map_correction = Some(map_correction);
-        self
-    }
-
-    pub fn with_fix_camera(mut self, fix_camera: StatusFunc) -> Self {
-        self.fix_camera = Some(fix_camera);
-        self
-    }
-
-    pub fn with_fix_pos_slow(mut self, fix_pos_slow: StatusFunc) -> Self {
-        self.fix_pos_slow = Some(fix_pos_slow);
-        self
-    }
-
-    pub fn with_check_damage(mut self, check_damage: StatusFunc) -> Self {
-        self.check_damage = Some(check_damage);
-        self
-    }
-
-    pub fn with_check_attack(mut self, check_attack: StatusFunc) -> Self {
-        self.check_attack = Some(check_attack);
-        self
-    }
-
-    pub fn with_on_change_lr(mut self, on_change_lr: StatusFunc) -> Self {
-        self.on_change_lr = Some(on_change_lr);
-        self
-    }
-
-    pub fn with_leave_stop(mut self, leave_stop: StatusFunc) -> Self {
-        self.leave_stop = Some(leave_stop);
-        self
-    }
-
-    pub fn with_notify_event_gimmick(mut self, notify_event_gimmick: StatusFunc) -> Self {
-        self.notify_event_gimmick = Some(notify_event_gimmick);
-        self
-    }
-
-    pub fn with_calc_param(mut self, calc_param: StatusFunc) -> Self {
-        self.calc_param = Some(calc_param);
-        self
-    }
-}
-
-pub fn is_hdr_available() -> bool {
-    let mut symbol = 0usize;
-    unsafe {
-        skyline::nn::ro::LookupSymbol(&mut symbol, "hdr_is_available\0".as_ptr());
-    }
-    symbol != 0
+pub struct CollisionLog {
+    pub next: *mut CollisionLog,
+    pub end: *mut CollisionLog,
+    pub location: Vector3f,
+    pub padding_0: u32,
+    pub padding_1: u32,
+    pub opponent_battle_object_id: u32,
+    pub padding_2: [u8;7],
+    pub collision_kind: u8,
+    pub receiver_part_id: u8,
+    pub collider_part_id: u8,
+    pub receiver_id: u8,
+    pub collider_id: u8,
+    pub padding_3: [u8;10]
 }

fighters/common/src/function_hooks/mod.rs

@@ -23,7 +23,6 @@ pub mod attack;
 pub mod collision;
 pub mod camera;
 pub mod shotos;
-pub mod aura;
 pub mod sound;
 mod fighterspecializer;
 mod fighter_util;
@@ -760,7 +759,6 @@ pub fn install() {
     collision::install();
     camera::install();
     shotos::install();
-    aura::install();
     sound::install();
     fighterspecializer::install();
     fighter_util::install();

fighters/common/src/function_hooks/vtables/brave.rs

@@ -0,0 +1,29 @@
+use super::*;
+use utils::ext::*;
+
+extern "C" {
+    #[link_name = "_ZN3app24FighterSpecializer_Brave23special_lw_open_commandERNS_7FighterE"]
+    fn special_lw_open_command();
+}
+
+extern "C" {
+    #[link_name = "hero_rng_hook_impl"]
+    fn hero_rng_hook_impl(fighter: *mut BattleObject);
+}
+
+#[skyline::hook(replace = special_lw_open_command)]
+pub unsafe fn hero_rng_hook(fighter: *mut BattleObject) {
+    hero_rng_hook_impl(fighter);
+}
+
+#[skyline::hook(offset = 0x853e10)]
+pub unsafe fn psych_up_hit() {
+    // do nothing
+}
+
+pub fn install() {
+    skyline::install_hooks!(
+        hero_rng_hook,
+        psych_up_hit
+    );
+}

fighters/common/src/function_hooks/vtables/donkey.rs

@@ -0,0 +1,29 @@
+use super::*;
+use utils::ext::*;
+
+#[skyline::hook(offset = 0x993ee0)]
+pub unsafe extern "C" fn donkey_link_event(vtable: u64, fighter: &mut Fighter, event: &mut smash_rs::app::LinkEvent) -> u64 {
+    // param_3 + 0x10
+    if event.link_event_kind.0 == hash40("capture") {
+        // println!("hi");
+        let capture_event : &mut smash_rs::app::LinkEventCapture = std::mem::transmute(event);
+        let module_accessor = fighter.battle_object.module_accessor;
+        if StatusModule::status_kind(module_accessor) == *FIGHTER_STATUS_KIND_SPECIAL_LW {
+            // param_3[0x28]
+            capture_event.result = true;
+            // capture_event.constraint = false;
+            // param_3 + 0x30
+            capture_event.node = smash_rs::phx::Hash40::new("throw");
+            StatusModule::change_status_request(module_accessor, *FIGHTER_STATUS_KIND_CATCH_PULL, false);
+            return 0;
+        }
+        return 1;
+    }
+    original!()(vtable, fighter, event)
+}
+
+pub fn install() {
+    skyline::install_hooks!(
+        donkey_link_event
+    );
+}

fighters/ganon/src/vtable_hook.rs fighters/common/src/function_hooks/vtables/ganon.rs

@@ -0,0 +1,23 @@
+use super::*;
+use utils::ext::*;
+
+extern "C" {
+    #[link_name = "krool_belly_damage_hook_impl"]
+    fn krool_belly_damage_hook_impl(damage: f32, fighter: *mut Fighter, unk: bool);
+}
+
+// #[skyline::hook(offset = 0xc050d8, inline)]
+// pub unsafe fn krool_belly_toggle_hook(ctx: &mut skyline::hooks::InlineCtx) {
+//     krool_belly_toggle_hook_impl(ctx);
+// }
+
+#[skyline::hook(offset = 0xc055f0)]
+pub unsafe fn krool_belly_damage_hook(damage: f32, fighter: *mut Fighter, unk: bool) {
+    krool_belly_damage_hook_impl(damage, fighter, unk);
+}
+
+pub fn install() {
+    skyline::install_hooks!(
+        krool_belly_damage_hook
+    );
+}

fighters/common/src/function_hooks/vtables/krool.rs

@@ -0,0 +1,103 @@
+use super::*;
+use utils::ext::*;
+
+#[skyline::hook(offset = 0xc456a0)]
+pub unsafe extern "C" fn hook_ko_meter_gain(vtable: u64, battle_object: *mut BattleObject, collisionLog: CollisionLog, damage: f32) -> u64 {
+    let boma = (&mut *(battle_object)).boma();
+    let opponent_boma = &mut *(sv_battle_object::module_accessor(collisionLog.opponent_battle_object_id));
+    //if HitModule::get_status(opponent_boma, collisionLog.receiver_part_id as i32, 0) != 0 { return call_original!(vtable, battle_object, collisionLog, 0.0); }
+    let mut meter_gain = 5.0;
+
+    // this effectively stubs the logic handling critical zoom unless at full meter
+    if boma.is_status(*FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_N2) {
+        let meter = WorkModule::get_float(boma, *FIGHTER_LITTLEMAC_INSTANCE_WORK_ID_FLOAT_KO_GAGE);
+        if meter != 100.0 {
+            let size = if meter < 40.0 { 0.5 } else { 0.7 };
+            EffectModule::req_on_joint(boma, Hash40::new("sys_hit_normal_l"), Hash40::new("handr"), &Vector3f::zero(), &Vector3f::zero(), 0.8, &Vector3f::zero(), &Vector3f::zero(), false, 0, 0, 0);
+            return 1
+        }
+    }
+
+    // modify meter gain based on opponent action
+    if opponent_boma.is_status_one_of(&[
+        *FIGHTER_STATUS_KIND_DAMAGE,
+        *FIGHTER_STATUS_KIND_DAMAGE_AIR,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY_ROLL,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY_METEOR,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY_REFLECT_LR,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY_REFLECT_U,
+        *FIGHTER_STATUS_KIND_DAMAGE_FLY_REFLECT_D,
+        *FIGHTER_STATUS_KIND_DAMAGE_FALL]) {
+        meter_gain = 10.0;
+    }
+    if opponent_boma.is_status_one_of(&[
+        *FIGHTER_STATUS_KIND_ATTACK_S4_HOLD,
+        *FIGHTER_STATUS_KIND_ATTACK_HI4_HOLD,
+        *FIGHTER_STATUS_KIND_ATTACK_LW4_HOLD]) {
+        EffectModule::req_on_joint(boma, Hash40::new("sys_sp_flash"), Hash40::new("top"), &Vector3f::new(0.0, 15.0, 4.0), &Vector3f::new(0.0, 0.0, 0.0), 1.0, &Vector3f::zero(), &Vector3f::zero(), true, 0, 0, 0);
+        meter_gain = 30.0;
+    }
+    if opponent_boma.is_status(*FIGHTER_STATUS_KIND_APPEAL) {
+        if TeamModule::hit_team_no(boma) != TeamModule::hit_team_no(opponent_boma) {
+            SlowModule::set_whole(boma, 4, 60);
+            EffectModule::req_on_joint(boma, Hash40::new("sys_hit_dead"), Hash40::new("bust"), &Vector3f::new(0.0, 0.0, 0.0), &Vector3f::new(0.0, 0.0, 0.0), 0.6, &Vector3f::zero(), &Vector3f::zero(), true, 0, 0, 0);
+            SoundModule::play_se_no3d(boma, Hash40::new("vc_littlemac_appeal05"), true, true);
+            SoundModule::play_se_no3d(boma, Hash40::new("vc_littlemac_missfoot02"), true, true);
+            meter_gain = 100.0;
+        }
+    }
+
+    // modify meter based on the attack used
+    if boma.is_status_one_of(&[
+        *FIGHTER_STATUS_KIND_ATTACK_100,
+        *FIGHTER_STATUS_KIND_ATTACK_S3,
+        *FIGHTER_STATUS_KIND_SPECIAL_HI,
+        *FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_HI_JUMP,
+        *FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_HI_START,
+        *FIGHTER_STATUS_KIND_ATTACK]) {
+        if !VarModule::is_flag(boma.object(), vars::littlemac::status::LIMIT_METER_GAIN) {
+            VarModule::on_flag(boma.object(), vars::littlemac::status::LIMIT_METER_GAIN);
+        }
+        else {
+            meter_gain *= if boma.is_status(*FIGHTER_STATUS_KIND_ATTACK_100) { 0.1 }
+            else if boma.is_status_one_of(&[
+                *FIGHTER_STATUS_KIND_SPECIAL_HI,
+                *FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_HI_JUMP,
+                *FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_HI_START
+            ]) { 0.2 } else { 0.5 };
+        }
+        if boma.is_motion(Hash40::new("attack_13"))
+        && VarModule::is_flag(boma.object(), vars::littlemac::instance::IS_DREAMLAND_EXPRESS) {
+            EffectModule::req_on_joint(boma, Hash40::new("sys_hit_magic"), Hash40::new("handl"), &Vector3f::zero(), &Vector3f::zero(), 0.4, &Vector3f::zero(), &Vector3f::zero(), false, 0, 0, 0);
+            meter_gain += 10.0;
+        }
+    }
+    if boma.is_status(*FIGHTER_LITTLEMAC_STATUS_KIND_SPECIAL_S_JUMP) {
+        meter_gain = 0.0;
+    }
+    if boma.is_status_one_of(&[
+        *FIGHTER_STATUS_KIND_ATTACK_S4,
+        *FIGHTER_STATUS_KIND_ATTACK_HI4,
+        *FIGHTER_STATUS_KIND_ATTACK_LW4]) {
+        meter_gain *= 2.0;
+    }
+
+    // Example on how to call update_littlemac_ui
+
+    // let meter = WorkModule::get_float(boma, *FIGHTER_LITTLEMAC_INSTANCE_WORK_ID_FLOAT_KO_GAGE);
+    // println!("Current Meter: {}", meter);
+    // println!("Gained Meter: {}", meter_gain);
+    // println!();
+
+    // let entry_id = WorkModule::get_int(boma, *FIGHTER_INSTANCE_WORK_ID_INT_ENTRY_ID);
+    // update_littlemac_ui(entry_id, meter + meter_gain);
+
+    call_original!(vtable, battle_object, collisionLog, meter_gain)
+}
+
+pub fn install() {
+    skyline::install_hooks!(
+        hook_ko_meter_gain,
+    );
+}

fighters/common/src/function_hooks/vtables/littlemac.rs

@@ -1,7 +1,21 @@
 use super::*;
 
+mod donkey;
+mod ganon;
+mod lucario;
+mod ptrainer;
+mod littlemac;
 mod rockman;
+mod krool;
+mod brave;
 
 pub fn install() {
+    donkey::install();
+    ganon::install();
+    lucario::install();
+    ptrainer::install();
+    littlemac::install();
     rockman::install();
+    krool::install();
+    brave::install();
 }