Hello Everybody, Earth Otherwise here with part two of chapter one of Game Programming in C++: Start to Finish. The second half of the chapter opens with Concurrent Versioning Systems. The books uses the old CVSNT, a versioning system for windows platforms. However, in the current market a tonne of people are using GIT for their projects, though other services are available.
If you don't know what a versioning system is I'll explain it quickly here and leave a link to the wikipedia page. As simply as I can put it a versioning system keeps track of when and what changes you make to your code, though it can also be used to keep track of changes in things like your textures or sound assets. It's more used and useful in teams that use multiple people.
It's used because anything that anyone does could potentially create a game breaking or software crashing bug and if you have 60 people all adding to a code base then tracking that one bug can be a nightmare. Instead you can step backwards through each change that the coders made and find the exact, or as close to exact as possible, change that introduced the bug, potentially cutting the code you'd have to look through down from millions of lines to a couple thousand or hundred.
Now, the books goes on to explain how to set up the version software that it uses. However, as we already know, this book is so out of date that almost nothing it uses is relevant anymore. In fact, the most up to date versions of CVSNT, the software it uses for version control, is no longer free. To that end we'll look at GIT and see what it has to offer us in the way of version control.
Note that Git itself is free, but some of the services of github, an online version repository, is not.
I'll be using Git myself on this project and I'll link to some tutorials and probably record my own process in the technical video on this chapter. As this is the informational video, we'll move on to the next part of the book. It spends a few pages teaching us how to use CVS, which I'll skip, before going on to DOxygen, which is a tool for creating comments and it's particularly used for C++ code.
The book uses an outdated version of DOxygen. After looking around there seems to be quite a few developers in game creation that think that adding comments in the code itself is good enough, and they may be right. The others though, say that DOxygen is still a valid and useful tool for code documentation, and we'll be using that in this project.
The last piece of software for this chapter is something called InnoSetup. Software for creating an executable that will set up the directories of your game in a customers computer. Looking around online there are many options, though it appears that InnoSetup is still up and running. The problem is that InnoSetup only creates an installer for the windows system and I want my games to potentially run on any kind of system imaginable. That's why I chose opengl and SDL in the first place, after all. Let's skip this for now and come back to it later, shall we?
The final part of this chapter goes over a few important parts of the Standard Template Library. You'll probably recognize them from the tutorials with Ben or my own coding videos.
The first is the string. I'm sure you all know about this. An array of characters like a password or a sentence that you can change, add to, subtract from, and rewrite with ease.
Next is the vector, one of my favorite things to use, since it's self checking and has an array of useful feature, though there is a bit more overhead and cpu cycles involved in using it.
Finally is the map container. Now, I've never needed a map, though I've seen it said that some use it for keeping key bindings in memory. It is a key and value pairing container that allows you to quickly grab and use a single object from a large array of objects without having to know exactly where in the map you put it.
This brings us to the end of the first chapter. There's not much here, but there will be one last post about this chapter as we install and get ready to use git and DOxygen.
After that we'll move into the more wordy chapter: Design Fundamentals.
▶️ DTube
▶️ IPFS