Game Engine Framework with C++ (Learning Engine Architecture through Sokoban and Shooting Games)

I have now clarified my understanding of confusing CS concepts to the point where I can explain them accurately. Furthermore, by designing Sokoban and shooting games myself and learning about RTTI and collision functions, I have gained the confidence that I can now create games on my own! I would love to recommend this to my friends!

I highly recommend this course to those who want to go beyond simply using the features provided by commercial engines and instead wish to directly design and understand the fundamental internal structure of a game engine. Through this lecture, I was able to gain deep insights into the operating principles of core functions, such as the actor lifecycle and tick management. In particular, learning how to control memory directly with C++ to prevent resource leaks and implementing custom RTTI to handle object inheritance and safe downcasting were invaluable experiences that cannot be gained through superficial study. Furthermore, the process of building the engine as a DLL to separate and link it provided practical CS knowledge that is difficult to encounter in standard university major courses or general tutorials. If you are a developer who wants to know the real reasons behind how engines like Unreal or Unity work internally, I strongly urge you to take this course.

This was a huge help. Starting from very small snippets of code, I eventually found myself properly creating a 2D game. I've also been learning Unreal Engine recently, and this course has been incredibly helpful. Since everything from minor variable names to class names aligns to some extent with those in Unreal, it helped me understand Unreal's structure as well. My favorite part was RTTI; I felt great joy seeing runtime information implemented through code I wrote myself and watching it function usefully within the game. I'm looking forward to the instructor's next course. Thank you!

Previously, my code was very messy because I focused solely on implementation without any knowledge of design. However, through this course, I learned implementation methods suited for engine and game structures, which improved my code readability and gave me a sense of direction for design. Thanks to this, I feel I will be able to approach studying Unreal Engine much more easily and structurally in the future. This course served as an excellent guide.

I’ve always wanted to try using an engine, and I feel like this is an opportunity to finally understand the internal workings of an engine that I had been ignoring for so long. I remember reading a book called 'Making a □□□ Game with C' in the past, and I recall it used the sleep() function for fixed frames. That's why the technique of specifying frames at the beginning was so fascinating to me.🤔 I used to always be interested but would end up turning away from game development after hitting the wall of the engine (its various features and interface...). However, thanks to your excellent explanations, my fear of engines seems to have faded a bit. Since you explain the lifecycle and operational processes, I think those who are intimidated by the vastness of an engine can get one step closer to game systems by building a lightweight engine themselves. Since the course takes place entirely within Visual Studio, I can pause the video, follow along with the coding, and learn while listening to the explanations. The lecture duration is a bit long, but personally, I found it great because I feel that typing along is more effective for learning. The lecture notes summarize what was covered and why, so I even used Gemini to create quizzes for review. Although you follow along while looking at the code, I think the learning effect will be better if you are somewhat familiar with C++ to keep up with the lecture pace. C++ is difficult for me, so my progress is a bit slow, but I am still very satisfied with the course. I will continue to study hard!! 🥰

Through this course, I was able to understand the basic overview of a game engine by building one myself, which allowed me to infer that commercial engines likely operate in a similar manner internally. In particular, while looking at the engine and renderer code structured using the Singleton pattern, I was once again able to feel how excellent code can be when a program is built through proper design. By changing project settings in Visual Studio, I learned practical knowledge not typically covered in school classes—such as managing project folders and building engine code as a separate DLL to link it rather than just running a simple executable. This made me feel like I’ve taken another step closer to becoming a professional developer. I believe this will be a great help to those who want to understand game engines.

Through Instructor RonnieJ’s ‘Game Engine Framework with C++’ course, I was able to build a very solid foundation in game engine development. While studying development, I had encountered various concepts related to game engines and CS, but I found it difficult to explain them accurately or organize them systematically. Through this class, I was able to clearly understand concepts that were previously confusing and organize them to the point where I can explain them myself. Beyond just understanding the overall flow of how an engine is structured and operates, I was able to learn the actual operating principles by directly implementing core concepts such as the game loop, actor and level-based world management, fixed-frame update structures, input processing systems, double-buffered rendering, and AABB collision detection. Designing the engine/content structure through DLL separation and implementing a custom type system (RTTI) was also very helpful. After completing this course, I am now learning Unreal Engine, and I naturally understood things like the DLL keywords and casting used in Unreal headers. Additionally, in an era overflowing with flashy graphics, I was satisfied to be able to create my own unique game by implementing a console-based game. The course structure was also very helpful for learning. By following the class materials provided for each lecture, the summaries at the bottom of the videos, and the checkpoints, I was able to review efficiently without missing important concepts. I believe this is not just a class where you simply make a game, but a lecture that allows you to understand the core structure of a game engine and elevate your mindset as a developer to the next level. For those who want to start game engine development or those studying development, this is a truly precious, unicorn-like lecture!!! I strongly recommend it to those who want to properly understand game engines and to developers who want to grow one step further!!

Everyone knows that understanding an engine is necessary for employment, but I think what that "understanding" actually means is quite abstract. This lecture explains the principles of how commercial game engines operate. It creates a game loop using concepts used in Unreal Engine (Actor, Level) and provides detailed explanations of RTTI concepts, which allow for a custom approach to downcasting. Additionally, when looking at Unreal Engine code, I didn't really know what the `ProjectName_API` prefix before class names was for, but after taking this lecture, I learned it is for using DLLs. I also gained a detailed understanding of the concept of separating engine code from content code.