Overview
Role: Gameplay & QA Programmer
Project Overview
Project Name: Lost Light
Genre: 2D Platformer Action Game
Development Environment: C++, using a custom game engine named 'Dragon'
Core Features:
Built on top of the proprietary 'Dragon' engine, featuring a structure that separates engine infrastructure from game logic.
The Dragon engine provides core functionalities such as application lifecycle management, window handling (GLFW), OpenGL rendering (Glad), input processing, sound (SFML), sprite animation, and a component-based game object system.
The Lost Light game implements platformer mechanics, various enemy characters with distinct behavioral patterns, multiple player weapon types and states, items, and a chunk-based level loading system.
Sep 2022 ~ June 2023
My achievements
Custom Engine Development (Dragon): Built a proprietary game engine encompassing core systems like rendering, input, audio, state management, and a game object/component architecture. This demonstrates a deep understanding of game engine fundamentals.
Rendering System: Implemented an OpenGL-based Batch Renderer for efficient drawing of 2D sprites. Created abstraction classes for Shaders, Vertex Buffers, Index Buffers, Vertex Arrays, and Textures. Included a RenderCamera for managing view transformations.
Game Object & State Management: Designed a flexible component-based Game Object system. Implemented hierarchical state machines for both the overall game flow (GameStateManager) and individual Game Objects (ObjectStateManager), enabling complex behaviors such as player states and boss phases.
Chunk-Based Level Loading: Developed a system to parse text files (Parser, .txt level data) and dynamically load/unload game chunks (ChunkLoader, ChunkManager) based on player position. This efficiently manages memory and performance for potentially large levels.
Gameplay Systems: Implemented core platformer mechanics, collision detection/resolution, multiple enemy types with basic AI and state-driven behaviors, player shooting mechanics with different bullet types, an item drop system, and a checkpoint/respawn system.
Editor Functionality: Built a level editor (EditorState, EditorChunk) integrated with the game engine using ImGui, demonstrating UI integration and tooling development skills. Included file dialogs for loading/saving level files.
Challenges
Engine Architecture Design: Designing and implementing a reusable game engine from scratch involves significant architectural decisions (ECS vs. OOP, renderer design, state management), which can be complex to get right. Maintaining separation between the engine (Dragon) and the game (Lost Light) was also crucial.
Batch Renderer Implementation: Optimizing draw calls using batch rendering requires careful management of vertex data, texture switching (handling texture limits, e.g., textureMaxCount), and shader uniforms, which can be technically challenging.
Collision Detection/Resolution: Implementing a robust 2D collision system, especially with potentially many objects in a chunk-based system, requires efficient spatial partitioning or sorting (e.g., the X-position sort in GameObjectManager::CollideTest) and correct resolution logic for various object interactions (player-block, player-enemy, bullet-enemy, etc.).
State Machine Complexity: Managing nested states (Game States containing Objects with their own states) and transitions between them, especially with asynchronous events or complex conditions, can lead to complex logic and potential bugs (e.g., ensuring correct state entry/exit behavior).
Memory Management: Dynamically loading/unloading level chunks requires careful memory management to avoid leaks or excessive fragmentation. Using std::shared_ptr helps but requires correct usage. Engine components like GameObjectManager and ComponentManager also involve managing object lifetimes.
Wonhyeong Chae