Today, we'll review the source code for RE3- the reverse-engineered C++ source code for Grand Theft Auto III and Vice City. We'll look at the code for Pedestrians, Vehicles, Cops, and Gangs.
just goes to show how much optimization the compiler does under the hood. the underlying assembly must've been pretty neat (thanks to the compiler turning bad rockstar code into nice assembly)
As someone who has worked with c++ for 10+ years, this code looks like something an intern would write. I do like the forward declarations in the headers, but I think that's pretty common in game development
I am not even a C++ dev but this code was so easy to understand. The variable naming and logic almost makes it feel like reading natural language. "If x is y, do z" etc.
This is really fascinating to look at in depth. I used to make mods for GTA 3 around 2002-2003, and was always hampered by the limits of the engine. I haven't been in that scene in years so I wasn't even aware of this project. Great video.
You guys don't realize that back in the late '90s and early 2000s there was still a lot of incorrect thinking that violent video games and movies directly caused kids to become violent and psychotic. This has since been disproven via psychological studies, but it was a common talking point back during that era. In fact you can still see some people clinging on to that incorrect belief to this day if you ask enough people.
Having one weapon class stacked with a huge switch case statement sounds bananas but the rest of the code looks pretty clean. This was really interesting!
I guess it was mostly issue of early gamedev as there were no engines like unity back then and I think people were following mostly the idea "don't fix what is not broken" allowing thus weird structures in code and logic just to make it done instead of banging their head to make it pretty. I recently starting to find this approach relatively viable if only certain team works on the project and until the point you decide to create it more maintainable. So currently my opinion on code is: First implementation can be anything that works, if features update starting to touch that piece of code a lot it will require revision.
Yeah I thought it would have dynamically called the class based on weapon type. Would love to know the backstory to these little things like "yeah we let the intern loose on that. It worked so we left it"
Probably because a switch statement is faster than doing a vtable lookup for polymorphism. For a switch statement the compiler generates a jump table and there is no indirection of code; you just jump to the code which needs to be executed. In a vtable you have an indirection to another method with an extra cost of dereferencing a pointer. If I recall correctly virtual methods can also cause cache misses due to the vtable lookup, dereferencing and indirection. The use of a switch statement here probably serves as an optimisation. In game programming, especially back in the days, it is common practice to ditch virtual methods in favour of switch statements, use array based data structures instead of pointer-based ones like linked lists.
People keep saying this and implying that its like intern level code, but it really just shows how little exposure you have to anything outside of OOP code and don't understand c++ that well. using Switch statements are way faster than performing dynamic dispatch using inheritance. When using an dynamic function in C++ you are working with a pointer that has to be dereferenced, which is slow, then you have to perform a look up on the VTable to find the right function. And if that isn't bad enough you can't inline dynamic functions. Switch statements can call functions that are able to be inline and don't have to use a VTable, now normally you would have functions inside of the switch statement that are all in one compilation unit, and this stays clean because you can look at all the different implementations of the gun in one file, which is quite nice for code read ability, unlike a lot of OOP code where multiple classes exist in different cpp files and you have to go from file to file across your code base to see how different versions of the the inherited functionality is used. There are lots of good reasons to use procedural programming practice, along with learning functional programming practices, I recommend not calling code messy just because it doesn't conform to the only programming style you seem to know @@n00bma5ter69
I like it! Definitely will watch more as if there’s not enough code reviews have to be done at work. Maybe it’s your voice that makes it so satisfying)
As a CS student it is refreshing to see this code being so "simple" and kinda relatable to what we are tough in school. You would think in the real world they would use some crazy logic and algorithms. It is nice to see the switch and the if statements lol
hoy hoy the switch and if statements are one of the backbones of any programming at all what's hard about CS study case vs IRL work case would be the decisions of said codes, analyzing your company's needs and ideal business process, and many other stuffs. Not forgetting working under more strict deadlines, dealing with tons of things to do with minimum resources, etc.
I've seen some of the leaked/stolen GTA V code. Apart from the file I saw having over 10k lines (which isn't even really an issue per se) it was very readable, clearly structured, the function names and signatures were pretty clear and descriptive. Not too many comments, but you don't always need them. I also didn't see any truly scary or horrible C++ concepts (no sign of the dreaded reinterpret_cast etc. From what I can remember) and I understood about 90% of it, despite not really being a C++ expert. Can't quite remember what that file did, but I think it was logic governing humans interacting with different types of object in the game world e.g. getting into a car, getting out of a car, what happens if you encounter another pedestrian and bump into them etc.
This is really useful content. I'm in Unity with C# but this is definitely giving me ideas of how to structure my code better and even how to "blueprint" my methods / variables to ensure I'm not forgetting functionality later on.
You'll get a headache for sure trying to maintain or expand your game, assuming you are following this example too close. You're much better off modularizing your components.
As much as Unity annoyed me and felt like a cheap toy, the way you structure your scripts and attached them to things is so much more intuitive than Unreal. At least at first. Unreal gets very messy very quickly when you break out the C++. It's non-standard syntax (with many things hidden from you) and you don't attach the code to a game object, rather the code IS the game object. Just like how the Blueprint in the editor IS the game object also. You can't really go "half and half" in Unreal like you can in Unity. Or at least I haven't quite figured out how yet. You're better off doing your entire project in Blueprint or C++ IMO.
@@halfbakedproductions7887 I'm working on a complex game project and it's really up to you, both workflows are possible! You can have the code running outside the gameobject, and that gameobject just being a reference, if it's that what you mean. When I tried Unreal for a few weeks I noticed that the workflow I created throughout the years was kinda similar to Unreal. But for me calling scripts, gameobjects and prefabs the same thing is just a mess. I prefer that on Unity it's really up to you what workflow you want, even if you want to replicate something like Unreal I believe it's possible!
5:58 The differences between the different kinds of cops doesn't warrant another layer of inheritance. They all have the same functionality except for different attributes like model, armor, etc. They all will use the same methods. I think it's very clean and a testament to how well written the base cop class is that they don't need to reimplement methods for each different cop type.
To be honest, then project there is cool, but don't lose your time watching this video. Check the project by yourself or watch from a reliable resource. His comments are of very few value. Unless you are a junior, them it may be interesting to waste your time listening to him.
@@salsichalivre5401How can it be interesting to "waste" your time? Especially if you make it sound like there's still some value for less experienced people, that's never a waste of time in that case.
@@salsichalivre5401 I agree, but I mostly just read code from the screen without really paying much attention to what he's saying. I feel like that's equivalent (except ofcourse you only read the code he shows).
I’m amazed that this even exists in the first place. The fact that it exists is proof that the free market of software / code is the real frontier of ideas. And I’m not even a dev. I’m a product designer but this is fascinating. I don’t play video games either. I’m just interested in the tech behind the world.
11:21 I really like enums. There are so many little tricks you can do with them, they are simple to understand and lots of enforcement at compile time or static analyze.
And at the end they boil down to just being plain old numbers. Rather than having to remember that 1 means "walking", you just have state.IsWalking instead. Makes your code so much more readable and a smart compiler will optimise it all down anyway.
@@prostmahlzeit Didn't really but much effort but here it goes: * Header file aren't documented in any way * Use of C-style pointers * The code doesn't follow memory safe practices. For instance, the pointers are not checked to be valid. In many places references could be used instead of pointers. * Questionable architecture. The monolithic classes should be split. For example the CVehicle class is awful. No abstractions, no proper pure virtual functions where needed. * By looking at a class header, it'll be unclear if the function changes the instance's state. * Unclear ownership of data. * The code doesn't seem to follow any widely used style practices. Lots of nested ifs, monolithic functions, no consts etc.
Comments, variable names, function names etc can't be retrieved via decompilation / reverse engineering, unless debug symbols are present. So all of the comments and names of everything are likely solely attributable to the folks that did the reverse engineering.
What you are seeing is the labels given by the person who has reverse engineered the purpose of each "thing", not the original labels by the rockstar programmers. When you disassemble a binary file, you don't have the luxury of retaining any useful labels or comments (sometimes all you have are some unmolested cleartext strings e.g. names of some external .dll files) so you've just got to add your own labels as you discover what each structure does. One hell of a task, and they did a really good collaborative job on this one.
I think comments have two big places where they can help. To help summarize large amounts of code. Like explain what this whole file of code is. I also use then if I don't feel like the code does something a little abnormal. Like why am I getting this variable or calling this function when it seems unrelated. So I might a comment saying it's best to run this to make sure all the objects are updated or something like that.
@@killionaire175 I don't mean the original code, I mean this version of the code shown in the video is perfectly readable despite being scarcely commented
I like the way they wrote it, they didn't go insane with the C++ OOP features, they do a very minimal implementation similar to how it would be done in C. I hate over engineered C++ stuff where there's a bunch of methods that are just one line.
one of my bigest issues with todays software concepts and frameworks. People just 'complexify' things. Makes code very hard to read. Its like a display of syntax knowledge rather than implementing things in the most efficient and simple way.
thats usually called a “c with classes” approach which basically tries to utilise core concepts of c and use c++ festures as little as possible (eg oop)
It's about debugging. If you have several lines of code, it is much harder to find errors than in single lines. If you break it down all the way to super small methods, you can check each and find errors much quicker. Between 1/4 and 1/2 of programming time is spent on debugging. So minimizing this is a huge plus!
9:25 Wouldn't that be because the getters and setters (or similar) that they would have had in the original code probably was inline? I'm guessing you had something like pDriver->SetVehicle(this); but since it was probably defined in the header it was optimized away at compile time into simply an inline assignment. Thus when the project owners reverse engineer it, they only see the inlined version? I feel that's just common sense for C++ generally.
for the heli section at 6:40 I believe the Find Target section is to enter a heli, but if heli status is Shot Down then you cant enter the heli. then all the cases are different ways you are able to path to or enter the heli. which is why Take Off is after that block of code.
I wish my college professors gave us real life examples like this!! They taught us inheritance, class, object etc but never really taught us how they are implemented in the real world.
It's worth pointing out that the reverse engineering of GTA3 was assisted by debug symbols being included in the PS2 and Android versions of GTA3, which made it easier (but not easy) to reverse engineer the source code.
It's always crazy to me when AAA developers leave debug symbols in the final compilation. It's extremely helpful, almost like a jigsaw where you know what certain functions are supposed to do by their name so when you finally find the code you can just go find that function name you know you saw and apply it
@@ITSecNEO Something tells me you don't understand the work that goes into reverse engineering source code. It's not enough to have something that works, you also have to engineer something that's maintainable. You can't automate that even with debug symbols.
@@ITSecNEO I have reverse engineered .NET code with tools like dnSpy. You still don't end up with code that you want to maintain. Why don't you go and tell the people reverse engineering GTA3 and Vice City that they're doing it all wrong, any look at their commit history will show it's not a 5 minute job.
A game I know called Let It Die has Enums that the game signature was dumped so we found value types, but no source code, the enums would increment from 0 and the last enum would actually be called MAX, generally setting any enum to the MAX enum value would crash the game because there was no code built around MAX just everything that came before it
I don't know a lot about C++ beyond what it has in common with other languages, nor have I played GTA3, but this is still one of the coolest things I've seen in a while. I've always wondered how code in triple A projects was structured
Bare in mind, this code is reverse engineered. So when your commenting on the style of variable names, thats of those that reverse engineered it, not the original code.
It doesn't matter which programming paradigm you are a fan of. It only takes that one co worker for you to change your mind. In modern day programming, you need to be fluent in every paradigm and be able to apply one that fits for a specific part of your program. No project can be entirely procedural, object-oriented or functional. You also need to know to switch paradigms when refactoring if it is a better fit.
You are very sympathetic and just got a new sub 😊 Edit: The code looks extremely well written. When I was modding pokemon emerald for the gba, the disassembly, written in C, was completely unreadable. It was downright disgusting. I had an easier time working with the first and second generation purely written in Z80 Assembly ^^
@@DanyloSyrotynskyy blabla bla the code always look horrible for a one single random dude, I am sure if there was to put a poll most people would find this code very readable
Back in those days it was likely too expensive to take the cache miss for vtable indirection. Likely why they went with big switch statements over inheritance
It also serves no purpose to introduce another layer of inheritance when you can instead write a robust base cop class and provide sufficient attributes that effectively modify the behavior based off the different kinds of cops.
Hey this was a really great video! Would like to see another like it if you're up to it :) There's a lot of open reversal projects for games dating to that generation. I personally recently was looking into MGS1 because I was curious on the implementation of the soliton radar. Hope you been well
This is interesting, but I think it would also be neat to look at the code that connects those logical functions to the visual character entities that display on the screen.
8:52 they call a Magazine a Clip, even though we haven't used clips since ww2 with the M1. I find it absolutely fascinating that people still consistently make this mistake, when it should be common knowledge what the difference between a magazine and a clip is.
I think I just had a "wait its all basically if-else statements - always has been" kinda moment. I was turning my nose at it until I realised I kinda agree with it, being a rust convert, throwing away inheritance all together, you probably end up using enums/tagged unions to handle sum types anyway, but this seems kinda loose in c++. Does c++ have interfaces, I mean it has "contracts" (was it?) for its type constraints, are they like traits/interfaces?
C++ doens't have interfaces, closest to that would be abstract classes (classes with pure, non-initialized virtual functions) and multiple (virtual) inheritance
An interface is just an idea in C++ unlike in other OOP languages that don't allow multi-inheritance for class types. But it is usually allowed to implement multiple interfaces, that's why other languages need the distinction. In C++ you just inherit from interfaces because they're classes. An interface in C++ is just a class where all member functions are pure virtual, and there are no data members. Also concepts are another way to implement the idea of an "interface" in C++, but it's for static polymorphism, not for dynamic polymorphism. C++ is not strictly an OOP language, so it's other major paradigm is "generic programming" which is used to implement the standard library, and for which concepts were designed for mainly.
Very nice video, by explaining the code I can understand a bit what it does despite of never code on C/C++. Is a shame that this project went to the trash because of Rockstar Games greediness but even so I can hope one day to see a project like this again because Vice City is one of my favourites games and the 3D era of GTA needs to be preserved
Vice City is a legendary game... and the reverse project seems to be much better in every possible way, than all the ports done by take2 and rockstar later on. I guess that why take2 brought it down - they cannot handle a fair competition. It's all about cash grab nowadays.
@@pisse3000 It's clearly less about piracy than it being an unauthorized reverse engineering. This is not a defense as I only points out the disingenuous counter.
A lot of game programming in comparison to usual software programming I noticed so far is, if the game doesn't need to be maintained (single release), you can throw a lot of etiquette away. Using switch case instead of classes, changing member variables from other objects, and otherwise very unusual solutions to problems are more common than I first expected. After all, having a consistent code structure will help in the first 75% of development, and help with diagnosing bugs on the latter 25%, but the number one focus really is to deliver something playable. The client (the player) experience is the same if the state machine is its own class with scripts or just a switch with 40 statements lol. Of course, this doesn't quite apply to MMOs and online games and moddable games and frameworks/engines, but it's the main idea.
This is sooo cool!!! Love to see how older games are made specially cause they had to be optimized to run on such low specs! Also unrelated but you could 100% do trailer voices if you need a job, you have the voice for it!
Deep inheritance would not necessarily be unwieldy. But it could be argued that depending on how deep you go your overall design is most likely flawed and should be reworked. One of the reasons they take so long to make GTA and Red Dead aside from the details is most likely how much time they spend ironing out every detail of the code to make it the complete opposite of anything made by Riot Games.
