Merge pull request #2291 from HDR-Development/megaman-adjustments

Megaman Adjustments

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/Cargo.toml

@@ -13,5 +13,5 @@ smashline = { git = "https://github.com/HDR-Development/smashline.git" }
 utils = { package = "dynamic", path = "../../dynamic" }
 ninput = { git = "https://github.com/blu-dev/ninput" }
 interpolation = "0.2.0" # for f32::lerp
-smash2 = { package = "smash", git = "https://github.com/blu-dev/smash-rs" }
+smash_rs = { package = "smash", git = "https://github.com/blu-dev/smash-rs" }
 rand = { git = "https://github.com/skyline-rs/rand" }

fighters/common/src/function_hooks/attack.rs

@@ -4,7 +4,7 @@ use std::arch::asm;
 use utils::game_modes::CustomMode;
 
 #[skyline::hook(offset = 0x3dc180)]
-unsafe fn attack_module_set_attack(module: u64, id: i32, group: i32, data: &mut smash2::app::AttackData) {
+unsafe fn attack_module_set_attack(module: u64, id: i32, group: i32, data: &mut smash_rs::app::AttackData) {
     let boma = *(module as *mut *mut BattleObjectModuleAccessor).add(1);
 
     // if a hitbox does not intentionally trip 100% of time, remove random trip chance
@@ -21,31 +21,31 @@ unsafe fn attack_module_set_attack(module: u64, id: i32, group: i32, data: &mut
             data.r_eff = 50;  // KBG
             data.r_add = 55;  // BKB
             data.sub_shield = 0;  // shield damage modifier
-            data.lr_check = smash2::app::AttackLRCheck::Pos; // always allow reverse hit
+            data.lr_check = smash_rs::app::AttackLRCheck::Pos; // always allow reverse hit
         }
         if (*boma).is_status(*FIGHTER_STATUS_KIND_SLIP_STAND_ATTACK) {
             data.power = 5.0;
             data.vector = 361;
             data.r_eff = 50;
             data.r_add = 55;
             data.sub_shield = 0;
-            data.lr_check = smash2::app::AttackLRCheck::Pos;
+            data.lr_check = smash_rs::app::AttackLRCheck::Pos;
         }
         if (*boma).is_status(*FIGHTER_STATUS_KIND_CLIFF_ATTACK) {
             data.power = 8.0;
             data.vector = 361;
             data.r_eff = 50;
             data.r_add = 45;
             data.sub_shield = 0;
-            data.lr_check = smash2::app::AttackLRCheck::Pos;
+            data.lr_check = smash_rs::app::AttackLRCheck::Pos;
         }
         if (*boma).is_status(*FIGHTER_STATUS_KIND_CATCH_ATTACK) {
             if !VarModule::is_flag((*boma).object(), vars::common::status::PUMMEL_OVERRIDE_GLOBAL_STATS) {
                 data.stop_frame = 3.5;  // hitlag mul
             }
         }
     }
-    
+
     call_original!(module, id, group, data)
 }
 

fighters/common/src/function_hooks/mod.rs

@@ -23,10 +23,10 @@ pub mod attack;
 pub mod collision;
 pub mod camera;
 pub mod shotos;
-pub mod aura;
 pub mod sound;
 mod fighterspecializer;
 mod fighter_util;
+mod vtables;
 
 #[repr(C)]
 pub struct TempModule {
@@ -362,7 +362,7 @@ unsafe fn before_collision(object: *mut BattleObject) {
                         app::lua_bind::KineticEnergyNormal::set_speed(damage_energy, &vec2);
                     }
                 }
-                
+
                 // </HDR>
 
                 let func_addr = (skyline::hooks::getRegionAddress(skyline::hooks::Region::Text) as *mut u8).add(0x6212f0);
@@ -384,7 +384,7 @@ unsafe fn before_collision(object: *mut BattleObject) {
                     let damage_speed_x = KineticModule::get_sum_speed_x(boma, *KINETIC_ENERGY_RESERVE_ATTRIBUTE_DAMAGE);
                     let mut jostle_energy = KineticModule::get_energy(boma, *FIGHTER_KINETIC_ENERGY_ID_JOSTLE) as *mut app::KineticEnergy;
                     let jostle_energy_x = app::lua_bind::KineticEnergy::get_speed_x(jostle_energy);
-            
+
                     if jostle_energy_x != 0.0
                     && (main_speed_x + damage_speed_x).abs() < jostle_energy_x.abs() {
                         // This check passes if the speed at which your character is moving due to general movement
@@ -622,28 +622,28 @@ unsafe fn after_collision(object: *mut BattleObject) {
             {
                 WorkModule::set_int(boma, 0, *FIGHTER_INSTANCE_WORK_ID_INT_FRAME_IN_AIR);
             }
-            
+
             // No need to check for motion kind changes if we are:
             //   1. Not currently detecting surface collision
             //   2. Neither on the ground nor in the air
             if GroundModule::get_correct(boma) != *GROUND_CORRECT_KIND_NONE
             && [*SITUATION_KIND_GROUND, *SITUATION_KIND_AIR].contains(&StatusModule::situation_kind(boma))
             && [*SITUATION_KIND_GROUND, *SITUATION_KIND_AIR].contains(&StatusModule::prev_situation_kind(boma))
             {
-                
+
                 let ground_module = *(boma as *mut BattleObjectModuleAccessor as *const u64).add(0x58 / 8);
                 let ground_collision_info = *((ground_module + 0x28) as *mut *mut f32);
-        
+
                 let prev_collision_line_up = ((ground_collision_info as u64) + 0x190) as *mut GroundCollisionLine;
                 let prev_collision_line_left = ((ground_collision_info as u64) + 0x1c0) as *mut GroundCollisionLine;
                 let prev_collision_line_right = ((ground_collision_info as u64) + 0x1f0) as *mut GroundCollisionLine;
                 let prev_collision_line_down = ((ground_collision_info as u64) + 0x220) as *mut GroundCollisionLine;
-                
+
                 let collision_line_up = ((ground_collision_info as u64) + 0x10) as *mut GroundCollisionLine;
                 let collision_line_left = ((ground_collision_info as u64) + 0x40) as *mut GroundCollisionLine;
                 let collision_line_right = ((ground_collision_info as u64) + 0x70) as *mut GroundCollisionLine;
                 let collision_line_down = ((ground_collision_info as u64) + 0xa0) as *mut GroundCollisionLine;
-        
+
                 // This check passes only on the first frame you come into contact with/leave a surface (ground/wall/ceiling)
                 // except when jumping, as the game already changes motion earlier on
                 if ( (*(prev_collision_line_up as *mut u64) == 0 && *(collision_line_up as *mut u64) != 0)
@@ -759,18 +759,18 @@ pub fn install() {
     collision::install();
     camera::install();
     shotos::install();
-    aura::install();
     sound::install();
     fighterspecializer::install();
     fighter_util::install();
+    vtables::install();
 
     unsafe {
         // Handles getting rid of the kill zoom
         const KILL_ZOOM_DATA: u32 = 0xD503201Fu32;
         skyline::patching::Patch::in_text(utils::offsets::kill_zoom_regular()).nop();
         skyline::patching::Patch::in_text(utils::offsets::kill_zoom_throw()).data(KILL_ZOOM_DATA);
         // Changes full hops to calculate vertical velocity identically to short hops
-        skyline::patching::Patch::in_text(0x6d21a8).data(0x52800015u32);        
+        skyline::patching::Patch::in_text(0x6d21a8).data(0x52800015u32);
 
         // removes phantoms
         skyline::patching::Patch::in_text(0x3e6d08).data(0x14000012u32);

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
+    );
+}