commit cccb88cdc0adcc843b293f2f1260954d61feffa6 Author: Aika Date: Fri Jul 10 15:38:40 2026 +0000 Add files via upload diff --git a/Storm-master/Byte_Manager/Byte_Manager.hpp b/Storm-master/Byte_Manager/Byte_Manager.hpp new file mode 100644 index 0000000..1978843 --- /dev/null +++ b/Storm-master/Byte_Manager/Byte_Manager.hpp @@ -0,0 +1,38 @@ +namespace Byte_Manager +{ + void Set_Bytes(__int8 Writeable, void* Address, unsigned __int32 Size, unsigned __int8 Byte) + { + if (Writeable == 0) + { + DWORD Previous_Access_Rights; + + VirtualProtect(Address, Size, PAGE_EXECUTE_READWRITE, &Previous_Access_Rights); + + __builtin_memset(Address, Byte, Size); + + VirtualProtect(Address, Size, Previous_Access_Rights, &Previous_Access_Rights); + } + else + { + __builtin_memset(Address, Byte, Size); + } + } + + void Copy_Bytes(__int8 Writeable, void* Address, unsigned __int32 Size, void* Bytes) + { + if (Writeable == 0) + { + DWORD Previous_Access_Rights; + + VirtualProtect(Address, Size, PAGE_EXECUTE_READWRITE, &Previous_Access_Rights); + + __builtin_memcpy(Address, Bytes, Size); + + VirtualProtect(Address, Size, Previous_Access_Rights, &Previous_Access_Rights); + } + else + { + __builtin_memcpy(Address, Bytes, Size); + } + } +}; \ No newline at end of file diff --git a/Storm-master/Calculate_View.hpp b/Storm-master/Calculate_View.hpp new file mode 100644 index 0000000..975fc57 --- /dev/null +++ b/Storm-master/Calculate_View.hpp @@ -0,0 +1,8 @@ +void* Original_Calculate_View_Caller; + +void __thiscall Redirected_Calculate_View(void* Player, void* Unknown_Parameter_1, float* Angles, void* Unknown_Parameter_2) +{ + (decltype(&Redirected_Calculate_View)(Original_Calculate_View_Caller))(Player, Unknown_Parameter_1, Angles, Unknown_Parameter_2); + + Byte_Manager::Copy_Bytes(1, Angles, sizeof(float[3]), (float*)((unsigned __int32)Player + 4996)); +} \ No newline at end of file diff --git a/Storm-master/Copy_Command.hpp b/Storm-master/Copy_Command.hpp new file mode 100644 index 0000000..733f4d7 --- /dev/null +++ b/Storm-master/Copy_Command.hpp @@ -0,0 +1,923 @@ +struct Target_Structure +{ + __int32 Identifier; + + void* Self; + + __int8 Priority; + + float Distance; + + __int32 Tick_Number; +}; + +std::vector Sorted_Target_List; + +void* Get_Studio_Header(void* Entity) +{ + using Get_Studio_Header_Type = void*(__thiscall*)(void* Entity); + + return Get_Studio_Header_Type((unsigned __int32)Client_Module + 8512)(Entity); +} + +void* Get_Hitbox_Set(Target_Structure* Target, float(*Bones)[3][4], float Time) +{ + using Setup_Bones_Type = __int8(__thiscall*)(void* Entity, void* Bones, __int32 Maximum_Bones, __int32 Mask, float Time); + + if (Setup_Bones_Type((unsigned __int32)Client_Module + 246656)((void*)((unsigned __int32)Target->Self + 4), Bones, 128, 524032, Time) == 1) + { + void* Studio_Header = *(void**)Get_Studio_Header(Target->Self); + + return (void*)((unsigned __int32)Studio_Header + *(__int32*)((unsigned __int32)Studio_Header + 176)); + } + + return nullptr; +} + +void* Original_Copy_Command_Caller; + +void __thiscall Redirected_Copy_Command(void* Unknown_Parameter, Command_Structure* Command) +{ + Extended_Command_Structure* Extended_Command = &Extended_Commands[Command->Command_Number % 150]; + + Extended_Command->Extra_Commands = 0; + + Extended_Command->Sequence_Shift = 0; + + void* Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + Global_Variables_Structure* Global_Variables = *(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744); + + if (Extra_Commands == -1) + { + *(float*)((unsigned __int32)Local_Player + 16) = Global_Variables->Interval_Per_Tick; + + *(__int32*)((unsigned __int32)Local_Player + 20) = Command->Command_Number; + + if ((Command->Buttons & 524288) == 524288) + { + Extended_Command->Extra_Commands = max(0, Extra_Commands = std::clamp(Interface_Extra_Commands.Integer, (__int32)(0.06f / Global_Variables->Interval_Per_Tick + 0.5f), 14)); + + *(float*)((unsigned __int32)Local_Player + 16) *= 1.f + Extended_Command->Extra_Commands * Interface_Interpolate_Extra_Commands.Integer; + } + + __int32 Variable_Number = 0; + + Traverse_Variables_Label: + { + void* Variable = *(void**)(*(unsigned __int32*)((unsigned __int32)Local_Player + 24) + Variable_Number * 12 + 8); + + *(float*)((unsigned __int32)Variable + 36) = *(float*)((unsigned __int32)Local_Player + 16); + + Variable_Number += 1; + + if (Variable_Number != *(__int32*)((unsigned __int32)Local_Player + 36)) + { + goto Traverse_Variables_Label; + } + } + } + + if (*(__int8*)((unsigned __int32)Local_Player + 327) == 0) + { + Command->Buttons |= 4194304 * (Command->Command_Number % 2); + + float Move_Angles[3] = + { + Command->Angles[0], + + Command->Angles[1] + }; + + static float Previous_Move_Angle_Y; + + if ((Command->Buttons & 2) + *(__int8*)((unsigned __int32)Local_Player + 324) == 4) + { + Command->Move[0] = 0.f; + + if (*(void**)((unsigned __int32)Local_Player + 316) == INVALID_HANDLE_VALUE) + { + Command->Buttons &= ~2; + } + else + { + Command->Buttons &= ~(*(__int32*)((unsigned __int32)Local_Player + 5028) & 2); + } + + float Difference = __builtin_remainderf(Move_Angles[1] - Previous_Move_Angle_Y, 360.f); + + Previous_Move_Angle_Y = Move_Angles[1]; + + float* Velocity = (float*)((unsigned __int32)Local_Player + 256); + + if (__builtin_fabsf(Difference) < __builtin_atan2f(30.f, __builtin_hypotf(Velocity[0], Velocity[1])) * 180.f / 3.1415927f) + { + float Strafe_Angle = __builtin_remainderf(Move_Angles[1] - __builtin_atan2f(Velocity[1], Velocity[0]) * 180.f / 3.1415927f, 360.f); + + if (__builtin_signbitf(Strafe_Angle) == 0) + { + Command->Move[1] = -450.f; + } + else + { + Command->Move[1] = 450.f; + } + + Move_Angles[1] -= Strafe_Angle; + } + else + { + if (__builtin_signbitf(Difference) == 0) + { + Command->Move[1] = -450.f; + } + else + { + Command->Move[1] = 450.f; + } + } + } + else + { + Previous_Move_Angle_Y = Move_Angles[1]; + } + + float Previous_Move[2]; + + Byte_Manager::Copy_Bytes(1, Previous_Move, sizeof(Previous_Move), Command->Move); + + float Desired_Move_Forward[3]; + + float Desired_Move_Right[3]; + + Angle_Vectors(Move_Angles, Desired_Move_Forward, Desired_Move_Right, nullptr); + + Desired_Move_Forward[2] = 0.f; + + Vector_Normalize(Desired_Move_Forward); + + Desired_Move_Right[2] = 0.f; + + Vector_Normalize(Desired_Move_Right); + + float Desired_Move[2] = + { + Desired_Move_Forward[0] * Command->Move[0] + Desired_Move_Right[0] * Command->Move[1], + + Desired_Move_Forward[1] * Command->Move[0] + Desired_Move_Right[1] * Command->Move[1] + }; + + auto Correct_Movement = [&]() -> void + { + float Move_Forward[3]; + + float Move_Right[3]; + + Angle_Vectors(Command->Angles, Move_Forward, Move_Right, nullptr); + + Move_Forward[2] = 0.f; + + Vector_Normalize(Move_Forward); + + Move_Right[2] = 0.f; + + Vector_Normalize(Move_Right); + + float Divider = Move_Forward[0] * Move_Right[1] - Move_Right[0] * Move_Forward[1]; + + Command->Move[0] = (Desired_Move[0] * Move_Right[1] - Move_Right[0] * Desired_Move[1]) / Divider; + + Command->Move[1] = (Move_Forward[0] * Desired_Move[1] - Desired_Move[0] * Move_Forward[1]) / Divider; + }; + + Correct_Movement(); + + Extended_Command_Structure* Initial_Extended_Command = &Extended_Commands[*(__int32*)((unsigned __int32)Local_Player + 20) % 150]; + + void* Network_Channel = *(void**)(*(unsigned __int32*)((unsigned __int32)Engine_Module + 4352236) + 24); + + auto Sequence_Shift = [&](__int32 Reserve) -> void + { + if (Initial_Extended_Command->Sequence_Shift == 0) + { + __int32 Sequence_Shift = (*(__int32*)((unsigned __int32)Local_Player + 5324) - Extended_Command->Extra_Commands + ~-150) / 150 * 150 + (Reserve * 150); + + if (Sequence_Shift > 0) + { + *(__int32*)((unsigned __int32)Network_Channel + 8) += Sequence_Shift; + + Extended_Command->Sequence_Shift += Sequence_Shift; + + __int32 Command_Number = Command->Command_Number; + + Traverse_Command_Batch_Label: + { + Command_Number -= 1; + + if (Command_Number >= *(__int32*)((unsigned __int32)Local_Player + 20)) + { + Extended_Commands[Command_Number % 150].Sequence_Shift = Extended_Command->Sequence_Shift; + + goto Traverse_Command_Batch_Label; + } + } + } + } + }; + + static __int32 Accumulative_Correction; + + auto Disable_Clock_Correction = [&](__int32 Queue) -> void + { + if (Queue > 0) + { + if (Extended_Command == Initial_Extended_Command) + { + Extended_Command->Extra_Commands = 0; + + Extra_Commands = max((__int32)(0.06f / Global_Variables->Interval_Per_Tick + 0.5f), Queue); + } + else + { + Accumulative_Correction += 1; + } + + if (Initial_Extended_Command->Extra_Commands == 0) + { + *(__int32*)((unsigned __int32)Network_Channel + 16) = -1; + + *(__int32*)((unsigned __int32)Network_Channel + 28) = 255; + } + } + }; + + auto Correct_Extended_Command = [&]() -> void + { + if (*(__int32*)((unsigned __int32)Network_Channel + 16) != -1) + { + Extended_Command->Extra_Commands += Accumulative_Correction; + + Accumulative_Correction = 0; + } + + Extended_Command->Sequence_Shift = Initial_Extended_Command->Sequence_Shift; + }; + + if (*(__int32*)((unsigned __int32)Local_Player + 228) == 3) + { + if (*(__int8*)((unsigned __int32)Local_Player + 7322) == 0) + { + if (*(void**)((unsigned __int32)Local_Player + 10008) == INVALID_HANDLE_VALUE) + { + if ((*(void**)((unsigned __int32)Local_Player + 10012) != INVALID_HANDLE_VALUE) + (*(void**)((unsigned __int32)Local_Player + 10024) != INVALID_HANDLE_VALUE) + (*(void**)((unsigned __int32)Local_Player + 10056) != INVALID_HANDLE_VALUE) != 0) + { + Command->Buttons |= (*(void**)((unsigned __int32)Local_Player + 10056) != INVALID_HANDLE_VALUE) * 2; + + Disable_Clock_Correction(Interface_Extra_Commands_Action.Integer); + } + } + else + { + Sequence_Shift(2); + } + } + else + { + if (*(__int32*)((unsigned __int32)Local_Player + 7324) == 0) + { + Sequence_Shift(-2); + } + } + + Correct_Extended_Command(); + } + else + { + __int8 Action = *(void**)((unsigned __int32)Local_Player + 7076) == *(void**)((unsigned __int32)Local_Player + 376); + + __int8 Reviving = *(void**)((unsigned __int32)Local_Player + 8076) != INVALID_HANDLE_VALUE; + + if ((*(float*)((unsigned __int32)Local_Player + 4604) + 800.f * Global_Variables->Interval_Per_Tick >= 560.f) + *(__int8*)((unsigned __int32)Local_Player + 8068) + *(__int8*)((unsigned __int32)Local_Player + 9708) != 0) + { + Sequence_Shift(2); + } + else + { + if (Action + Reviving != 0) + { + Disable_Clock_Correction(Interface_Extra_Commands_Action.Integer); + } + } + + Correct_Extended_Command(); + + *(__int32*)((unsigned __int32)Local_Player + 5620) = Command->Command_Number; + + void* Prediction = (void*)((unsigned __int32)Client_Module + 8072728); + + *(__int8*)((unsigned __int32)Prediction + 8) = 1; + + *(__int8*)((unsigned __int32)Prediction + 24) = 0; + + using Set_Host_Type = void(__thiscall*)(void* Move_Helper, void* Player); + + Set_Host_Type((unsigned __int32)Client_Module + 1331216)((void*)((unsigned __int32)Client_Module + 7174888), Local_Player); + + Redirected_Run_Command(Prediction, Local_Player, Command, (void*)((unsigned __int32)Client_Module + 7174888)); + + Set_Host_Type((unsigned __int32)Client_Module + 1331216)((void*)((unsigned __int32)Client_Module + 7174888), nullptr); + + *(__int8*)((unsigned __int32)Prediction + 8) = 0; + + __int32 Block_Buttons = 2049; + + if ((*(__int32*)((unsigned __int32)Local_Player + 324) & 9) == 0) + { + if ((*(__int32*)((unsigned __int32)Local_Player + 5020) & 32) * (Action ^ 1) == 0) + { + using Can_Attack_Type = __int8(__thiscall*)(void* Player); + + if (Can_Attack_Type((unsigned __int32)Client_Module + 2541696)(Local_Player) == 1) + { + using Get_Weapon_Type = void*(__thiscall*)(void* Entity); + + void* Weapon = *(__int8*)((unsigned __int32)Local_Player + 7867) == 0 ? Get_Weapon_Type((unsigned __int32)Client_Module + 74304)(Local_Player) : nullptr; + + if (Weapon == nullptr) + { + Block_Buttons = 2048; + } + else + { + __int8 Cancelable_Shove = 1 + (*(float*)((unsigned __int32)Local_Player + 7336) < Global_Variables->Time) * (*(float*)((unsigned __int32)Weapon + 2404) <= Global_Variables->Time); + + __int32 Weapon_Identifier = Get_Identifier(Weapon, 1, 0); + + if ((Weapon_Identifier == 105) + (Weapon_Identifier == 121) == 0) + { + static std::unordered_set<__int32> Grenades = { 106, 118, 129 }; + + if (Grenades.contains(Weapon_Identifier) == 1) + { + Cancelable_Shove = min((*(__int16*)((unsigned __int32)Weapon + 3304) == 0) + (*(float*)((unsigned __int32)Weapon + 3308) == 0.f), Cancelable_Shove); + } + } + else + { + Cancelable_Shove = min(1 + (*(float*)((unsigned __int32)Weapon + 3312) == -1.f), Cancelable_Shove); + } + + __int8 In_Shove = Global_Variables->Time >= *(float*)((unsigned __int32)Local_Player + 7904); + + if (Global_Variables->Time >= *(float*)((unsigned __int32)Weapon + 2704)) + { + In_Shove = *(__int8*)((unsigned __int32)Weapon + 2720); + } + + __int32 Ammo = *(__int32*)((unsigned __int32)Weapon + 2436); + + static void* Predicted_Shot; + + using Get_Weapon_Data_Type = void*(__thiscall*)(void* Weapon); + + void* Weapon_Data = Get_Weapon_Data_Type((unsigned __int32)Client_Module + 86432)(Weapon); + + __int8 Is_Melee = *(__int32*)((unsigned __int32)Weapon_Data + 352) * (*(__int32*)((unsigned __int32)Weapon_Data + 348) ^ 1) <= 1; + + __int8 Reloading = *(__int8*)((unsigned __int32)Weapon + 2493); + + __int8 Can_Attack = 0; + + if (Weapon_Identifier == 39) + { + Can_Attack = (min(Chainsaw_Cycles * 0.46153846f * Global_Variables->Interval_Per_Tick, 1.f) > 0.95f) * (In_Shove ^ 1); + } + else + { + Can_Attack = (*(float*)((unsigned __int32)Weapon + 2400) <= Global_Variables->Time) * (Ammo > 0 - Is_Melee * 2) * (Reloading ^ 1); + + if ((*(double*)((unsigned __int32)Weapon + 3392) == 0.) * Weapon_Identifier == 153) + { + Can_Attack *= *(float*)((unsigned __int32)Weapon + 3400) <= Global_Variables->Time; + } + } + + __int32 Entity_Number = 1; + + using Get_Interpolation_Time_Type = float(__cdecl*)(); + + float Interpolation_Time = Get_Interpolation_Time_Type((unsigned __int32)Engine_Module + 594000)(); + + Sorted_Target_List.clear(); + + auto Get_Target_Time = [&](Target_Structure* Target) -> float + { + if (Interface_Target_On_Simulation.Integer == 0) + { + return *(float*)((unsigned __int32)Local_Player + 336); + } + + return *(float*)((unsigned __int32)Target->Self + 336); + }; + + Traverse_Entity_List_Label: + { + void* Entity = *(void**)((unsigned __int32)Client_Module + 7644532 + ((Entity_Number - 4097) << 4)); + + if (Entity != nullptr) + { + if (Entity != Local_Player) + { + __int32 Identifier = Get_Identifier(Entity, 0, 0); + + if (Identifier != -1) + { + if (*(__int32*)((unsigned __int32)Entity + 228) % 2 != *(__int32*)((unsigned __int32)Local_Player + 228) % 2) + { + float* Local_Origin = (float*)((unsigned __int32)Local_Player + 292); + + float* Entity_Origin = (float*)((unsigned __int32)Entity + 292); + + float Time = *(float*)((unsigned __int32)Entity + 336) + Interpolation_Time; + + Target_Structure Target = + { + Identifier, + + Entity, + + (__int8)(Identifier == 270 ? *(void**)((unsigned __int32)Entity + 8040) == *(void**)((unsigned __int32)Local_Player + 376) : 0), + + __builtin_powf(Local_Origin[0] - Entity_Origin[0], 2.f) + __builtin_powf(Local_Origin[1] - Entity_Origin[1], 2.f) + __builtin_powf(Local_Origin[2] - Entity_Origin[2], 2.f), + + (__int32)(Time / Global_Variables->Interval_Per_Tick + 0.5f) + }; + + if (*(float*)((unsigned __int32)Entity + 16) != Get_Target_Time(&Target)) + { + if (Identifier == 277) + { + if (*(float*)((unsigned __int32)Entity + 4844) == 1.f) + { + Sorted_Target_List.push_back(Target); + } + } + else + { + Sorted_Target_List.push_back(Target); + } + } + } + } + } + } + + if (Entity_Number != *(__int32*)((unsigned __int32)Client_Module + 7644568)) + { + Entity_Number += 1; + + goto Traverse_Entity_List_Label; + } + } + + auto Target_List_Sort = [](Target_Structure& X, Target_Structure& Y) -> __int8 + { + if (X.Priority == Y.Priority) + { + return X.Distance < Y.Distance; + } + + return X.Priority > Y.Priority; + }; + + std::sort(Sorted_Target_List.begin(), Sorted_Target_List.end(), Target_List_Sort); + + size_t Target_Number = 0; + + using Get_Eye_Position_Type = void(__thiscall*)(void* Entity, float* Eye_Position); + + float Eye_Position[3]; + + Get_Eye_Position_Type((unsigned __int32)Client_Module + 108512)(Local_Player, Eye_Position); + + Target_Structure* Shove_Target = nullptr; + + if (Cancelable_Shove + In_Shove > 1) + { + if (*(__int8*)((unsigned __int32)Local_Player + 8070) * (Weapon_Identifier == 231) == 0) + { + if (Interface_Shotgun_Shove.Integer == 1) + { + if ((Weapon_Identifier - 148) % 14 == 0) + { + if ((void*)((unsigned __int32)Weapon + Ammo) == Predicted_Shot) + { + Predicted_Shot = nullptr; + + Command->Buttons |= 2048; + + Block_Buttons = 1; + } + } + } + + __int8 Is_Chainsaw = Weapon_Identifier == 39; + + __int8 Holstering = 0; + + if (Is_Chainsaw == 0) + { + using Get_Sequence_Duration_Type = float(__thiscall*)(void* Entity, void* Studio_Header, __int32 Sequence); + + using Select_Sequence_Type = __int32(__thiscall*)(void* Entity, __int32 Activity); + + using Translate_Activity_Type = __int32(__thiscall**)(void* Weapon, __int32 Activity); + + using Get_Deploy_Activity_Type = __int32(__thiscall**)(void* Weapon); + + Holstering = (min(*(float*)((unsigned __int32)Local_Player + 3872), *(float*)((unsigned __int32)Weapon + 2412)) + Get_Sequence_Duration_Type((unsigned __int32)Client_Module + 180400)(Weapon, Get_Studio_Header(Weapon), Select_Sequence_Type((unsigned __int32)Client_Module + 202896)(Weapon, (*Translate_Activity_Type(*(unsigned __int32*)Weapon + 1692))(Weapon, (*Get_Deploy_Activity_Type(*(unsigned __int32*)Weapon + 1600))(Weapon)))) > Global_Variables->Time) * (Can_Attack ^ 1); + } + else + { + Is_Chainsaw = Can_Attack * (Command->Buttons & 1); + } + + Shove_Traverse_Sorted_Target_List_Label: + { + if (Target_Number != Sorted_Target_List.size()) + { + Target_Structure* Target = &Sorted_Target_List.at(Target_Number); + + __int8 Forced = 0; + + if (((Command->Buttons & 2048) + Reloading + Holstering + Is_Melee * (Is_Chainsaw ^ 1)) * (Action + Reviving ^ 1) != 0) + { + if ((Target->Identifier ^ 72) % 348 >= 72) + { + Forced = 1; + + goto Shove_Label; + } + } + + if ((270 - Target->Identifier ^ Target->Identifier - 263) >= 0) + { + Shove_Label: + { + __int8 Infected = (Target->Identifier == 264) * (Forced ^ 1); + + __int32 Gender = *(__int32*)((unsigned __int32)Target->Self + 52); + + if ((Infected ^ 1) + (Gender == 15) != 0) + { + if (__builtin_strstr(Get_Sequence_Name(Target->Self), "hove") == nullptr) + { + using Perform_Shove_Trace = __int8(__thiscall*)(void* Weapon, float* Direction); + + float* Target_Origin = Get_Center(Target->Self); + + float Direction[3] = + { + Target_Origin[0] - Eye_Position[0], + + Target_Origin[1] - Eye_Position[1], + + Target_Origin[2] - Eye_Position[2] + }; + + Vector_Normalize(Direction); + + *(float*)((unsigned __int32)Weapon + 2724) = 75.f; + + *(__int32*)((unsigned __int32)Weapon + 3248) = 0; + + Perform_Trace_Target = Target->Self; + + Perform_Trace_Damage = 0.f; + + Perform_Shove_Trace((unsigned __int32)Client_Module + 3220512)(Weapon, Direction); + + Perform_Trace_Target = nullptr; + + if (Perform_Trace_Damage == 1.f) + { + if (Action == 0) + { + Command->Tick_Number = Target->Tick_Number; + + Command->Angles[0] = __builtin_atan2f(-Direction[2], __builtin_hypotf(Direction[0], Direction[1])) * 180.f / 3.1415927f; + + Command->Angles[1] = __builtin_atan2f(Direction[1], Direction[0]) * 180.f / 3.1415927f; + + if (Cancelable_Shove == 1) + { + float Shove_Multiplier = min((Global_Variables->Time - *(float*)((unsigned __int32)Weapon + 2704) + *(float*)((unsigned __int32)Weapon + 2700)) / *(float*)((unsigned __int32)Weapon + 2700), 1.f); + + Command->Angles[1] += -45.f * Shove_Multiplier + 45.f * (1.f - Shove_Multiplier); + } + else + { + Command->Angles[1] += 45.f; + } + + Command->Buttons |= 2048; + + Block_Buttons = 1; + + Cancelable_Shove = (Gender * Interface_Riot_Deprioritize.Integer * (Forced ^ 1)) == 15; + + *(float*)((unsigned __int32)Target->Self + 16) = Get_Target_Time(Target); + + goto Shove_Found_Target_Label; + } + + Cancelable_Shove = 0; + + goto Shove_Found_Target_Label; + } + } + } + } + } + + Target_Number += 1; + + goto Shove_Traverse_Sorted_Target_List_Label; + + Shove_Found_Target_Label: + { + Shove_Target = Target; + } + } + } + } + } + + if (Cancelable_Shove != 0) + { + if (Reviving + (Can_Attack ^ 1) == 0) + { + Target_Structure* Aim_Target = nullptr; + + if (Is_Melee == 0) + { + __int8 Compensate_Burst = 0; + + if (Weapon_Identifier == 2) + { + Command->Command_Number = -2134739495; + + Command->Random_Seed = 11144000; + } + else + { + if (Weapon_Identifier == 148) + { + Command->Command_Number = -2139542887; + + Command->Random_Seed = 1246243990; + } + else + { + if (Weapon_Identifier == 153) + { + Compensate_Burst = *(double*)((unsigned __int32)Weapon + 3392) != 0.; + + Command->Buttons |= Compensate_Burst; + } + else + { + if ((163 - Weapon_Identifier ^ Weapon_Identifier - 162) == 1) + { + Command->Command_Number = -2139097805; + + Command->Random_Seed = 494641349; + } + } + } + } + + if (Compensate_Burst == 0) + { + using Update_Spread_Type = void(__thiscall*)(void* Weapon); + + Update_Spread_Type((unsigned __int32)Client_Module + 3197648)(Weapon); + } + + Target_Number = 0; + + Aim_Traverse_Sorted_Target_List_Label: + { + if (Target_Number != Sorted_Target_List.size()) + { + Target_Structure* Target = &Sorted_Target_List.at(Target_Number); + + float Bones[128][3][4]; + + void* Hitbox_Set = Get_Hitbox_Set(Target, Bones, Global_Variables->Time); + + if (Hitbox_Set != nullptr) + { + auto Perform_Trace = [&](float* Angles) -> __int8 + { + using Fire_Bullet_Type = void(__thiscall*)(void* Player, float X, float Y, float Z, float* Angles, __int32 Identifier, void* Unknown_Parameter); + + __int32 Bullets = *(__int32*)((unsigned __int32)Weapon_Data + 2520); + + if (Interface_Penetration_Damage.Floating_Point == 0.f) + { + *(__int32*)((unsigned __int32)Weapon_Data + 2520) = 1; + } + + Perform_Trace_Target = Target->Self; + + Perform_Trace_Damage = 0.f; + + void* Previous_Audio_Device = *(void**)((unsigned __int32)Engine_Module + 5050008); + + *(void**)((unsigned __int32)Engine_Module + 5050008) = nullptr; + + *(__int32*)((unsigned __int32)Client_Module + 7075944) = Command->Random_Seed; + + *(__int32*)((unsigned __int32)Client_Module + 7683464) = 1; + + *(__int32*)((unsigned __int32)Client_Module + 7689576) = 0; + + *(__int32*)((unsigned __int32)Client_Module + 8175320) = 0; + + *(__int32*)((unsigned __int32)Client_Module + 8175392) = 0; + + using Get_Weapon_Identifier_Type = __int32(__thiscall**)(void* Weapon); + + Fire_Bullet_Type((unsigned __int32)Client_Module + 3103776)(Local_Player, Eye_Position[0], Eye_Position[1], Eye_Position[2], Angles, (*Get_Weapon_Identifier_Type(*(unsigned __int32*)Weapon + 1532))(Weapon), nullptr); + + *(__int32*)((unsigned __int32)Client_Module + 8175392) = 1; + + *(__int32*)((unsigned __int32)Client_Module + 8175320) = 1; + + *(__int32*)((unsigned __int32)Client_Module + 7689576) = 1; + + *(__int32*)((unsigned __int32)Client_Module + 7683464) = 0; + + *(void**)((unsigned __int32)Engine_Module + 5050008) = Previous_Audio_Device; + + Perform_Trace_Target = nullptr; + + *(__int32*)((unsigned __int32)Weapon_Data + 2520) = Bullets; + + return (Perform_Trace_Damage >= Interface_Penetration_Damage.Floating_Point) * (Perform_Trace_Damage != 0.f); + }; + + static std::unordered_map<__int32, __int32> Hitboxes = + { + { 0, 10 }, + + { 13, 0 }, + + { 99, 9 }, + + { 263, 10 }, + + { 264, 15 }, + + { 265, 4 }, + + { 270, 10 }, + + { 272, 4 }, + + { 276, 12 }, + + { 277, 10 } + }; + + void* Hitbox = (void*)((unsigned __int32)Hitbox_Set + 12 + Hitboxes[Target->Identifier] * 68); + + if (*(__int32*)Hitbox < sizeof(Bones) / sizeof(Bones[0])) + { + float* Hitbox_Minimum = (float*)((unsigned __int32)Hitbox + 8); + + float* Hitbox_Maximum = (float*)((unsigned __int32)Hitbox + 20); + + float Hitbox_Center[3] + { + (Hitbox_Minimum[0] + Hitbox_Maximum[0]) / 2.f, + + (Hitbox_Minimum[1] + Hitbox_Maximum[1]) / 2.f, + + (Hitbox_Minimum[2] + Hitbox_Maximum[2]) / 2.f + }; + + float Target_Origin[3] = + { + Bones[*(__int32*)Hitbox][0][0] * Hitbox_Center[0] + Bones[*(__int32*)Hitbox][0][1] * Hitbox_Center[1] + Bones[*(__int32*)Hitbox][0][2] * Hitbox_Center[2] + Bones[*(__int32*)Hitbox][0][3], + + Bones[*(__int32*)Hitbox][1][0] * Hitbox_Center[0] + Bones[*(__int32*)Hitbox][1][1] * Hitbox_Center[1] + Bones[*(__int32*)Hitbox][1][2] * Hitbox_Center[2] + Bones[*(__int32*)Hitbox][1][3], + + Bones[*(__int32*)Hitbox][2][0] * Hitbox_Center[0] + Bones[*(__int32*)Hitbox][2][1] * Hitbox_Center[1] + Bones[*(__int32*)Hitbox][2][2] * Hitbox_Center[2] + Bones[*(__int32*)Hitbox][2][3] + }; + + float Direction[3] = + { + Target_Origin[0] - Eye_Position[0], + + Target_Origin[1] - Eye_Position[1], + + Target_Origin[2] - Eye_Position[2] + }; + + Vector_Normalize(Direction); + + float Angles[3] = + { + __builtin_atan2f(-Direction[2], __builtin_hypotf(Direction[0], Direction[1])) * 180.f / 3.1415927f, + + __builtin_atan2f(Direction[1], Direction[0]) * 180.f / 3.1415927f + }; + + if (Perform_Trace(Angles) == 1) + { + Command->Tick_Number = Target->Tick_Number; + + Byte_Manager::Copy_Bytes(1, Command->Angles, sizeof(Angles), Angles); + + Command->Buttons |= 1; + + *(float*)((unsigned __int32)Target->Self + 16) = Get_Target_Time(Target); + + goto Aim_Found_Target_Label; + } + } + } + + Target_Number += 1; + + goto Aim_Traverse_Sorted_Target_List_Label; + + Aim_Found_Target_Label: + { + Aim_Target = Target; + } + } + } + } + + if ((Command->Buttons & 1) == 1) + { + if (Shove_Target != nullptr) + { + *(float*)((unsigned __int32)Shove_Target->Self + 16) = 0.f; + + if (Aim_Target != nullptr) + { + *(float*)((unsigned __int32)Aim_Target->Self + 16) = Get_Target_Time(Aim_Target); + } + } + + if (Is_Melee == 0) + { + *(__int32*)((unsigned __int32)Client_Module + 7075944) = Command->Random_Seed; + + using Random_Type = float(__cdecl*)(char* Name, float Minimum, float Maximum, void* Unknown_Parameter); + + float Maximum_Spread = *(float*)((unsigned __int32)Weapon + 3340); + + float* Recoil = (float*)((unsigned __int32)Local_Player + 4612); + + Command->Angles[0] -= Random_Type((unsigned __int32)Client_Module + 1756592)((char*)"CTerrorGun::FireBullet HorizSpread", -Maximum_Spread, Maximum_Spread, nullptr) + Recoil[0]; + + Command->Angles[1] -= Random_Type((unsigned __int32)Client_Module + 1756592)((char*)"CTerrorGun::FireBullet VertSpread", -Maximum_Spread, Maximum_Spread, nullptr) + Recoil[1]; + + Command->Angles[2] -= Recoil[2]; + } + + Predicted_Shot = (void*)((unsigned __int32)Weapon + Ammo - 1); + + Block_Buttons = 2048; + } + } + + if (Block_Buttons == 2049) + { + Block_Buttons = 2048 * (Cancelable_Shove == 1) + (Can_Attack ^ 1); + } + } + } + } + } + } + + Command->Buttons &= ~Block_Buttons; + + Byte_Manager::Copy_Bytes(1, Command->Move, sizeof(Previous_Move), Previous_Move); + + Correct_Movement(); + + *(__int8*)((unsigned __int32)__builtin_frame_address(0) + 235) = max(Extra_Commands <= 0, *(__int32*)((unsigned __int32)Network_Channel + 16) == -1); + } + } + + Command->Buttons &= ~524288; + + (decltype(&Redirected_Copy_Command)(Original_Copy_Command_Caller))(Unknown_Parameter, Command); +} \ No newline at end of file diff --git a/Storm-master/Draw_Crosshair.hpp b/Storm-master/Draw_Crosshair.hpp new file mode 100644 index 0000000..f6695d2 --- /dev/null +++ b/Storm-master/Draw_Crosshair.hpp @@ -0,0 +1,71 @@ +void Redirected_Draw_Crosshair() +{ + static float Rotation_Angle; + + auto Draw_Storm = [&](__int32 X, __int32 Y, __int32 Additional_Rotation_Angle) + { + using Set_Color_Type = void(__thiscall**)(void* Surface, unsigned __int8 Red, unsigned __int8 Green, unsigned __int8 Blue, unsigned __int8 Alpha); + + void* Surface = *(void**)((unsigned __int32)Client_Module + 8960244); + + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, 0, 0, 0, 255); + + using Draw_Circle_Type = void(__thiscall**)(void* Surface, __int32 X, __int32 Y, __int32 Radius, __int32 Segments); + + X += Interface_Storm_Rotation_Radius.Integer * __builtin_cosf(__builtin_remainderf(Rotation_Angle + Additional_Rotation_Angle, 360.f) * 3.1415927f / 180.f); + + Y += Interface_Storm_Rotation_Radius.Integer * __builtin_sinf(__builtin_remainderf(Rotation_Angle + Additional_Rotation_Angle, 360.f) * 3.1415927f / 180.f); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X - 1, Y, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X, Y - 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X + 1, Y, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X, Y + 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X - 1, Y - 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X + 1, Y - 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X - 1, Y + 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X + 1, Y + 1, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, 0, 128, 255, 255); + + (*Draw_Circle_Type(*(unsigned __int32*)Surface + 384))(Surface, X, Y, Interface_Storm_Radius.Integer, Interface_Storm_Segments.Integer); + }; + + __int32 Storm_Number = 0; + + using Get_Screen_Size_Type = __int32(__cdecl*)(__int32* Width, __int32* Height); + + __int32 Screen_Width; + + __int32 Screen_Height; + + Get_Screen_Size_Type((unsigned __int32)Client_Module + 1780352)(&Screen_Width, &Screen_Height); + + Screen_Width /= 2; + + Screen_Height /= 2; + + Draw_Storm_Label: + { + if (Storm_Number < Interface_Storm_Iterations.Integer) + { + Draw_Storm(Screen_Width, Screen_Height, Storm_Number * 360 / Interface_Storm_Iterations.Integer); + + Storm_Number += 1; + + goto Draw_Storm_Label; + } + } + + Rotation_Angle = __builtin_remainderf(Rotation_Angle + (*(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744))->Frame_Time * Interface_Storm_Speed.Integer, 360.f); + + using Get_Display_Type = void*(__cdecl*)(); + + *(__int32*)((unsigned __int32)Get_Display_Type((unsigned __int32)Client_Module + 2930128)() + 400) = 0; +} \ No newline at end of file diff --git a/Storm-master/Draw_Effect.hpp b/Storm-master/Draw_Effect.hpp new file mode 100644 index 0000000..dd47902 --- /dev/null +++ b/Storm-master/Draw_Effect.hpp @@ -0,0 +1,13 @@ +void* Original_Draw_Effect_Caller; + +__int8 __thiscall Redirected_Draw_Effect(void* Effect, void* Unknown_Parameter_1, void* Unknown_Parameter_2) +{ + using Get_Effect_Name_Type = char*(__thiscall*)(void* Effect); + + if (__builtin_strstr(Get_Effect_Name_Type((unsigned __int32)Client_Module + 1423136)((void*)((unsigned __int32)Effect - 8)), "ecloud_ca") == nullptr) + { + return (decltype(&Redirected_Draw_Effect)(Original_Draw_Effect_Caller))(Effect, Unknown_Parameter_1, Unknown_Parameter_2); + } + + return 0; +} \ No newline at end of file diff --git a/Storm-master/Entry_Point.cpp b/Storm-master/Entry_Point.cpp new file mode 100644 index 0000000..357be32 --- /dev/null +++ b/Storm-master/Entry_Point.cpp @@ -0,0 +1,290 @@ +#include + +#include + +#include "Byte_Manager/Byte_Manager.hpp" + +#include "Redirection_Manager/Redirection_Manager.hpp" + +void* Engine_Module; + +#include "Extended_Interface.hpp" + +void* Client_Module; + +#include "Post_Network_Data_Received.hpp" + +#include "Set_Move_Type.hpp" + +#include "Interpolate.hpp" + +#include "Update_Animations.hpp" + +#include "Estimate_Velocity.hpp" + +#include "Spawn_Grenade.hpp" + +#include "Update.hpp" + +#include "Run_Command.hpp" + +#include "Process_Movement.hpp" + +#include "Play_Footstep_Sound.hpp" + +#include "Finish_Move.hpp" + +#include "Item_Post_Frame.hpp" + +#include "Perform_Trace.hpp" + +#include "Perform_Shove_Trace.hpp" + +#include "Read_Packets.hpp" + +#include "Move.hpp" + +#include "Send_Move.hpp" + +#include "Copy_Command.hpp" + +#include "Calculate_View.hpp" + +#include "Draw_Effect.hpp" + +#include "Write_Texture.hpp" + +#include "Paint.hpp" + +#include "Get_Glow_Color.hpp" + +#include "Draw_Crosshair.hpp" + +__int32 __stdcall DllMain(HMODULE This_Module, unsigned __int32 Call_Reason, void* Reserved) +{ + if (Call_Reason == DLL_PROCESS_DETACH) + { + __fastfail(EXIT_SUCCESS); + } + else + { + if (Call_Reason == DLL_PROCESS_ATTACH) + { + if (GetModuleHandleW(L"left4dead2.exe") == nullptr) + { + void* Snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); + + PROCESSENTRY32W Snapshot_Entry; + + Snapshot_Entry.dwSize = sizeof(Snapshot_Entry); + + Traverse_Snapshot_Label: + { + if (Process32NextW(Snapshot, &Snapshot_Entry) == 0) + { + return 1; + } + + if (wcscmp(Snapshot_Entry.szExeFile, L"left4dead2.exe") != 0) + { + goto Traverse_Snapshot_Label; + } + } + + void* Process = OpenProcess(PROCESS_ALL_ACCESS, 0, Snapshot_Entry.th32ProcessID); + + void* Remote_Path = VirtualAllocEx(Process, nullptr, 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + + wchar_t Local_Path[MAX_PATH]; + + GetModuleFileNameW(This_Module, Local_Path, sizeof(Local_Path)); + + WriteProcessMemory(Process, Remote_Path, Local_Path, sizeof(Local_Path), nullptr); + + WaitForSingleObject(CreateRemoteThread(Process, nullptr, 0, (LPTHREAD_START_ROUTINE)LoadLibraryW, Remote_Path, 0, nullptr), INFINITE); + + VirtualFreeEx(Process, Remote_Path, 0, MEM_RELEASE); + } + else + { + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)LoadLibraryW(L"vaudio_speex.dll") + 9440), 1, 195); + + AllocConsole(); + + SetConsoleTitleW(L"Storm"); + + _wfreopen(L"CONOUT$", L"w", stdout); + + SetConsoleOutputCP(65001); + + HANDLE Standard_Output_Handle = GetStdHandle(STD_OUTPUT_HANDLE); + + CONSOLE_FONT_INFOEX Console_Font_Information = { sizeof(CONSOLE_FONT_INFOEX), 0, { 0, 12 }, FF_DONTCARE, FW_NORMAL, { L"Terminal" } }; + + SetCurrentConsoleFontEx(Standard_Output_Handle, 0, &Console_Font_Information); + + CONSOLE_CURSOR_INFO Console_Cursor_Information = { sizeof(Console_Cursor_Information) }; + + SetConsoleTextAttribute(Standard_Output_Handle, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_BLUE); + + SetConsoleCursorInfo(Standard_Output_Handle, &Console_Cursor_Information); + + CONSOLE_SCREEN_BUFFER_INFO Console_Screen_Buffer_Information; + + GetConsoleScreenBufferInfo(Standard_Output_Handle, &Console_Screen_Buffer_Information); + + COORD Top_Left = { }; + + DWORD Characters_Written; + + FillConsoleOutputAttribute(Standard_Output_Handle, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_BLUE, Console_Screen_Buffer_Information.dwSize.X * Console_Screen_Buffer_Information.dwSize.Y, Top_Left, &Characters_Written); + + Engine_Module = GetModuleHandleW(L"engine.dll"); + + _putws(L"[ + ] Delimit Interface"); + { + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Engine_Module + 1423205), 1, 235); + } + + _putws(L"[ + ] Extend Interface"); + { + Implement_Extended_Interface(); + } + + Client_Module = GetModuleHandleW(L"client.dll"); + + _putws(L"[ + ] Events"); + { + Original_Post_Network_Data_Received_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 1555264), (void*)Redirected_Post_Network_Data_Received); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 316816), 1, 195); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Engine_Module + 350575), 1, 94); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Engine_Module + 521741), 1, 235); + + *(void**)((unsigned __int32)Client_Module + 7492840) = (void*)Redirected_Set_Move_Type; + } + + _putws(L"[ + ] Interpolation"); + { + Original_Interpolate_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 214256), (void*)Redirected_Interpolate); + } + + _putws(L"[ + ] Animations"); + { + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Client_Module + 205296), (void*)Redirected_Update_Animations); + + Original_Estimate_Velocity_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 311856), (void*)Redirected_Estimate_Velocity); + + unsigned __int8 Maintain_Sequence_Transitions_Bytes[3] = { 194, 24 }; + + Byte_Manager::Copy_Bytes(0, (void*)((unsigned __int32)Client_Module + 245232), sizeof(Maintain_Sequence_Transitions_Bytes), Maintain_Sequence_Transitions_Bytes); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 3244278), 1, 15); + } + + _putws(L"[ + ] Prediction"); + { + static Prediction_Descriptor_Structure Original_Prediction_Descriptor; + + Prediction_Descriptor_Structure* Prediction_Descriptor = (Prediction_Descriptor_Structure*)((unsigned __int32)Client_Module + 7290836); + + Byte_Manager::Copy_Bytes(0, &Original_Prediction_Descriptor, sizeof(Prediction_Descriptor_Structure), Prediction_Descriptor); + + static Prediction_Field_Structure Prediction_Fields = { 1, (char*)"m_fMaxSpread", 3340, 1, { }, sizeof(float) }; + + Prediction_Descriptor->Fields = &Prediction_Fields; + + Prediction_Descriptor->Size = sizeof(Prediction_Fields) / sizeof(Prediction_Field_Structure); + + Prediction_Descriptor->Parent = &Original_Prediction_Descriptor; + + Original_Spawn_Grenade_Caller = Redirection_Manager::Redirect_Function(2, (void*)((unsigned __int32)Client_Module + 2227424), (void*)Redirected_Spawn_Grenade); + + Original_Update_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 1554304), (void*)Redirected_Update); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 1554528), 1, 235); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 1557776), 1, 235); + + Original_Run_Command_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 1553504), (void*)Redirected_Run_Command); + + Original_Process_Movement_Caller = Redirection_Manager::Redirect_Function(2, (void*)((unsigned __int32)Client_Module + 2590832), (void*)Redirected_Process_Movement); + + Original_Play_Footstep_Sound_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 978528), (void*)Redirected_Play_Footstep_Sound); + + Original_Finish_Move_Caller = Redirection_Manager::Redirect_Function(2, (void*)((unsigned __int32)Client_Module + 1553264), (void*)Redirected_Finish_Move); + + Original_Item_Post_Frame_Caller = Redirection_Manager::Redirect_Function(3, (void*)((unsigned __int32)Client_Module + 2542896), (void*)Redirected_Item_Post_Frame); + + *(__int32*)((unsigned __int32)Original_Item_Post_Frame_Caller + 5) = (__int32)((unsigned __int32)Client_Module + 2438551) - (__int32)Original_Item_Post_Frame_Caller; + + Original_Perform_Trace_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 3093744), (void*)Redirected_Perform_Trace); + + Original_Perform_Shove_Trace_Caller = (void*)((unsigned __int32)Client_Module + 3221111); + + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Client_Module + 3221102), (void*)Redirected_Perform_Shove_Trace); + } + + _putws(L"[ + ] Network"); + { + Original_Read_Packets_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Engine_Module + 499264), (void*)Redirected_Read_Packets); + + Original_Move_Caller = Redirection_Manager::Redirect_Function(3, (void*)((unsigned __int32)Engine_Module + 512288), (void*)Redirected_Move); + + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Engine_Module + 511680), (void*)Redirected_Send_Move); + } + + _putws(L"[ + ] Input"); + { + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 1250661), 3, 144); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 417204), 1, 235); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 2538675), 1, 255); + + Original_Copy_Command_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 1094672), (void*)Redirected_Copy_Command); + } + + _putws(L"[ + ] Effects"); + { + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 407384), 1, 133); + + Original_Calculate_View_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 132944), (void*)Redirected_Calculate_View); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 133424), 1, 235); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 2881566), 1, 246); + + Original_Draw_Effect_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)Client_Module + 1425904), (void*)Redirected_Draw_Effect); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 1868237), 1, 52); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 2655546), 1, 216); + + *(void**)((unsigned __int32)Client_Module + 8115120) = (void*)((unsigned __int32)Client_Module + 0xE956C); + } + + _putws(L"[ + ] Paint"); + { + Original_Write_Texture_Caller = Redirection_Manager::Redirect_Function(0, (void*)((unsigned __int32)GetModuleHandleW(L"vguimatsurface.dll") + 100592), (void*)Redirected_Write_Texture); + + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Client_Module + 2913504), (void*)Redirected_Paint); + + Original_Get_Glow_Color_Caller = Redirection_Manager::Redirect_Function(1, (void*)((unsigned __int32)Client_Module + 2455600), (void*)Redirected_Get_Glow_Color); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 3244715), 1, 49); + + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Client_Module + 2301184), (void*)Redirected_Draw_Crosshair); + + Byte_Manager::Set_Bytes(0, (void*)((unsigned __int32)Client_Module + 2930985), 1, 235); + + Redirection_Manager::Redirect_Function((void*)((unsigned __int32)Client_Module + 3118720), (void*)Redirected_Draw_Crosshair); + } + } + } + } + + return 1; +} \ No newline at end of file diff --git a/Storm-master/Estimate_Velocity.hpp b/Storm-master/Estimate_Velocity.hpp new file mode 100644 index 0000000..c90d3dd --- /dev/null +++ b/Storm-master/Estimate_Velocity.hpp @@ -0,0 +1,131 @@ +char* Get_Sequence_Name(void* Entity) +{ + using Get_Sequence_Name_Type = char*(__thiscall*)(void* Entity, __int32 Sequence); + + return Get_Sequence_Name_Type((unsigned __int32)Client_Module + 203392)(Entity, *(__int32*)((unsigned __int32)Entity + 2212)); +} + +__int32 Get_Identifier(void* Entity, __int8 Raw, __int8 Equipment) +{ + using Get_Identifier_Type = void*(__cdecl**)(); + + __int32 Identifier = *(__int32*)((unsigned __int32)(*Get_Identifier_Type(*(unsigned __int32*)((unsigned __int32)Entity + 8) + 4))() + 20); + + if (Raw == 1) + { + return Identifier; + } + + if (*(__int8*)((unsigned __int32)Entity + 221) == 0) + { + static std::unordered_set<__int32> Targets = { 0, 13, 99, 232, 263, 264, 265, 270, 272, 275, 276, 277 }; + + if (Targets.contains(Identifier) == 1) + { + __int8 Valid = 0; + + if (Identifier == 13) + { + *(__int32*)((unsigned __int32)Entity + 228) = 1; + + Valid = *(__int8*)((unsigned __int32)Entity + 324) == 5; + } + else + { + if ((*(__int32*)((unsigned __int32)Entity + 572) - 131088 & 255) == 0) + { + if (__builtin_strstr(Get_Sequence_Name(Entity), "eath") == nullptr) + { + Valid = Identifier == 264 ? *(__int8*)((unsigned __int32)Entity + 4493) ^ 1 : 1; + } + } + } + + if (Valid == 1) + { + if (Identifier * (*(__int32*)((unsigned __int32)Entity + 228) == 3) == 232) + { + static std::unordered_map<__int32, __int32> Translators = + { + { 1, 270 }, + + { 2, 0 }, + + { 3, 263 }, + + { 4, 272 }, + + { 5, 265 }, + + { 6, 99 }, + + { 8, 276 } + }; + + Identifier = Translators[*(__int32*)((unsigned __int32)Entity + 7312)]; + } + + return (Identifier - 232) % 43 ? Identifier : 232; + } + } + else + { + if (Equipment == 1) + { + if ((*(__int32*)((unsigned __int32)Entity + 224) & 32) == 0) + { + static std::unordered_set<__int32> Equipment_List = { 73, 105, 109, 121, 256, 260 }; + + if (Equipment_List.contains(Identifier) == 1) + { + if (Identifier == 260) + { + static std::unordered_map<__int32, __int32> Translators = + { + { 12, 73 }, + + { 15, 121 }, + + { 23, 105 }, + + { 24, 109 } + }; + + Identifier = Translators[*(__int32*)((unsigned __int32)Entity + 2392)]; + } + + if (Identifier != 0) + { + if (*(void**)((unsigned __int32)Entity + 312) == INVALID_HANDLE_VALUE) + { + return -Identifier; + } + } + } + } + } + } + } + + return -1; +} + +void* Original_Estimate_Velocity_Caller; + +void __thiscall Redirected_Estimate_Velocity(void* Entity, float* Velocity) +{ + static std::unordered_set<__int32> Invalids = { 264, 277 }; + + if (Invalids.contains(Get_Identifier(Entity, 1, 0)) == 1) + { + (decltype(&Redirected_Estimate_Velocity)(Original_Estimate_Velocity_Caller))(Entity, Velocity); + } + else + { + using Calculate_Velocity_Type = void(__thiscall*)(void* Entity); + + Calculate_Velocity_Type((unsigned __int32)Client_Module + 290704)(Entity); + + Byte_Manager::Copy_Bytes(1, Velocity, sizeof(float[3]), (float*)((unsigned __int32)Entity + 136)); + } +} \ No newline at end of file diff --git a/Storm-master/Extended_Interface.hpp b/Storm-master/Extended_Interface.hpp new file mode 100644 index 0000000..481fb29 --- /dev/null +++ b/Storm-master/Extended_Interface.hpp @@ -0,0 +1,86 @@ +struct Interface_Structure +{ + __int8 Additional_Bytes_1[44]; + + float Floating_Point; + + __int32 Integer; + + __int8 Additional_Bytes_3[20]; +}; + +Interface_Structure Interface_Extra_Commands; + +Interface_Structure Interface_Extra_Commands_Action; + +Interface_Structure Interface_Interpolate_Extra_Commands; + +Interface_Structure Interface_Target_On_Simulation; + +Interface_Structure Interface_Shotgun_Shove; + +Interface_Structure Interface_Riot_Deprioritize; + +Interface_Structure Interface_Penetrate_Teammates; + +Interface_Structure Interface_Aim_Intersection; + +Interface_Structure Interface_Penetration_Damage; + +Interface_Structure Interface_Equipment_Distance; + +Interface_Structure Interface_Storm_Rotation_Radius; + +Interface_Structure Interface_Storm_Radius; + +Interface_Structure Interface_Storm_Segments; + +Interface_Structure Interface_Storm_Iterations; + +Interface_Structure Interface_Storm_Speed; + +void Implement_Extended_Interface() +{ + auto Create_Interface = [](Interface_Structure* Interface, char* Name, char* Value, void* Handler) + { + using Create_Variable_Type = void(__thiscall*)(Interface_Structure* Interface, char* Name, char* Value, void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Handler); + + Create_Variable_Type((unsigned __int32)Engine_Module + 0x283B30)(Interface, Name, Value, nullptr, nullptr, Handler); + + *(__int32*)((unsigned __int32)Interface + 20) &= ~10; + + wprintf(L"[ + ] %hs -> %p\n", Name, Interface); + }; + + #define Pointer_Name(Interface) &Interface, (char*)#Interface + 10 + + Create_Interface(Pointer_Name(Interface_Extra_Commands), (char*)"5", nullptr); + + Create_Interface(Pointer_Name(Interface_Extra_Commands_Action), (char*)"10", nullptr); + + Create_Interface(Pointer_Name(Interface_Interpolate_Extra_Commands), (char*)"1", nullptr); + + Create_Interface(Pointer_Name(Interface_Target_On_Simulation), (char*)"0", nullptr); + + Create_Interface(Pointer_Name(Interface_Shotgun_Shove), (char*)"1", nullptr); + + Create_Interface(Pointer_Name(Interface_Riot_Deprioritize), (char*)"0", nullptr); + + Create_Interface(Pointer_Name(Interface_Penetrate_Teammates), (char*)"0", nullptr); + + Create_Interface(Pointer_Name(Interface_Aim_Intersection), (char*)"1", nullptr); + + Create_Interface(Pointer_Name(Interface_Penetration_Damage), (char*)"12", nullptr); + + Create_Interface(Pointer_Name(Interface_Equipment_Distance), (char*)"2048", nullptr); + + Create_Interface(Pointer_Name(Interface_Storm_Rotation_Radius), (char*)"24", nullptr); + + Create_Interface(Pointer_Name(Interface_Storm_Radius), (char*)"8", nullptr); + + Create_Interface(Pointer_Name(Interface_Storm_Segments), (char*)"12", nullptr); + + Create_Interface(Pointer_Name(Interface_Storm_Iterations), (char*)"16", nullptr); + + Create_Interface(Pointer_Name(Interface_Storm_Speed), (char*)"512", nullptr); +} \ No newline at end of file diff --git a/Storm-master/Finish_Move.hpp b/Storm-master/Finish_Move.hpp new file mode 100644 index 0000000..8289a2e --- /dev/null +++ b/Storm-master/Finish_Move.hpp @@ -0,0 +1,15 @@ +void* Original_Finish_Move_Caller; + +void __thiscall Redirected_Finish_Move(void* Unknown_Parameter_1, void* Player, void* Unknown_Parameter_2, void* Move_Data) +{ + float X = *(float*)((unsigned __int32)Move_Data + 76); + + if (X > 180.f) + { + X -= 360.f; + } + + *(float*)((unsigned __int32)Move_Data + 76) = std::clamp(X, -90.f, 90.f); + + (decltype(&Redirected_Finish_Move)(Original_Finish_Move_Caller))(Unknown_Parameter_1, Player, Unknown_Parameter_2, Move_Data); +} \ No newline at end of file diff --git a/Storm-master/Get_Glow_Color.hpp b/Storm-master/Get_Glow_Color.hpp new file mode 100644 index 0000000..5ad9f3e --- /dev/null +++ b/Storm-master/Get_Glow_Color.hpp @@ -0,0 +1,9 @@ +void* Original_Get_Glow_Color_Caller; + +void __thiscall Redirected_Get_Glow_Color(void* Entity, void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Unknown_Parameter_3, void* Unknown_Parameter_4) +{ + if (Get_Identifier(Entity, 0, 0) == -1) + { + (decltype(&Redirected_Get_Glow_Color)(Original_Get_Glow_Color_Caller))(Entity, Unknown_Parameter_1, Unknown_Parameter_2, Unknown_Parameter_3, Unknown_Parameter_4); + } +} \ No newline at end of file diff --git a/Storm-master/Interpolate.hpp b/Storm-master/Interpolate.hpp new file mode 100644 index 0000000..71e5235 --- /dev/null +++ b/Storm-master/Interpolate.hpp @@ -0,0 +1,11 @@ +void* Original_Interpolate_Caller; + +__int8 __thiscall Redirected_Interpolate(void* Entity, void* Unknown_Parameter) +{ + if (Entity == *(void**)((unsigned __int32)Client_Module + 7498712)) + { + return (decltype(&Redirected_Interpolate)(Original_Interpolate_Caller))(Entity, Unknown_Parameter); + } + + return 1; +} \ No newline at end of file diff --git a/Storm-master/Item_Post_Frame.hpp b/Storm-master/Item_Post_Frame.hpp new file mode 100644 index 0000000..365e8be --- /dev/null +++ b/Storm-master/Item_Post_Frame.hpp @@ -0,0 +1,9 @@ +void* Original_Item_Post_Frame_Caller; + +void __thiscall Redirected_Item_Post_Frame(void* Player) +{ + if (*(void**)((unsigned __int32)__builtin_frame_address(0) + 88) == (void*)((unsigned __int32)Client_Module + 423107)) + { + (decltype(&Redirected_Item_Post_Frame)(Original_Item_Post_Frame_Caller))(Player); + } +} \ No newline at end of file diff --git a/Storm-master/Move.hpp b/Storm-master/Move.hpp new file mode 100644 index 0000000..afd74db --- /dev/null +++ b/Storm-master/Move.hpp @@ -0,0 +1,62 @@ +__int32 Extra_Commands; + +__int32 Chainsaw_Cycles; + +void* Original_Move_Caller; + +void Redirected_Move(float Unknown_Parameter, __int8 Final) +{ + void* Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + using Run_Prediction_Type = void(__cdecl*)(); + + if (Local_Player != nullptr) + { + Redirected_Read_Packets(Final); + + Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + Run_Prediction_Type((unsigned __int32)Engine_Module + 527776)(); + + Redirected_Update_Animations(); + + using Fire_Events_Type = void(__cdecl*)(); + + Fire_Events_Type((unsigned __int32)Engine_Module + 521648)(); + + Update_Animation_Time = (*(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744))->Time; + + Update_Animation_Type = 1; + + Redirected_Update_Animations(); + + Update_Animation_Type = 0; + } + + Extra_Commands = -1; + + Move_Label: + { + (decltype(&Redirected_Move)(Original_Move_Caller))(Unknown_Parameter, Final); + + Run_Prediction_Type((unsigned __int32)Engine_Module + 527776)(); + + if (Local_Player != nullptr) + { + Chainsaw_Cycles += 1 + (Chainsaw_Cycles == 0); + + static float Deploy_Time; + + Chainsaw_Cycles *= *(float*)((unsigned __int32)Local_Player + 3872) == Deploy_Time; + + Deploy_Time = *(float*)((unsigned __int32)Local_Player + 3872); + } + + if (Extra_Commands > 0) + { + Extra_Commands -= 1; + + goto Move_Label; + } + } +} \ No newline at end of file diff --git a/Storm-master/Paint.hpp b/Storm-master/Paint.hpp new file mode 100644 index 0000000..3c297f8 --- /dev/null +++ b/Storm-master/Paint.hpp @@ -0,0 +1,397 @@ +void __thiscall Redirected_Paint(void* Panel) +{ + using Set_Order_Type = void(__thiscall*)(void* Panel, __int32 Order); + + Set_Order_Type((unsigned __int32)Client_Module + 4082160)(Panel, -1); + + __int32 Entity_Number = 1; + + void* Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + Sorted_Target_List.clear(); + + Traverse_Entity_List_Label: + { + void* Entity = *(void**)((unsigned __int32)Client_Module + 7644532 + ((Entity_Number - 4097) << 4)); + + if (Entity != nullptr) + { + if (Entity != Local_Player) + { + __int32 Identifier = Get_Identifier(Entity, 0, 1); + + if (Identifier != -1) + { + using Get_Origin_Type = float*(__thiscall*)(void* Entity); + + float* Local_Origin = Get_Origin_Type((unsigned __int32)Client_Module + 297584)(Local_Player); + + float* Entity_Origin = Get_Origin_Type((unsigned __int32)Client_Module + 297584)(Entity); + + Target_Structure Target = + { + __builtin_abs(Identifier), + + Entity, + + 0, + + __builtin_powf(Local_Origin[0] - Entity_Origin[0], 2.f) + __builtin_powf(Local_Origin[1] - Entity_Origin[1], 2.f) + __builtin_powf(Local_Origin[2] - Entity_Origin[2], 2.f) + }; + + if (Identifier >= 0) + { + Sorted_Target_List.push_back(Target); + } + else + { + if (__builtin_sqrtf(Target.Distance) <= Interface_Equipment_Distance.Floating_Point) + { + Sorted_Target_List.push_back(Target); + } + } + } + } + } + + if (Entity_Number != *(__int32*)((unsigned __int32)Client_Module + 7644568)) + { + Entity_Number += 1; + + goto Traverse_Entity_List_Label; + } + } + + auto Target_List_Sort = [](Target_Structure& X, Target_Structure& Y) -> __int8 + { + return X.Distance < Y.Distance; + }; + + std::sort(Sorted_Target_List.begin(), Sorted_Target_List.end(), Target_List_Sort); + + size_t Target_Number = Sorted_Target_List.size() - 1; + + Traverse_Sorted_Target_List_Label: + { + if (Target_Number != -1) + { + Target_Structure* Target = &Sorted_Target_List.at(Target_Number); + + float Bounds[4] = { __builtin_inff(), -__builtin_inff(), __builtin_inff(), -__builtin_inff() }; + + auto Get_Bounds = [&]() -> __int8 + { + float Bones[128][3][4]; + + void* Hitbox_Set = Get_Hitbox_Set(Target, Bones, (*(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744))->Time); + + if (Hitbox_Set != nullptr) + { + __int32 Hitbox_Number = 0; + + Get_Bounds_Label: + { + if (Hitbox_Number != *(__int32*)((unsigned __int32)Hitbox_Set + 4)) + { + void* Hitbox = (void*)((unsigned __int32)Hitbox_Set + 12 + Hitbox_Number * 68); + + if (*(__int32*)Hitbox < sizeof(Bones) / sizeof(Bones[0])) + { + float* Hitbox_Minimum = (float*)((unsigned __int32)Hitbox + 8); + + float* Hitbox_Maximum = (float*)((unsigned __int32)Hitbox + 20); + + float Hitbox_Vertices[8][3]; + + __int32 Axis_Number = 0; + + Initialize_Vertices_Label: + { + Hitbox_Vertices[0][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Minimum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Minimum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Minimum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[1][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Maximum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Minimum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Minimum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[2][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Minimum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Maximum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Minimum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[3][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Minimum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Minimum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Maximum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[4][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Maximum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Maximum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Minimum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[5][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Maximum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Minimum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Maximum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[6][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Minimum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Maximum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Maximum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Hitbox_Vertices[7][Axis_Number] = Bones[*(__int32*)Hitbox][Axis_Number][0] * Hitbox_Maximum[0] + Bones[*(__int32*)Hitbox][Axis_Number][1] * Hitbox_Maximum[1] + Bones[*(__int32*)Hitbox][Axis_Number][2] * Hitbox_Maximum[2] + Bones[*(__int32*)Hitbox][Axis_Number][3]; + + Axis_Number += 1; + + if (Axis_Number != sizeof(Hitbox_Vertices[0]) / sizeof(float)) + { + goto Initialize_Vertices_Label; + } + } + + __int32 Vertex_Number = 0; + + Transform_Vertices_Label: + { + using Screen_Transform_Type = __int8(__cdecl*)(float* World, float* Screen); + + float Screen[3]; + + if (Screen_Transform_Type((unsigned __int32)Client_Module + 1841648)(Hitbox_Vertices[Vertex_Number], Screen) == 0) + { + using Get_Screen_Size_Type = __int32(__cdecl*)(); + + __int32 Screen_Width = Get_Screen_Size_Type((unsigned __int32)Client_Module + 738576)(); + + __int32 Screen_Height = Get_Screen_Size_Type((unsigned __int32)Client_Module + 738544)(); + + Screen[0] = Screen[0] / 2.f * Screen_Width + Screen_Width / 2.f; + + Screen[1] = -Screen[1] / 2.f * Screen_Height + Screen_Height / 2.f; + + Bounds[0] = min(Bounds[0], Screen[0]); + + Bounds[1] = max(Bounds[1], Screen[0]); + + Bounds[2] = min(Bounds[2], Screen[1]); + + Bounds[3] = max(Bounds[3], Screen[1]); + } + else + { + return 0; + } + + Vertex_Number += 1; + + if (Vertex_Number != sizeof(Hitbox_Vertices) / sizeof(Hitbox_Vertices[0])) + { + goto Transform_Vertices_Label; + } + } + + Hitbox_Number += 1; + + goto Get_Bounds_Label; + } + } + } + + Bounds[0] -= 2.f; + + Bounds[1] += 2.f; + + Bounds[2] -= 2.f; + + Bounds[3] += 2.f; + } + + return __builtin_isfinite(Bounds[0]) * (Bounds[1] != 2.f) * (Bounds[3] != 2.f); + }; + + if (Get_Bounds() == 1) + { + void* Surface = *(void**)((unsigned __int32)Client_Module + 8960244); + + struct Paint_Data_Structure + { + unsigned __int8 Color[3]; + + wchar_t* Name; + }; + + static std::unordered_map<__int32, Paint_Data_Structure> Paint_Data_List = + { + { 0, { { 255, 128, 0 }, (wchar_t*)L"Boomer" } }, + + { 13, { { 0, 128, 255 }, (wchar_t*)L"Rock" } }, + + { 73, { { 255, 255, 255 }, (wchar_t*)L"Aid" } }, + + { 99, { { 255, 128, 0 }, (wchar_t*)L"Charger" } }, + + { 105, { { 255, 255, 255 }, (wchar_t*)L"Adrenaline" } }, + + { 109, { { 255, 255, 255 }, (wchar_t*)L"Defibrillator" } }, + + { 121, { { 255, 255, 255 }, (wchar_t*)L"Pain" } }, + + { 232, { { 0, 255, 0 } } }, + + { 256, { { 255, 255, 255 }, (wchar_t*)L"Ammo" } }, + + { 263, { { 255, 128, 0 }, (wchar_t*)L"Hunter" } }, + + { 264, { { 255, 0, 0 }, (wchar_t*)L"Infected" } }, + + { 265, { { 255, 128, 0 }, (wchar_t*)L"Jockey" } }, + + { 270, { { 255, 128, 0 }, (wchar_t*)L"Smoker" } }, + + { 272, { { 255, 128, 0 }, (wchar_t*)L"Spitter" } }, + + { 276, { { 0, 128, 255 }, (wchar_t*)L"Tank" } }, + + { 277, { { 0, 128, 255 }, (wchar_t*)L"Witch" } } + }; + + Paint_Data_Structure* Paint_Data = &Paint_Data_List[Target->Identifier]; + + if (Target->Identifier == 232) + { + static wchar_t* Survivors[8] = { (wchar_t*)L"Nick", (wchar_t*)L"Rochelle", (wchar_t*)L"Coach", (wchar_t*)L"Ellis", (wchar_t*)L"Bill", (wchar_t*)L"Zoey", (wchar_t*)L"Louis", (wchar_t*)L"Francis" }; + + Paint_Data->Name = Survivors[std::clamp(*(__int32*)((unsigned __int32)Target->Self + 7308), 0, 7) + 4 * (*(__int32*)((unsigned __int32)Client_Module + 8144624) == 1)]; + } + + __int8 Ghost = 0; + + if (*(__int32*)((unsigned __int32)Target->Self + 236) != 0) + { + Ghost = *(__int8*)((unsigned __int32)Target->Self + 7322); + } + + auto Draw_Box = [&](__int32 From_X, __int32 From_Y, __int32 To_X, __int32 To_Y) -> void + { + using Set_Color_Type = void(__thiscall**)(void* Surface, unsigned __int8 Red, unsigned __int8 Green, unsigned __int8 Blue, unsigned __int8 Alpha); + + if (Ghost == 0) + { + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, (__int32)(Paint_Data->Color[0] / 2.f + 0.5f), (__int32)(Paint_Data->Color[1] / 2.f + 0.5f), (__int32)(Paint_Data->Color[2] / 2.f + 0.5f), 128); + } + else + { + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, 64, 64, 64, 128); + } + + using Draw_Filled_Rect_Type = void(__thiscall**)(void* Surface, __int32 From_X, __int32 From_Y, __int32 To_X, __int32 To_Y); + + (*Draw_Filled_Rect_Type(*(unsigned __int32*)Surface + 48))(Surface, From_X + 2, From_Y + 2, To_X - 2, To_Y - 2); + + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, 0, 0, 0, 255); + + using Draw_Rect_Type = void(__thiscall**)(void* Surface, __int32 From_X, __int32 From_Y, __int32 To_X, __int32 To_Y); + + (*Draw_Rect_Type(*(unsigned __int32*)Surface + 56))(Surface, From_X - 1, From_Y - 1, To_X + 1, To_Y + 1); + + (*Draw_Rect_Type(*(unsigned __int32*)Surface + 56))(Surface, From_X + 1, From_Y + 1, To_X - 1, To_Y - 1); + + if (Ghost == 0) + { + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, Paint_Data->Color[0], Paint_Data->Color[1], Paint_Data->Color[2], 255); + } + else + { + (*Set_Color_Type(*(unsigned __int32*)Surface + 44))(Surface, 128, 128, 128, 255); + } + + (*Draw_Rect_Type(*(unsigned __int32*)Surface + 56))(Surface, From_X, From_Y, To_X, To_Y); + }; + + Draw_Box(Bounds[0], Bounds[2], Bounds[1], Bounds[3]); + + using Draw_Text_Type = void(__cdecl*)(void* Font, __int32 X, __int32 Y, __int32 Red, __int32 Green, __int32 Blue, __int32 Alpha, wchar_t* Text); + + auto Create_Font = [&]() -> void* + { + using Create_Font_Type = void*(__thiscall**)(void* Surface); + + void* Font = (*Create_Font_Type(*(unsigned __int32*)Surface + 252))(Surface); + + using Setup_Font_Type = __int8(__thiscall**)(void* Surface, void* Font, char* Name, void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Unknown_Parameter_3, void* Unknown_Parameter_4, __int32 Flags, void* Unknown_Parameter_5, void* Unknown_Parameter_6); + + (*Setup_Font_Type(*(unsigned __int32*)Surface + 256))(Surface, Font, (char*)"Fixedsys", nullptr, nullptr, nullptr, nullptr, 512, nullptr, nullptr); + + wchar_t Character = L' '; + + Calculate_Character_Bounds_Label: + { + wchar_t Text[2] = { Character }; + + Write_Character = Text[0]; + + Draw_Text_Type((unsigned __int32)Engine_Module + 2219008)(Font, 0, 0, 0, 0, 0, 0, Text); + + Write_Character = 0; + + if (Character != L'~') + { + Character += L'\1'; + + goto Calculate_Character_Bounds_Label; + } + } + + return Font; + }; + + static void* Font = Create_Font(); + + size_t Character_Number = 0; + + unsigned __int32 Width = 0; + + unsigned __int32 Height = 0; + + __int32 Offset_Y = 0; + + size_t Characters_Count = wcslen(Paint_Data->Name); + + Calculate_Text_Bounds_Label: + { + unsigned __int32* Character_Bounds = Characters_Bounds[Paint_Data->Name[Character_Number]]; + + Width += Character_Bounds[1] + 1; + + Height = max(Height, Character_Bounds[3]); + + Offset_Y = max(Offset_Y, 3 - (__int32)Character_Bounds[2]); + + Character_Number += 1; + + if (Character_Number != Characters_Count) + { + goto Calculate_Text_Bounds_Label; + } + + Draw_Box(Bounds[1] + 3, Bounds[2], Bounds[1] + 8 + Width, Bounds[2] + Height + Offset_Y + 3); + + Character_Number = 0; + + __int32 Offset_X = 0; + + Draw_Character_Label: + { + Character_Bounds = Characters_Bounds[Paint_Data->Name[Character_Number]]; + + wchar_t Text[2] = { Paint_Data->Name[Character_Number] }; + + if (Ghost == 0) + { + Draw_Text_Type((unsigned __int32)Engine_Module + 2219008)(Font, Bounds[1] + 7 + Offset_X - Character_Bounds[0], Bounds[2] + Offset_Y, Paint_Data->Color[0], Paint_Data->Color[1], Paint_Data->Color[2], 255, Text); + } + else + { + Draw_Text_Type((unsigned __int32)Engine_Module + 2219008)(Font, Bounds[1] + 7 + Offset_X - Character_Bounds[0], Bounds[2] + Offset_Y, 128, 128, 128, 255, Text); + } + + Offset_X += Character_Bounds[1] + 1; + + Character_Number += 1; + + if (Character_Number != Characters_Count) + { + goto Draw_Character_Label; + } + } + } + } + + Target_Number -= 1; + + goto Traverse_Sorted_Target_List_Label; + } + } +} \ No newline at end of file diff --git a/Storm-master/Perform_Shove_Trace.hpp b/Storm-master/Perform_Shove_Trace.hpp new file mode 100644 index 0000000..67ae52e --- /dev/null +++ b/Storm-master/Perform_Shove_Trace.hpp @@ -0,0 +1,21 @@ +void __thiscall Perform_Shove_Trace(void* Stack) +{ + if (*(void**)((unsigned __int32)Stack + 332) == Perform_Trace_Target) + { + Perform_Trace_Damage = 1.f; + } +} + +void* Original_Perform_Shove_Trace_Caller; + +__attribute__((naked)) void Redirected_Perform_Shove_Trace() +{ + asm("leal -304(%ebp), %eax"); + asm("pushl %eax"); + asm("calll *%edx"); + asm("pushal"); + asm("movl %esp, %ecx"); + asm("calll %0" : : "m"(Perform_Shove_Trace)); + asm("popal"); + asm("jmpl *%0" : : "m"(Original_Perform_Shove_Trace_Caller)); +} \ No newline at end of file diff --git a/Storm-master/Perform_Trace.hpp b/Storm-master/Perform_Trace.hpp new file mode 100644 index 0000000..5569887 --- /dev/null +++ b/Storm-master/Perform_Trace.hpp @@ -0,0 +1,341 @@ +void* Perform_Trace_Target; + +float* Get_Center(void* Entity) +{ + using Get_Center_Type = float*(__thiscall*)(void* Entity); + + return Get_Center_Type((unsigned __int32)Client_Module + 114400)(Entity); +} + +float Perform_Trace_Damage; + +float Vector_Normalize(float* Vector) +{ + using Vector_Normalize_Type = float(__thiscall*)(float* Vector); + + return Vector_Normalize_Type((unsigned __int32)Client_Module + 3536192)(Vector); +}; + +void Angle_Vectors(float* Angles, float* Forward, float* Right, float* Up) +{ + using Angle_Vectors_Type = void(__cdecl*)(float* Angles, float* Forward, float* Right, float* Up); + + Angle_Vectors_Type((unsigned __int32)Client_Module + 3539392)(Angles, Forward, Right, Up); +}; + +void __thiscall Perform_Trace(void* Stack) +{ + void* Entity = *(void**)((unsigned __int32)Stack + 312); + + __int32 Identifier = Get_Identifier(Entity, 0, 0); + + if (Interface_Penetrate_Teammates.Integer == 0) + { + if (Identifier == 232) + { + void* Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + if (*(__int32*)((unsigned __int32)Entity + 228) == *(__int32*)((unsigned __int32)Local_Player + 228)) + { + Perform_Trace_Target = nullptr; + + Perform_Trace_Damage = 0.f; + + return; + } + } + } + + if (Entity == Perform_Trace_Target) + { + __int32 Group = *(__int32*)((unsigned __int32)Stack + 304); + + if (Interface_Aim_Intersection.Integer == 0) + { + if (Group != 1) + { + return; + } + } + + void* Trace_Information = *(void**)((unsigned __int32)Stack + 36); + + void* Weapon_Data = *(void**)((unsigned __int32)Trace_Information + 4); + + float* End = (float*)((unsigned __int32)Stack + 248); + + __int32 Upgrade_Type = (*(__int32*)((unsigned __int32)Trace_Information + 36) & 255) % 5; + + __int32 Gender = *(__int32*)((unsigned __int32)Entity + 52); + + auto Compute_Damage = [&]() -> void + { + if (Interface_Penetration_Damage.Floating_Point == 0.f) + { + Perform_Trace_Damage = 1.f; + } + else + { + float* Start = (float*)((unsigned __int32)Stack + 236); + + float Distance = __builtin_sqrtf(__builtin_powf(End[0] - Start[0], 2.f) + __builtin_powf(End[1] - Start[1], 2.f) + __builtin_powf(End[2] - Start[2], 2.f)); + + float Damage; + + static void* Calculate_Damage = (void*)((unsigned __int32)GetModuleHandleW(L"server.dll") + 3950592); + { + asm("movl %0, %%esi" : : "m"(Weapon_Data) : "esi"); + asm("subl $16, %esp"); + asm("movss %0, %%xmm0" : : "m"(Distance) : "esp"); + asm("movdqu %xmm0, (%esp)"); + asm("calll *%0" : : "m"(Calculate_Damage) : "eax", "ecx", "edx"); + asm("movd %%xmm0, %0" : "=m"(Damage)); + asm("addl $16, %esp"); + } + + __int32 Bullet_Type = *(__int32*)((unsigned __int32)Weapon_Data + 2128); + + __int8 Is_Shotgun = (Bullet_Type ^ 12) % 7 == 4; + + if (Upgrade_Type * Is_Shotgun == 1) + { + Damage *= *(__int32*)((unsigned __int32)Weapon_Data + 2520); + } + + auto Apply_Difficulty_Scaling = [&]() -> void + { + using Get_Difficulty_Type = __int32(__cdecl*)(); + + static float Multipliers[3] = { 0.8f, 0.7f, 0.6f }; + + Damage *= Multipliers[Get_Difficulty_Type((unsigned __int32)Client_Module + 2650448)()]; + }; + + char* Mode = *(char**)((unsigned __int32)Client_Module + 8145092); + + __int8 Realism = Mode[0] == 'r'; + + auto Apply_Shotgun_Scaling = [&]() -> void + { + if (Is_Shotgun == 1) + { + __int8 Hardcore = Realism; + + if (__builtin_strlen(Mode) > 8) + { + Hardcore = (Mode[8] == '8') + (Mode[9] == '2'); + } + + if (Hardcore == 0) + { + using Get_Bounds_Type = void(__thiscall*)(void* Collision, float* Start, float* Bounds); + + void* Local_Player = *(void**)Trace_Information; + + float Bounds[3]; + + Get_Bounds_Type((unsigned __int32)Client_Module + 878608)((void*)((unsigned __int32)Entity + 540), Get_Center(Local_Player), Bounds); + + using Calculate_Distance_Type = float(__thiscall*)(void* Collision, float* Bounds); + + float Distance = Calculate_Distance_Type((unsigned __int32)Client_Module + 878688)((void*)((unsigned __int32)Local_Player + 540), Bounds); + + if (Distance < 100.f) + { + Damage += 4.f * Damage * __builtin_powf(1.f - Distance / 100.f, 2.f); + } + } + } + }; + + if (Identifier == 13) + { + Damage *= *(float*)((unsigned __int32)Entity + 336) - *(float*)((unsigned __int32)Entity + 472) >= 0.5f; + } + else + { + if (Identifier == 264) + { + if ((Upgrade_Type == 1) + (Bullet_Type == 6)) + { + Damage = __builtin_inff(); + } + else + { + Apply_Shotgun_Scaling(); + + __int8 Is_Sniper_Rifle = Bullet_Type > 8; + + if (Group == 1) + { + if (Gender == 14) + { + static std::unordered_set<__int32> Neutrals = { 563, 567, 592, 600, 648 }; + + if (Neutrals.contains(*(__int32*)((unsigned __int32)Entity + 4688)) == 1) + { + Damage = __builtin_inff(); + } + } + else + { + if (Gender != 17) + { + Damage = __builtin_inff(); + } + } + } + else + { + if (Group * (Gender != 14) * (Gender != 17) * Is_Shotgun == 3) + { + Damage = __builtin_inff(); + } + else + { + Apply_Difficulty_Scaling(); + + if ((Bullet_Type == 2) + Is_Sniper_Rifle != 0) + { + if (Gender == 14) + { + if (Is_Sniper_Rifle * Realism == 0) + { + Damage = 450.f; + } + } + else + { + Damage = __builtin_inff(); + } + } + } + } + } + } + else + { + if (Identifier == 277) + { + if (Group != 1) + { + Apply_Difficulty_Scaling(); + } + + Apply_Shotgun_Scaling(); + } + else + { + if (Identifier + Bullet_Type == 284) + { + Damage *= 0.85f; + } + + if ((Identifier != 276) + (Upgrade_Type != 1) == 2) + { + static float Multipliers[8] = { 1.f, 4.f, 1.f, 1.25f, 1.f, 1.f, 0.75f, 0.75f }; + + Damage *= min(Multipliers[Group], 4.f - 2.75f * Is_Shotgun); + } + + __int32 Raw_Identifier = Get_Identifier(Entity, 1, 0); + + if (Raw_Identifier == 99) + { + if (*(__int32*)((unsigned __int32)Entity + 2212) == 5) + { + Damage *= 1.f / 3.f; + } + } + else + { + if (Identifier * Group == 270) + { + if (*(void**)((unsigned __int32)Entity + 8040) != INVALID_HANDLE_VALUE) + { + if (Damage > 50.f) + { + __int8 Competitive = ('v' - Mode[0] ^ Mode[0] - 's') == 3; + + if (__builtin_strlen(Mode) > 8) + { + Competitive = Mode[9] == '8'; + } + + if (Competitive == 0) + { + Damage = __builtin_inff(); + } + } + } + } + } + + if (Damage != __builtin_inff()) + { + Damage = (__int32)(Damage + 1.f * (Damage < 1.f)); + + if (Raw_Identifier == 276) + { + if (__builtin_strstr(Get_Sequence_Name(Entity), "limb") != nullptr) + { + Damage = min(Damage, *(__int32*)((unsigned __int32)Entity + 236) - 1.f); + } + } + } + } + } + } + + Perform_Trace_Damage += Damage; + } + }; + + if ((Upgrade_Type == 2) + (Gender == 15) == 2) + { + float Inflictor_Direction[3]; + + float* Start = Get_Center(*(void**)Trace_Information); + + Inflictor_Direction[0] = End[0] - Start[0]; + + Inflictor_Direction[1] = End[1] - Start[1]; + + Inflictor_Direction[2] = End[2] - Start[2]; + + Vector_Normalize(Inflictor_Direction); + + using Get_Attachment_Type = void(__thiscall*)(void* Entity, char* Attachment, float* Origin, float* Angle); + + float Origin[3]; + + float Angle[3]; + + Get_Attachment_Type((unsigned __int32)Client_Module + 178656)(Entity, (char*)"chest", Origin, Angle); + + float Victim_Direction[3]; + + Angle_Vectors(Angle, Victim_Direction, nullptr, nullptr); + + if (Inflictor_Direction[0] * Victim_Direction[0] + Inflictor_Direction[1] * Victim_Direction[1] + Inflictor_Direction[2] * Victim_Direction[2] >= 0.f) + { + Compute_Damage(); + } + } + else + { + Compute_Damage(); + } + } +} + +void* Original_Perform_Trace_Caller; + +__attribute__((naked)) void Redirected_Perform_Trace() +{ + asm("pushal"); + asm("movl %esp, %ecx"); + asm("calll %0" : : "m"(Perform_Trace)); + asm("popal"); + asm("jmpl *%0" : : "m"(Original_Perform_Trace_Caller)); +} \ No newline at end of file diff --git a/Storm-master/Play_Footstep_Sound.hpp b/Storm-master/Play_Footstep_Sound.hpp new file mode 100644 index 0000000..3c090a0 --- /dev/null +++ b/Storm-master/Play_Footstep_Sound.hpp @@ -0,0 +1,9 @@ +void* Original_Play_Footstep_Sound_Caller; + +void __thiscall Redirected_Play_Footstep_Sound(void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Unknown_Parameter_3, void* Unknown_Parameter_4, void* Unknown_Parameter_5, void* Unknown_Parameter_6) +{ + if (*(__int8*)((unsigned __int32)Client_Module + 8072736) <= *(__int8*)((unsigned __int32)Client_Module + 8072752)) + { + (decltype(&Redirected_Play_Footstep_Sound)(Original_Play_Footstep_Sound_Caller))(Unknown_Parameter_1, Unknown_Parameter_2, Unknown_Parameter_3, Unknown_Parameter_4, Unknown_Parameter_5, Unknown_Parameter_6); + } +} \ No newline at end of file diff --git a/Storm-master/Post_Network_Data_Received.hpp b/Storm-master/Post_Network_Data_Received.hpp new file mode 100644 index 0000000..a38431d --- /dev/null +++ b/Storm-master/Post_Network_Data_Received.hpp @@ -0,0 +1,96 @@ +struct Prediction_Copy_Structure +{ + __int8 Additionals_Bytes_1[8]; + + void* Destination; + + void* Source; + + __int8 Additional_Bytes_2[48]; + + void Construct(void* Destination, void* Source, void* Handler) + { + using Construct_Type = void(__fastcall*)(void* Prediction_Copy, void* Unknown_Parameter, __int32 Type, void* Destination, __int8 Destination_Packed, void* Source, __int8 Source_Packed, __int32 Operation_Type, void* Handler); + + Construct_Type((unsigned __int32)Client_Module + 1564512)(this, nullptr, 2, Destination, 1, Source, 0, 3, Handler); + } +}; + +Prediction_Copy_Structure Predicton_Copy; + +struct Prediction_Field_Structure +{ + __int32 Type; + + char* Name; + + __int32 Offset; + + unsigned __int16 Size; + + __int8 Additionals_Bytes_1[18]; + + __int32 Bytes; + + __int8 Additionals_Bytes_2[12]; + + __int32 Flat_Offset[2]; + + __int8 Additionals_Bytes_3[2]; +}; + +__int8 Consistent_Time; + +void Predicton_Copy_Compare(void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Unknown_Parameter_3, void* Unknown_Parameter_4, void* Unknown_Parameter_5, void* Unknown_Parameter_6, __int8 Within_Tolerance, void* Unknown_Parameter_7) +{ + Prediction_Field_Structure* Field = *(Prediction_Field_Structure**)((unsigned __int32)__builtin_frame_address(0) + 60); + + if (Field->Flat_Offset[0] * Consistent_Time == 5324) + { + goto Copy_Label; + } + + if (Within_Tolerance == 1) + { + if ((256 - Field->Flat_Offset[0] ^ Field->Flat_Offset[0] - 244) != 12) + { + Copy_Label: + { + Byte_Manager::Copy_Bytes(1, (void*)((unsigned __int32)Predicton_Copy.Destination + Field->Flat_Offset[0]), Field->Bytes, (void*)((unsigned __int32)Predicton_Copy.Source + Field->Flat_Offset[1])); + } + } + } +} + +struct Prediction_Descriptor_Structure +{ + Prediction_Field_Structure* Fields; + + __int32 Size; + + __int8 Additional_Bytes_1[4]; + + Prediction_Descriptor_Structure* Parent; + + __int8 Additional_Bytes_2[8]; +}; + +void* Original_Post_Network_Data_Received_Caller; + +void __thiscall Redirected_Post_Network_Data_Received(void* Unknown_Parameter, __int32 Commands_Acknowledged) +{ + void* Local_Player = *(void**)((unsigned __int32)Client_Module + 7498712); + + void* Prediction_Frame = *(void**)((unsigned __int32)Local_Player + 900 + (150 - ((Commands_Acknowledged - 1) % 150 + 1) * 150 % -~150) * 4); + + if (Prediction_Frame != nullptr) + { + Predicton_Copy.Construct(Local_Player, Prediction_Frame, (void*)Predicton_Copy_Compare); + + using Transfer_Data_Type = __int32(__thiscall*)(Prediction_Copy_Structure* Prediction_Copy, void* Unknown_Parameter, __int32 Entity_Number, Prediction_Descriptor_Structure* Descriptor); + + Transfer_Data_Type((unsigned __int32)Client_Module + 1573744)(&Predicton_Copy, nullptr, -1, (Prediction_Descriptor_Structure*)((unsigned __int32)Client_Module + 7236480)); + } + + (decltype(&Redirected_Post_Network_Data_Received)(Original_Post_Network_Data_Received_Caller))(Unknown_Parameter, Commands_Acknowledged); +} \ No newline at end of file diff --git a/Storm-master/Process_Movement.hpp b/Storm-master/Process_Movement.hpp new file mode 100644 index 0000000..7a9e8ff --- /dev/null +++ b/Storm-master/Process_Movement.hpp @@ -0,0 +1,27 @@ +void* Original_Process_Movement_Caller; + +void __thiscall Redirected_Process_Movement(void* Unknown_Parameter, void* Player, void* Move_Data) +{ + if (*(__int32*)((unsigned __int32)Player + 5324) < 0) + { + *(__int32*)((unsigned __int32)Move_Data + 36) &= ~1564; + + *(__int32*)((unsigned __int32)Move_Data + 36) |= 4 * *(__int8*)((unsigned __int32)Player + 4636); + + *(double*)((unsigned __int32)Move_Data + 44) = 0.; + } + + (decltype(&Redirected_Process_Movement)(Original_Process_Movement_Caller))(Unknown_Parameter, Player, Move_Data); + + if (Get_Identifier(Player, 0, 0) == 272) + { + using Get_Ability_Type = void*(__thiscall*)(void* Entity); + + void* Ability = Get_Ability_Type((unsigned __int32)Client_Module + 2438560)(Player); + + if (Ability != nullptr) + { + *(float*)((unsigned __int32)Ability + 1636) = 0.f; + } + } +} \ No newline at end of file diff --git a/Storm-master/README.md b/Storm-master/README.md new file mode 100644 index 0000000..79fb924 --- /dev/null +++ b/Storm-master/README.md @@ -0,0 +1,20 @@ +to achieve least (aligned) interpolation time: `cl_updaterate 30;cl_interp_ratio 0;cl_interp 0`\ +to queue extra commands: `bind key +zoom` +``` +code: https://github.com/qwertyuiop3/Storm + +credits: +me (for something) +noop (for being helpful, specifically on debugging and reversing) +d3x (for telling me that i don't have to bruteforce prediction frame) +polak (for strafe deltas) +ucuser0 (for his post regarding backup commands) +kamay (for crossproducts of movement) +deniz (for being friend) + +songs: +david bowie - art decade +scratch acid - cannibal + +edited by "obviously who" +``` \ No newline at end of file diff --git a/Storm-master/Read_Packets.hpp b/Storm-master/Read_Packets.hpp new file mode 100644 index 0000000..81f33a4 --- /dev/null +++ b/Storm-master/Read_Packets.hpp @@ -0,0 +1,13 @@ +void* Original_Read_Packets_Caller; + +void Redirected_Read_Packets(__int8 Final) +{ + static __int8 Parsed_Packets; + + if (Parsed_Packets == 0) + { + (decltype(&Redirected_Read_Packets)(Original_Read_Packets_Caller))(Final); + } + + Parsed_Packets = __builtin_return_address(0) != (void*)((unsigned __int32)Engine_Module + 1631183); +} \ No newline at end of file diff --git a/Storm-master/Redirection_Manager/Redirection_Manager.hpp b/Storm-master/Redirection_Manager/Redirection_Manager.hpp new file mode 100644 index 0000000..f1e3265 --- /dev/null +++ b/Storm-master/Redirection_Manager/Redirection_Manager.hpp @@ -0,0 +1,30 @@ +namespace Redirection_Manager +{ + void Redirect_Function(void* Original_Function, void* Redirected_Function) + { + DWORD Previous_Access_Rights; + + VirtualProtect(Original_Function, 6, PAGE_EXECUTE_READWRITE, &Previous_Access_Rights); + + *(__int8*)Original_Function = 104; + + *(void**)((unsigned __int32)Original_Function + 1) = Redirected_Function; + + *(unsigned __int8*)((unsigned __int32)Original_Function + 5) = 195; + + VirtualProtect(Original_Function, 6, Previous_Access_Rights, &Previous_Access_Rights); + } + + void* Redirect_Function(unsigned __int32 Offset, void* Original_Function, void* Redirected_Function) + { + void* Original_Function_Caller = VirtualAlloc(nullptr, 12 + Offset, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); + + __builtin_memcpy(Original_Function_Caller, Original_Function, 6 + Offset); + + Redirect_Function((void*)((unsigned __int32)Original_Function_Caller + 6 + Offset), (void*)((unsigned __int32)Original_Function + 6 + Offset)); + + Redirect_Function(Original_Function, Redirected_Function); + + return Original_Function_Caller; + } +}; \ No newline at end of file diff --git a/Storm-master/Run_Command.hpp b/Storm-master/Run_Command.hpp new file mode 100644 index 0000000..7c0ab21 --- /dev/null +++ b/Storm-master/Run_Command.hpp @@ -0,0 +1,47 @@ +struct Command_Structure +{ + __int8 Additional_Bytes_1[4]; + + __int32 Command_Number; + + __int32 Tick_Number; + + float Angles[3]; + + float Move[3]; + + __int32 Buttons; + + __int8 Additional_Bytes_2[9]; + + __int32 Random_Seed; +}; + +struct Extended_Command_Structure +{ + __int32 Extra_Commands; + + __int32 Sequence_Shift; +}; + +Extended_Command_Structure Extended_Commands[150]; + +void* Original_Run_Command_Caller; + +void __thiscall Redirected_Run_Command(void* Prediction, void* Player, Command_Structure* Command, void* Move_Helper) +{ + Extended_Command_Structure* Extended_Command = &Extended_Commands[*(__int32*)((unsigned __int32)Player + 5620) % 150]; + + *(__int32*)((unsigned __int32)Player + 5324) -= Extended_Command->Extra_Commands + Extended_Command->Sequence_Shift; + + (decltype(&Redirected_Run_Command)(Original_Run_Command_Caller))(Prediction, Player, Command, Move_Helper); + + if (__builtin_return_address(0) == (void*)((unsigned __int32)Client_Module + 423107)) + { + *(__int32*)((unsigned __int32)Player + 5324) += Extended_Command->Sequence_Shift; + + Global_Variables_Structure* Global_Variables = *(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744); + + Global_Variables->Time = (*(__int32*)((unsigned __int32)Player + 5324) - 1) * Global_Variables->Interval_Per_Tick; + } +} \ No newline at end of file diff --git a/Storm-master/Send_Move.hpp b/Storm-master/Send_Move.hpp new file mode 100644 index 0000000..19fefa4 --- /dev/null +++ b/Storm-master/Send_Move.hpp @@ -0,0 +1,73 @@ +void Redirected_Send_Move() +{ + struct Message_Structure + { + __int8 Message[160]; + + void Construct(__int8* Data, unsigned __int32 Size) + { + Byte_Manager::Set_Bytes(1, Message, sizeof(Message), 0); + + *(void**)Message = (void*)((unsigned __int32)Engine_Module + 3501364); + + *(void**)((unsigned __int32)Message + 132) = Data; + + *(__int32*)((unsigned __int32)Message + 136) = Size; + + *(__int32*)((unsigned __int32)Message + 140) = Size * 8; + } + }; + + Message_Structure Message; + + __int8 Data[4000]; + + Message.Construct(Data, sizeof(Data)); + + void* Client = *(void**)((unsigned __int32)Engine_Module + 4352236); + + __int32 Choked_Commands = *(__int32*)((unsigned __int32)Client + 19024); + + __int32 Commands_Queue = min(Choked_Commands + 1, 15); + + *(__int32*)((unsigned __int32)&Message + 88) = Commands_Queue; + + __int32 Extra_Commands_Queue = Choked_Commands + 1 - Commands_Queue; + + __int32 Backup_Commands = min(Extra_Commands_Queue, 7); + + *(__int32*)((unsigned __int32)&Message + 84) = Backup_Commands; + + __int32 From_Command_Number = -1; + + __int32 Next_Command_Number = *(__int32*)((unsigned __int32)Client + 19020) + Choked_Commands + 2; + + __int32 To_Command_Number = Next_Command_Number - Commands_Queue - Backup_Commands; + + Write_Command_Label: + { + using Write_Command_Type = __int8(__thiscall*)(void* Client, void* Unknown_Parameter_1, void* Data, __int32 From, __int32 To, void* Unknown_Parameter_2); + + Write_Command_Type((unsigned __int32)Client_Module + 691088)(*(void**)((unsigned __int32)Engine_Module + 5171072), nullptr, (void*)((unsigned __int32)&Message + 132), From_Command_Number, To_Command_Number, nullptr); + + From_Command_Number = To_Command_Number; + + To_Command_Number += 1; + + if (To_Command_Number != Next_Command_Number) + { + goto Write_Command_Label; + } + } + + void* Network_Channel = *(void**)(*(unsigned __int32*)((unsigned __int32)Engine_Module + 4352236) + 24); + + if (*(__int32*)((unsigned __int32)Network_Channel + 16) != -1) + { + *(__int32*)((unsigned __int32)Network_Channel + 28) -= Extra_Commands_Queue; + } + + using Send_Message_Type = void(__thiscall**)(void* Network_Channel, void* Message, void* Unknown_Parameter_1, void* Unknown_Parameter_2); + + (*Send_Message_Type(*(unsigned __int32*)Network_Channel + 164))(Network_Channel, &Message, nullptr, nullptr); +} \ No newline at end of file diff --git a/Storm-master/Set_Move_Type.hpp b/Storm-master/Set_Move_Type.hpp new file mode 100644 index 0000000..0a5a512 --- /dev/null +++ b/Storm-master/Set_Move_Type.hpp @@ -0,0 +1,11 @@ +void Redirected_Set_Move_Type(void* Input, void* Output) +{ + if (*(__int8*)((unsigned __int32)Output + 324) == 0) + { + *(float*)((unsigned __int32)Output + 472) = *(float*)((unsigned __int32)Output + 336); + } + + *(__int8*)((unsigned __int32)Output + 324) = *(__int8*)((unsigned __int32)Input + 4); + + *(__int8*)((unsigned __int32)Output + 325) = 0; +} \ No newline at end of file diff --git a/Storm-master/Spawn_Grenade.hpp b/Storm-master/Spawn_Grenade.hpp new file mode 100644 index 0000000..b703db5 --- /dev/null +++ b/Storm-master/Spawn_Grenade.hpp @@ -0,0 +1,14 @@ +void* Original_Spawn_Grenade_Caller; + +void __thiscall Redirected_Spawn_Grenade(void* Entity) +{ + using Set_Size_Type = void(__thiscall*)(void* Entity, float* Minimum, float* Maximum); + + float Minimum[3] = { -16.f, -16.f, -16.f }; + + float Maximum[3] = { 16.f, 16.f, 16.f }; + + Set_Size_Type((unsigned __int32)Client_Module + 281664)(Entity, Minimum, Maximum); + + (decltype(&Redirected_Spawn_Grenade)(Original_Spawn_Grenade_Caller))(Entity); +} \ No newline at end of file diff --git a/Storm-master/Storm.vcxproj b/Storm-master/Storm.vcxproj new file mode 100644 index 0000000..a2b186a --- /dev/null +++ b/Storm-master/Storm.vcxproj @@ -0,0 +1,114 @@ + + + + + Release + Win32 + + + + 16.0 + Win32Proj + {9e56cc0a-5a40-4957-8031-ab3cc4108170} + Storm + 10.0 + + + + DynamicLibrary + false + ClangCL + true + Unicode + + + + + + + + + + + false + false + .cpl + + + false + + + + true + true + false + _CRT_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions) + true + stdcpplatest + $(ProjectDir);%(AdditionalIncludeDirectories) + None + MaxSpeed + AnySuitable + Speed + true + false + StreamingSIMDExtensions2 + Fast + /Zc:threadSafeInit- /clang:-fno-unwind-tables -Wno-microsoft-goto %(AdditionalOptions) + true + false + false + false + false + Level3 + true + __msvc_all_public_headers.hpp + + + Windows + true + true + false + %(AdditionalLibraryDirectories) + false + + + + + false + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Storm-master/Storm.vcxproj.filters b/Storm-master/Storm.vcxproj.filters new file mode 100644 index 0000000..9ac7300 --- /dev/null +++ b/Storm-master/Storm.vcxproj.filters @@ -0,0 +1,95 @@ + + + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + + + C++ + + + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + Header++ + + + \ No newline at end of file diff --git a/Storm-master/Storm.vcxproj.user b/Storm-master/Storm.vcxproj.user new file mode 100644 index 0000000..0f14913 --- /dev/null +++ b/Storm-master/Storm.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Storm-master/Update.hpp b/Storm-master/Update.hpp new file mode 100644 index 0000000..a53ff65 --- /dev/null +++ b/Storm-master/Update.hpp @@ -0,0 +1,8 @@ +void* Original_Update_Caller; + +void __thiscall Redirected_Update(void* Unknown_Parameter_1, void* Unknown_Parameter_2, void* Unknown_Parameter_3, __int32 Incoming_Sequence_Number, int Outgoing_Sequence_Number) +{ + Consistent_Time = Outgoing_Sequence_Number - Incoming_Sequence_Number > 150; + + (decltype(&Redirected_Update)(Original_Update_Caller))(Unknown_Parameter_1, Unknown_Parameter_2, Unknown_Parameter_3, Incoming_Sequence_Number, Incoming_Sequence_Number + (Outgoing_Sequence_Number - Incoming_Sequence_Number) % 150); +} \ No newline at end of file diff --git a/Storm-master/Update_Animations.hpp b/Storm-master/Update_Animations.hpp new file mode 100644 index 0000000..afa70d5 --- /dev/null +++ b/Storm-master/Update_Animations.hpp @@ -0,0 +1,58 @@ +struct Global_Variables_Structure +{ + __int8 Additional_Bytes_1[12]; + + float Time; + + float Frame_Time; + + __int8 Additional_Bytes_2[8]; + + float Interval_Per_Tick; +}; + +float Update_Animation_Time; + +__int8 Update_Animation_Type; + +void Redirected_Update_Animations() +{ + Global_Variables_Structure* Global_Variables = *(Global_Variables_Structure**)((unsigned __int32)Client_Module + 7096744); + + float Previous_Time = Global_Variables->Time; + + Global_Variables->Time = Update_Animation_Time; + + float Previous_Frame_Time = Global_Variables->Frame_Time; + + Global_Variables->Frame_Time = Global_Variables->Interval_Per_Tick * Update_Animation_Type; + + __int32 Entity_Number = 0; + + Traverse_Animation_List_Label: + { + if (Entity_Number != *(__int32*)((unsigned __int32)Client_Module + 7479624)) + { + void* Animation_List = *(void**)((unsigned __int32)Client_Module + 7479612); + + if ((*(__int8*)((unsigned __int32)Animation_List + 8 * Entity_Number + 4) & 1) != 0) + { + using Update_Animation_Type = void(__thiscall**)(void* Entity); + + void* Entity = *(void**)((unsigned __int32)Animation_List + 8 * Entity_Number); + + *(float*)((unsigned __int32)Entity + 328) = Update_Animation_Time - Global_Variables->Frame_Time; + + (*Update_Animation_Type(*(unsigned __int32*)Entity + 808))(Entity); + } + + Entity_Number += 1; + + goto Traverse_Animation_List_Label; + } + } + + Global_Variables->Frame_Time = Previous_Frame_Time; + + Global_Variables->Time = Previous_Time; +} \ No newline at end of file diff --git a/Storm-master/Write_Texture.hpp b/Storm-master/Write_Texture.hpp new file mode 100644 index 0000000..167ed60 --- /dev/null +++ b/Storm-master/Write_Texture.hpp @@ -0,0 +1,66 @@ +void* Original_Write_Texture_Caller; + +wchar_t Write_Character; + +std::unordered_map Characters_Bounds; + +void __thiscall Redirected_Write_Texture(void* Unknown_Parameter_1, void* Unknown_Parameter_2, unsigned __int32 Width, unsigned __int32 Height, void* Texture) +{ + (decltype(&Redirected_Write_Texture)(Original_Write_Texture_Caller))(Unknown_Parameter_1, Unknown_Parameter_2, Width, Height, Texture); + + if (Write_Character != 0) + { + unsigned __int32 X = 0; + + unsigned __int32 Offset_X = Width; + + unsigned __int32 Character_Width = 0; + + unsigned __int32 Offset_Y = Height; + + unsigned __int32 Character_Height = 0; + + Traverse_Horizontal_Label: + { + unsigned __int32 Y = 0; + + Traverse_Vertical_Label: + { + if (*(unsigned __int32*)((unsigned __int32)Texture + X * 4 + Y * 4 * Width) != 0) + { + Offset_X = min(X, Offset_X); + + Character_Width = max(Character_Width, X + 1); + + Offset_Y = min(Y, Offset_Y); + + Character_Height = max(Character_Height, Y + 1); + } + + Y += 1; + + if (Y != Height) + { + goto Traverse_Vertical_Label; + } + } + + X += 1; + + if (X != Width) + { + goto Traverse_Horizontal_Label; + } + } + + unsigned __int32* Character_Bounds = Characters_Bounds[Write_Character]; + + Character_Bounds[0] = Offset_X; + + Character_Bounds[1] = Character_Width - Offset_X; + + Character_Bounds[2] = Offset_Y; + + Character_Bounds[3] = Character_Height; + } +} \ No newline at end of file