Gentoo Offensive – LWSS Weblog – Basement Dweller

2023-06-03 09:39:21

100% Open Supply CS:GO


Again in late April of 2020, the supply code of CSGO and TF2 had been leaked. Since then, I’ve been working with the CSGO supply code personally on a venture that I name Kisak-Strike: Gentoo Offensive.

The Aim of Kisak-Strike is 100% open supply CS:GO from the 2017-era for perservation, fanatic use, and long run upkeep.

This weblog put up tells a tough historic story of the venture as much as at this time – in chronological order.

The Leak

(Some could find out about this half already, and may safely skip to the subsequent part)

April twenty second, 2020 – Rumor of a CSGO supply code leak spreads round varied teams. At first this was arduous to consider, however because the day progressed, a hyperlink materialized and it was clearly true.

The leaks come from a Valve fanatic youtuber referred to as the Valve Information Community(VNN). I don’t actually take care of his movies a lot, however apparently his relationship with Valve is nearer than he portrays in his movies.
VNN and his group of goons had gotten buddy-buddy sufficient with Valve to safe a Supply Engine Companion relationship, one thing fairly uncommon and usually solely given to skilled builders for video games like: Titanfall, Insurgency, Vampire: The Masquerade, and some others.

Anybody can use the Supply Engine 2013 SDK, but it surely solely accommodates headers for precompiled libraries. It isn’t attainable (with out binary hacks) to change the conduct/code of the engine as a result of the Supply Code will not be included.
A Companion relationship is extra superior and grants entry to the Supply Engine Supply.

The associate construct isn’t full nonetheless. Valve thought that leaks had been a chance so that they made positive to chop out delicate bits of data. There are additionally third social gathering libraries, like Scaleform Flash UI, the place Valve can not give out the Supply Code and as an alternative give out precompiled-blobs.

Opening the Leak

What precisely did we get within the leak? Let’s see…

There’s 2 folders to deal with – (that are initially contained in full.7z)

cstrike15_src – CSGO

hl2_src – TF2

There’s additionally an idea recreation right here known as FStop. Can’t say I used to be too all for it, however whereas eyeballing it once more for this put up, I seen it has some deferred rendering stuff in it that may very well be cool.

There’s some boring chat logs and a Dota Merchandise idea, and lastly a be aware from the leaker himself. is all the Counter Strike: World Offensive supply code as of Operation Hydra and the TF2 supply code as of Jungle Inferno.
These had been willingly held onto by a choose few of individuals, (VNN, and so on) and stored in a really small circle. It was some form of medium for them to jerk off about having secret shit
Some bizarre schizoid managed to seize each these codebases throughout his work on some 900th try of a HL2 VR venture and his main purpose was to have this circle leak it to the general public and fly to his girlfriends home (additionally concerned within the valve neighborhood) and kill himself and her. Completely fucking insane, and it is one thing to have a beer over and giggle about along with your supply modding pals
Ended up getting arrested after she fleed and cops had been known as. 
Plenty of attention-grabbing information may be gained from these two codebases alone and quite a lot of resourceful info can come of it. Go wild!


Constructing CSGO – Act I: VPC Hijinks


For Home windows customers, this half was in all probability fairly simple, there’s a .bat file to make it good and straightforward to import into Visible Studio. However sadly for Linux players like myself, issues had been a bit rigged.

First off, let’s take a look at CreateSolution.bat

devtoolsbinvpc.exe /csgo +csgo_partner /mksln csgo_partner.sln

That is the place the primary “villain” of the story is encountered.

VPC, the Valve Mission Creator, is what’s used to construct this venture.
Principally, this can be a customized build-system made by Valve within the Early 2000s again earlier than CMake or Meson had been fashionable. It has a high-level syntax that’s translated into makefiles for every supported platform.

On Home windows, this implies it’ll create Visible Studio .vcproj information for you.

Nevertheless on Linux, it’ll create a makefile for every venture of their respective folders, and a grasp makefile csgo_partner.mak in the principle listing.

As of this put up, I depend 73 construct targets. A goal is a static library, dynamic library, or executable file.

First, I needed to recreate the hardcoded construct instruments path.

/** I created a full information again when the leak was new and exiting ( that I will likely be referring to. **/
mkdir -p /valve/bin64/
cd /valve/bin64/
ln -s $(which ar) ar
ln -s $(which gcc) gcc-4.6
ln -s $(which g++) g++-4.6
#this half comes from cryptopp
mkdir -p /valve/steam-runtime/bin
cd /valve/steam-runtime/bin
ln -s $(which g++) g++
ln -s $(which gcc) gcc

The Valve Cookbook explicitly requires GCC 4.6.3, I consider that is due to the CXX11 String ABI adjustments that occurred that yr, however may be reverted with a preprocessor definition _GLIBCXX_USE_CXX11_ABI=0. I went forward and put this in some VPC information so I wouldn’t should trouble establishing outdated GCC and patching it to work on at this time’s techniques. (Which I really did first, see the hyperlink above)

Alright so after that, we’ve to manually construct every one of many dependencies and put them within the /lib folder. Valve devs didn’t trouble including them to VPC as a result of they theoretically by no means should be rebuilt.

The dependencies are situated in /exterior and /thirdparty and embody: libSDL2_mixer, libtcmalloc, cryptopp, libPNG, libz, and extra! I’m not going to speak about them intimately as a result of it’s fairly straight ahead stuff, however if you wish to see extra learn the gist linked above.

At this level we’re able to construct with VPC! Right here’s the params I used.

./devtools/bin/vpc /csgo /f +csgo_partner /no_scaleform -dedicated_main -datamodel -stdshader_dbg -game_controls -movieobjects /mksln csgo_partner.sln /linux64

Then we simply run make proper? Properly positive that will work however take over an hour, we want some threads however have a look right here within the csgo_partner.mak

# to regulate parallelism, set the MAKE_JOBS surroundings variable
ifeq ($(strip $(MAKE_JOBS)),)
    ifeq ($(shell $(UNAME)),Darwin)
       	CPUS := $(shell /usr/sbin/sysctl -n hw.ncpu)
    ifeq ($(shell $(UNAME)),Linux)
       	CPUS := $(shell $(TOOL_PATH)grep processor /proc/cpuinfo | $(TOOL_PATH)wc -l)
    MAKE_JOBS := $(CPUS)

We’re to make use of MAKE_JOBS surroundings variable as an alternative of the usual -j flag, and spot that if this isn’t included, it’ll auto-detect your thread depend.

Nevertheless, this doesn’t work how you’d anticipate it to. Bear in mind earlier once I stated that the venture has about 73 targets(A goal being a static library, dynamic library, or executable).
The MAKE_JOBS variable controls what number of targets are constructed directly, which means that if you happen to do MAKE_JOBS=20, it’ll begin constructing 20 targets with 1 thread.

That is dangerous for two causes,

-1 A few of the targets are large and take a very long time, whereas most are medium-small. Which means the most important targets will proceed to construct for 20 minutes whereas all the things else is finished.

-2 It doesn’t take dependencies under consideration, which signifies that you’ll require A number of Construct Sweeps to get all the things compiled.

The total construct was taking on 20 Minutes on my Threadripper 2950x, and I wasn’t glad with the workflow; This leads us into Act II…

Constructing CSGO – Act II: Exchange the entire Construct System

Rotten to the core. There is not any saving it -- we have to pull it out by the roots. 
Wipe the slate clear. BURN IT DOWN! And from the ashes, a brand new (csgo construct system) will likely be born.
Senator Armstrong

CMake was the plain alternative for the brand new construct system. I already knew it, it’s the goto normal these days, and my favourite C++ editor, CLion, would acquire superpowers as soon as it was full.

Now i’ll present some instance conversion from VPC->CMake.

One of many first ones I did was the ToGL venture, don’t ask why, I simply clicked someplace and took off.


Right here’s the beginning of the file, discover how variables are set with the $Macro key phrase, $embody statements are supported, and there’s a $Configuration part.
Now let’s see the CMake Model…


As you possibly can see it’s fairly comparable, with just a little additional meat on the CMake model. Every CMake file will embody a few of the widespread issues like CMAKE_MODULE_PATH to be extra modular. Each goal within the Kisak-Strike venture may be constructed individually at any time.

Now let’s have a look at the supply information.


This goal is fairly easy, there’s solely a handful of .cpp information. One of many stuff you’ll discover are the [$VARIABLE] blocks on the finish of some strains.
These are VPC if-statements and the road is just included if that variable is ready.


On the CMake facet, it’s fairly comparable, however the if-statements are extra apparent. One factor to notice is that I didn’t trouble including header information to the goal sources.
I’ve seen this earlier than in comparable CMake tasks(dhewm3, RBDoom3BFG) and the one motive so as to add it’s if you happen to would need them to point out up within the Headers part of Visible Studio when importing a venture. Visible Studio CMake help is slowly getting higher, so quickly I don’t suppose it’ll be wanted in any respect.

Lastly there’s a link-section on the backside of the VPC $Mission part.


This venture hyperlinks to tier2 and mathlib as you possibly can see.


Similar on CMake, however you may discover the additional libvstdlib. There’s really 4 hidden hyperlinks deep throughout the bowels of VPC that get added to each venture. I’ve dubbed these the “Smelly linkies” they’re libtier0, tier1, interfaces, and vstdlib. I’ve them within the CMake base venture however since this was the primary one it seems to be like I added it manually and it may be safely eliminated.

Talking of the CMake Base venture, they’re situated within the /cmake folder of Kisak-Strike and solely the linux model is carried out.

All in all it took me about 2 months to complete the port to CMake, I ported the dependencies to CMake and even received issues just like the protobufs relying the on customized construct output of the protoc compiler venture.

Present Construct instances

make -j30

actual	5m51.375s
consumer	153m53.981s
sys     12m14.018s

make -j2 (DEDICATED) on a pungent VPS

Huge enhancements from the VPC construct system, for reference it was taking me over 20 minutes to do a full construct.

There’s a number of room for enchancment right here too, we aren’t even utilizing ccache (like VPC does) nor are we utilizing precompiled headers.

Facet Journey

Just lately I discovered a weblog put up by a Linux Valve developer telling about his compile instances. (And no I don’t stalk Valve workers, it was linked within the VoGL wiki)

Right here is the post written by a Mr. Mike Sartain

Absolutely constructing TF2 devoted server was taking round 13 minutes, 10 seconds on this:

Intel(R) Core(TM) i7-4930K CPU @ 3.40GHz
mikesart@mikesart-petra:~$ grep -c mannequin.identify /proc/cpuinfo

I are likely to muck with the decrease degree libraries which meant I used to be spending fairly a little bit of my day ready for these builds to complete.

TF2 devoted server has:
 - 1347 cpp information
 - 13 DSOs (with 13 .dbg information)
 - 12 static libraries


So I received one in every of these:

(2) Intel(R) Xeon(R) CPU E5-2697 v3 @ 2.60GHz
mikesart@mikesart-mint:~/valvesrc/ValveGames/staging/recreation$ grep -c mannequin.identify /proc/cpuinfo

The construct time is now 3 minutes, 30 seconds.

With 56 threads, he received the construct time to three minutes, 30 seconds for the TF2 DEDICATED server. Understand that the devoted server excludes compilation of no matter will not be wanted for a devoted server (clientside code/graphics/UI).

Godlike Powers enabled in CLion

Now I need to present you the superior powers my IDE has gained by porting the code to CMake.

/** As an instance we need to observe a perform name via an interface,
how about Hint one of many CreateMove()'s the sport has about 10 of these, fairly annoying to seek out manually. **/

/** Hey that labored fairly good, what about some code-completion. **/

/** Ha, now let's do some actual code-completion. **/

/** Now let's discover each class that derives from IGameSystemPerFrame **/

/** One final check, let's discover each single ConVar within the recreation,
this one needs to be very arduous and compute-intensive. **/

Nice, that was on a normal SATA SSD and it solely took slightly below 30 seconds to seek out 4148 ConVars in all the codebase. It is a default-installation of CLion as nicely, I’m positive with extra tuning, it might carry out higher.

The CMake model rocks, and I want to add that Kisak-Strike compiles far more code than the VPC model. How way more? Properly many of the dependencies + a number of additional stuff that was not included within the CSGO associate repo.

What stuff chances are you’ll ask? Properly proceed to Act V to seek out out…

Constructing CSGO – Act III: Resurrection of Code

At the moment our CSGO seems to be like this:


Appears to be like kinda slick, but it surely’s non-functional. The In-Recreation UI can also be lacking, and there’s tons of ScaleForm UI code ripped out.

The weapons don’t work, and several other different issues don’t both.

The code has been neutered, more often than not with a message like this:


Fortunately, we’ve some assets at our disposal that will likely be acquainted to you if you happen to’ve ever been concerned within the CSGO dishonest scene.
Valve has by chance launched debug variations of their video games on Mac (and generally Linux), we are going to analyze these every time we have to see what performance is lacking from part of the code.

/** Now that i've seen the construct system, I believe I do know why the debug variations leak generally.
On linux/mac it isn't attainable to construct with debug symbols in a separate file like .pdb's on Home windows
As a substitute they strip out the debug information in a postprocessing step.
I think about that generally this step fails and their scripts publish the builds anyway **/

I’ll undergo one in every of these and present an instance. Right here’s a perform in /recreation/shared/cstrike15/weapon_base.cpp that may assist us get our weapons again.


This may be present in shopper, but additionally server because it’s within the shared/ folder. Let’s open it in IDA.


Right here we go, seems to be pretty small.


Alright so first off, we need to get the proprietor of this weapon. There’s additionally a dynamic forged proper under.


Why don’t we take a peek at one other perform on this class…


That half with GetPlayerOwner() seems to be like what we wish, and look right here, it has a dynamic_cast.


Alright let’s transfer to the subsequent half… (Zoom In)


On the high you’ll see our dynamic_cast code after which a fast if-statement block to examine if null, then return.
After this the code hundreds up C_BaseEntity::m_nPredictionRandomSeed right into a variable.
We are able to entry this simply with GetPredictionRandomSeed() right here:


After this, the code checks weapon_legacy_recoiltable to see if it’s set.
As an OG CSGO participant, I occurred to already know that this was associated to the nospread patch the place the unfold seeds received modified to be server-sided.
It’ll both name CCSWeaponInfo::GetRecoilOffsets() or g_WeaponRecoilData.GetRecoilOffsets() relying on its state.
We’ve got entry to each of those capabilities already and with a view to make certain we get it proper, we are able to simply check out them and see which one will not be legacy.


Alright so based on this remark, this one is out of date and will likely be used if weapon_legacy_recoiltable is ready to 1.

We’ve got yet another small chunk to have a look at…


Which is fairly simple to learn, simply apply the ensuing recoil to the Participant Proprietor we received earlier.

The ultimate code seems to be like this:

void CWeaponCSBase::Recoil( CSWeaponMode weaponMode )
    /** Eliminated for associate depot **/
    //lwss - rebuilt this perform from reversing retail bins
    CCSPlayer *pPlayer = GetPlayerOwner();
    if ( !pPlayer )

    int seed = GetPredictionRandomSeed();
    float angle;
    float magnitude;
    if( weapon_legacy_recoiltable.GetBool() )
        GetCSWpnData().GetRecoilOffsets( weaponMode, seed, angle, magnitude );
        g_WeaponRecoilData.GetRecoilOffsets( this, weaponMode, seed, angle, magnitude );

    pPlayer->KickBack( angle, magnitude );
    //lwss finish

I prefer to hold the unique Elimination assertion for historic functions. You’ll additionally discover the //lwss and //lwss finish, that is one thing I picked up from one in every of my idTech pals.
It’s a normal process to remark your adjustments with these blocks as a associate, in order that while you ask for engine-support they will inform what adjustments you’ve made. I believe it’s just a little outdated with trendy VCS but it surely’s kinda comfortable and I believed it was applicable for this venture.

In order that was one instance of restoring code, as you possibly can see the Debug bins are a helpful instrument. In addition they occur to be from across the precise time this repo is from.
One other good useful resource is the accompanying TF2 leak, it appears to be extra full than the CS:GO model, and we are going to seek advice from it later on this put up.

This was completed just a few extra instances to totally restore the weapons, make loadouts work(particularly on the bots), and different varied issues.

Constructing CSGO – Act IV: Unsustainable UI

Changing the Scaleform UI was the subsequent massive process on my Agenda.

Holding it was out of the query because of it being incomplete, proprietary, and laggy.
I considered hacking Panorama UI in, which might be fairly amusing, nonetheless it’s closed supply and doesn’t match the theme of the venture.
I additionally considered ending the VGUI. I already knew that the codebase for VGUI was fairly dangerous after a earlier try at doing a VGUI menu for an additional venture, however after seeing it in additional element, I opted out!

I seemed round a bit for some options:

  • Good ole’ ImGUI – not customizable sufficient, solely good for settings menus tbh.
  • FlatUI – Deserted, bloated, made by google
  • Chromium Embedded – LAG
  • EAWebkit – LAG
  • Coherent Hummingbird(Diabotical) – Closed supply, costly, lame

I lastly discovered absolutely the good library for the job, and it’s known as RmlUI.


RmlUI, a fork of the deserted libRocket, is an up-and-coming UI library. It makes use of customized trimmed-down variations of HTML and CSS together with a customized engine that’s not WebKit-based.
It doesn’t embody any scripting languages by default (Which I like), nonetheless Lua help may be enabled.

The library could be very nicely abstracted and the Documentation covers all the things you could know to implement the required interfaces(Rendering/System/Filesystem/and so on).
In reality after testing out the included demo, I instantly began implementing the library into the sport and didn’t run into any main issues apart from OpenGL state mismatches that had been my fault.

Integrating RmlUI

I needed to do a correct integration of the library, and with a view to do that I must match or exceed the standard of the Scaleform code.

Right here is the format of RmlUI within the KisakStrike code base:

  • /recreation/shopper/cstrike15/RocketUI/*
    • Right here is the cpp code for all the CSGO customized components. Every aspect will load a corresponding .rml file utilizing the RocketUI interface.
    • Word that the RocketUI system consists of two Contexts, one for the Most important Menu and one other for In-Recreation. Naming Scheme RkHud hundreds to the in-game context and RkMenu to the Most important Menu, an RkPanel may be loaded in both.
    • Rocket HUD components are registered with DECLARE_HUDELEMENT and derive from CHudElement. Which means they’re mechanically known as/registered with the sport engine.
  • /public/rocketui/rocketui.h
    • The /public folder is the place you will discover headers for interfaces, information in listed below are typically secure to incorporate and principally include pure interfaces and predeclarations. The RocketUI Interface is right here.
  • /rocketui/*
    • It is a customized CTier3AppSystem implementation of the RocketUI interface. It is a new goal that builds right into a that will likely be loaded by the sport on launch and jacked in through the interface system.
    • rocketuiimpl.cpp is the Most important implementation for the interface Init/Join/Disconnect.
    • rocketrenderGL.cpp is an OpenGL Rendering implementation. Ideally we might use the ToGL system, however I needed to get one thing working first and this venture is aimed to be Linux-Solely.
    • rocketfilesystem.cpp File system chroot’d to the ${GAMEDIR}/csgo/rocketui/* space within the recreation folders AND/OR pak information through the common filesystem interface.
  • ${GAMEDIR}/csgo/rocketui/*
    • A New folder within the recreation listing that accommodates our new UI Format and Fashion information, together with photos, fonts, and templates.

Modifications made to the Current Codebase:

  • /public/interfaces/interfaces.h
  • /engine/host.cpp_Host_RunFrame
    • Calling into RocketUI on new body. Used to replace RocketUI and set the shopper realtime.
  • /engine/keys.cppvaried
    • Enter hook that goes to RocketUI::HandleInputEvent()
  • /engine/sys_dll2.cppCEngineAPI::Join
    • Addition of RocketUI Interface manufacturing facility and setting worth of g_pRocketUI
  • /engine/sys_mainwind.cppCGame::DispatchInputEvent()
    • Copy a Scaleform hack right here to cease Enter hook whereas vgui console is open.
  • /engine/view.cpp – `V_RenderVGuiOnly_NoSwap()
    • RenderRocketMenu() is known as right here.
  • /recreation/shopper/c_playerresource.cppC_PlayerResource constructor and destructor
    • Name g_pRocketUI->AddDeviceDependentObject() on building of C_PlayerResource and take away it on Destruction. This registers RocketUI to obtain callbacks when the rendering gadget is up to date.
  • /recreation/shopper/viewrender.cppRenderView()
    • RenderRocketHUD() is known as right here.
  • /materialsystem/cmatqueuedrendercontext.h
    • Add DEFINE_QUEUED_CALL’s for RocketUI. That is wanted for mat_queue_mode which signifies that the draw instructions are stacked up and completed on one other thread. 99% of the time that is enabled as a result of it provides 40-50% extra FPS.
  • Varied others.

Another issues to Word:

  • Enabled WITH_OVERLAY_CURSOR_VISIBILITY_WORKAROUND to get the system mouse cursor to cease flashing. (I’m positive you’ve seen this if you happen to performed CSGO again when it had Scaleform and I might wager cash that Valve enabled this in Panorama)
  • Splitscreen slots should not carried out, however remember they aren’t carried out in Panorama both.
  • Makes use of Uncooked OpenGL instructions at present.

I had somebody ask me how I carried out it and thought I might write up a good overview for them to see, it additionally helps get an thought of how the engine hooks as much as RocketUI precisely. For extra info, you possibly can see this commit.


What I needed from the UI was one thing that was fundamental, quick, and did the job. There’s all the time room for enchancment after the performance is there, and I designed the UI to be extremely customizable by the end-user.

Right here’s a brief video exhibiting what it seems to be like:

Every little thing is connected and dealing; very light-weight, efficiency affect is just about 1%.

That is the most important authentic chunk of code within the KisakStrike codebase, however one thing that wanted to be completed seeing because the ScaleformUI was neutered and VGUI was by no means completed.

Constructing CSGO – Act V: Chasing the Dream

This Act will likely be our crescendo, the quantity of pure unbridled autism on this part is huge.
A Mission months within the making, that is It, this ultimate half actually took essentially the most quantity time and work, and I’ll attempt to present how.

First, let me state the Absolute goal for this venture once I began it.

A Absolutely Open-Supply CSGO for Linux, with no blobs, 
one thing capable of be preserved by the customers ceaselessly 
on any structure or platform. 

If we received nuked tomorrow, and Steam went down, anybody might have CSGO up and operating within the Bunker LAN by subsequent week.
Years later when us smoothskins are rockin’ Power9 Rigs, we might even have the flexibility to recompile and port the sport.

Evil Blobs

Something Closed-Supply is mechanically evil. After ensuring I had all our geese in a row, these had been the remaining closed-source blobs for the sport.

  • ( HRTF Audio )
  • ( All Physics, Raytraces )
  • gcsdk_client.a ( Recreation Coordinator )
  • steamdatagramlib_client.a ( SDR Relays )

HRTF Audio

Let’s begin with a simple one, HRTF audio was added to recreation in a later patch.
No offense, however I by no means actually appreciated it, thought it appeared like I used to be underwater and will use extra tuning.

See Also

I added #ifdef’s to a number of of the audio engine code information and enabled this as an elective construct step ( -DUSE_VALVE_HRTF ).

Sooner or later I want to discover a few of the new OpenAL 3D audio extensions and see how nicely they work.

Steam Datagram lib

One other simple one.

SDR Relays are solely used to hook up with Valve Matchmaking Servers. I need this venture to have the most effective likelihood of staying publicly out there, so I made a decision it was out of scope.

Added extra #ifdef’s and eliminated the performance.


Right here’s the place issues get attention-grabbing… Do you bear in mind once I stated that the TF2 leak had extra content material than the CSGO one?

The TF2 leak really has this half, however after all it wasn’t a straight paste job…

  • CSGO particular stuff lacking after all, and the initialization trusted that.
  • There have been updates to the GCSDK since TF2, inconsistencies relating to SOID_t, CSteamID, and so on wanted to be resolved.

New Recordsdata

  • /recreation/shared/gc_clientsystem.cpp/.h
    • Fundamental GC connection. Generic baseline communcation. Generic Message Handlers
  • /recreation/shopper/cstrike15/cs_gc_client.cpp/.h
    • CSGO particular messages. Message Handlers.
  • Protobufs had been up to date to the retail model to make sure they labored correctly.

The /gcsdk and /public/gcsdk folder is from TF2. Word that /gcsdk_original and /public/gcsdk_original are the unique ones that got here with CSGO that had been incomplete.

This part was really very a lot wanted for the Devoted server to work as a result of the blob that we received within the leak was not compiled with -DDEDICATED so a few of the code in /tier0/threadtools was totally different.
Initially hacks had been made on this space to get the devoted to work, however they’ve since been eliminated.

Right here’s what it seems to be like when logging in:


The Ship/Recv msg’s are just a little contact that I did, they’re Dota2-style. Proper now there may be only a easy handler for the Matchmaking Hiya that exhibits a few of your account information.


The perfect was saved for final.

The physics engine was faraway from the CSGO leak, after a quick look within the TF2 leak it seemed to be there.
/vphysics was there, it seemed full, and was the identical interface model because the CSGO vphysics.

Nevertheless, it depends on a folder known as /ivp that was absent from each leaks.

On the time, I had no thought what IVP stood for.
After some looking I found it stood for Ipion Digital Physics and was a German middleware from round 1999 that later went out of enterprise. It’s arduous to seek out info on them, but it surely appears they had been absorbed by their competitor Havok within the early 2000’s and not exist.

IVP was not wherever on-line and gave the impression to be misplaced ceaselessly to the sands of time. Simply once I thought all hope was misplaced, I considered yet another place to look… The notorious HL2 beta leak from 2003.
I seemed on-line for this leak and didn’t discover it wherever ( Whereas writing this text after all it’s the first consequence that results in, go determine ). I knew that I had downloaded it someplace and began trying via outdated arduous drives… After about an hour, I discovered it on my outdated 2016 drive, however did it have the /ivp folder?
Bingo, it did!

twentieth Century Abomination

After lastly discovering the traditional magicks from 1999, Germany, I used to be prepared to stick it into KisakStrike and have it work. However, it wasn’t even near functioning.

This code is early C++, written by German Physicists in half-german, half-english, hard-coded to be 32-bit. There was int-pointer arithmetic scattered all through all the factor that will make it not possible to work on 64-bit.

Now after all these guys are lots smarter than me, and I’m positive there’s some strong arithmetic on this code, however check out a few of this:


For some motive they actually beloved utilizing the thisptr to get again to an array tackle.



Plenty of bitfields!


Some issues from id Software program?

Hey it’s the Little/Huge numbers, cute. Appears to be like like they’ve a little bit of bsp stuff too.

Did I point out I had the retail vphysics open in IDA? Appears to be like like Valve additionally received to expertise some enjoyable in right here. Copied their error message for swag after all.


I additionally did some issues I’m not actual pleased with….



But it surely seems to be like I wasn’t the one one hack’in


Right here’s the quantity of lwss’s I added to the code altogether.


The code is in a brilliant tough state, however I’ve duct-taped it sufficient in order that it really works.

Raggedy Ragdolls

One space I had some hassle in was the Ragdolls, right here’s a blooper phase…

After getting it working, right here’s the preliminary consequence.

Welp, seems to be like some information corruption, after spending god is aware of how lengthy within the IVP code, I found out it was the compiler optimizations.
I began caveman’ing and making use of optimizations to every of the cpp information and the wrongdoer was ragdoll_constraint_bp_builder.cpp.
The file is just about 210 strains, however don’t ask me why it fails on O2 and never on O1!

Right here we go take 2:

Properly they’re not spasm’ing, but it surely seems to be like once they die, they fly in the direction of mecca as an alternative of the bottom.
This was really a bug that I launched whereas upgrading the code.
In CSGO there’s a function the place the ragdoll gravity may be set totally different from the remainder of the physics.
That is known as SetAlternateGravity(), not the most effective identify fellas, however I wanted to have one thing there for the interface and right here’s what I had.


I tousled the Axis’s after all, however I ended up eradicating this code fully as an alternative of setting the sport’s gravity to the cl_ragdoll_gravity ( one thing foolish within the first place ).

Take #3:

Hoorah the ragdolls work.

Caveats and wrapping up

The Open Supply Physics rebuild – referred to as Kisak-Physics doesn’t implement the next:

  • Ragdoll-Particular Gravity
  • Automobiles
  • Prediction (results unknown!)

It’s in a good state now, however is an elective build-step because of not being good. Use -DUSE_KISAK_PHYSICS to allow.

Constructing KSGO – Epilogue: The Future and You

Kisak-Strike is now 100% Open Supply.

The one Closed-Supply binary is the 
This file is left for comfort and technically will not be part of the sport.
For those who had been making a totally totally different recreation, you'd nonetheless want to combine into Steam.

I need to focus on a few of the constraints I’ve placed on this venture.

  1. Kisak-Strike is Linux-Solely.
    • I don’t care about Home windows/Mac customers, they each have the flexibility to return to Linux at no cost.
  2. Kisak-Strike doesn’t connect with Matchmaking
    • This doesn’t appear applicable. Sooner or later, I would add neighborhood server connectivity. At the moment, you have to to hook up with a devoted kisak-strike server.
  3. Kisak-Strike has no skins
    • One thing Valve is delicate about

Kisak-Strike doesn’t need to compete with the mainline recreation. As a substitute we need to take the sport our personal route and have full modding freedom over the code.


Construct it your self! Create your individual personalised construct optimized on your pc!

Kisak-Strike may be discovered here

Kisak-Strike further information may be discovered here

Please be aware that this code is property of Valve-Software program and any contributions that you simply make are thought of a donation into the general public area.

Finish of Put up

This one was fairly lengthy, however I attempted to maintain it entertaining. Plenty of stuff was neglected with a view to hold this readable, however I believe I lined all the things massive.

Good luck players, and have a Merry Christmas!

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top