Team of 13
September 2023 - April 2024
Skills Utilized: C++, Unreal Engine, Tools Programming

Introduction

Our team, consisting of programmers, designers, artists, and sound designers, collaborated to develop a game using Unreal Engine 5.2. Mercy for Machines is a 3rd person, narrative driven sci-fi horror game. My primary role was gameplay programming, and I also developed editor tools for designers and implemented destruction mechanics using Chaos physics.

Showcase

↑ Actor Collector

↑ Chaos Destruction

Technical Highlights

Actor Collector

While observing the map creation process, I noticed that manually maintaining lists of various actors was a frequent and inefficient task. To streamline this, I developed a tool that automatically collects and visualizes actors. Users can intuitively select actors using box and sphere volumes, with additional filtering options based on actor class, interface, or component class. To enhance visibility, I implemented an outline material for collected actors and a material effect that desaturates everything else in the scene. To minimize runtime overhead, the tool only retains the collected actor list in the final build without performing any additional operations.

Chaos Destruction

One gameplay sequence required a staircase to collapse, causing the player to fall. I immediately thought of Unreal Engine 5’s Chaos physics engine and its destruction system. While fracturing the mesh was straightforward, controlling how the pieces scattered proved challenging. I achieved the desired effect by carefully utilizing Anchor Fields and Master Fields to direct the fragments’ movement.

Conclusion

Mercy for Machines was a valuable experience that expanded my understanding of Unreal Engine 5. Developing the Actor Collector tool improved level design efficiency, while implementing Chaos Destruction deepened my knowledge of the engine’s physics system. Through this project, I gained hands-on experience with Unreal’s editor scripting, rendering, and physics features, further refining my ability to develop both gameplay mechanics and engine tools.

Solo Project
December 2024 - Current
Skills Utilized: C++, Unreal Engine, Concurrent Programming, Multiplayer Programming

Introduction

I really enjoyed playing Satisfactory, but I always thought it would be nice to see all my buildings I built on the map. This led me to create a mod, Cartograph, using the excellent framework, Satisfactory Mod Loader (SML).

I leveraged the speed of rendering textures and shapes on a render target to draw buildings on top of the existing map. To improve user experience, I added features such as toggling building visibility and filtering by height, seamlessly integrating with the base game.

Since buildings can number in the thousands, I optimized the mod by spreading the rendering across multiple frames and only redrawing the affected sections when buildings are placed or dismantled. Additionally, I made it to fully support multiplayer.

At the time of writing, the mod has reached over 18,000 downloads and has the highest conversion rate among mods, with a view-to-download ratio of about 4:1.

GitHub: https://github.com/yeshjho/Cartograph

Satisfactory Mod Repository (Where the mod is posted): https://ficsit.app/mod/Cartograph

Showcase

↑ The game's map with Cartograph. It draws the buildings, with a menu for toggling each building and filtering by height.

↑ The game's map without Cartograph. It doesn't draw any building.

Technical Highlights

Distributing Work Across Frames

Processing building data and rendering it on the map needed to be done asynchronously to avoid disrupting normal gameplay. For that, I wanted a method that allowed pausing midway while retaining local state, making coroutines an ideal choice. Using UE5Coro, I structured the rendering process to keep a per-frame time budget while maintaining a manageable code.

Partial Redraw Optimization

When buildings were placed or removed, redrawing only the affected areas was necessary for efficiency. To determine which buildings overlapped efficiently, I used a quadtree to store building data. However, simply redrawing those buildings led to misalignment at the boundaries. To solve this, I applied scissoring while drawing buildings on the render texture. Since Unreal Engine’s render target draw functions didn’t support scissoring, I created a custom class inheriting from FCanvasBaseRenderItem and manually called RHICmdList.SetScissorRect in the Render function.

Multiplayer Support

In multiplayer, clients only receive data for buildings near them for optimization, but the map needs to render all buildings. To support this, I had to implement a custom synchronization system. A major challenge was the large packet size required to send all building data at once. To resolve this, I split the data into smaller chunks and implemented a back-and-forth communication system between the client and server to receive the data over multiple packets.

Conclusion

Through this project, I gained experience in asynchronous rendering, spatial data structures, and network synchronization. Implementing coroutine-based rendering improved my understanding of managing time-constrained tasks efficiently. Working with quadtrees and custom rendering logic deepened my knowledge of optimizing large-scale dynamic rendering. Additionally, handling multiplayer data synchronization reinforced my skills in packet management and client-server communication. This project provided valuable insights into optimizing both performance and usability in a real-time environment.

Team of 4
August 2024 - December 2024
Skills Utilized: Python, Unreal Engine, Binary Manipulation 

Introduction

I enjoyed playing Abiotic Factor and wanted more of my friends to experience it, but the lack of Korean language support was a barrier. While the game supported eight languages, Korean wasn’t one of them. So, I decided—why not create a patch myself?

I began analyzing the game files and discovered that many texts and images weren’t exposed for localization. To work around this, I directly modified binary .uasset files and dealt with Unreal Engine’s IO Store files (.utoc and .ucas) as well as .pak archives. Using various tools, I unpacked and repacked these files and extracted .usmap data from the game.

Through this process, I gained a deeper understanding of how Unreal Engine packs and stores game assets.

GitHub Link: https://github.com/yeshjho/abiotic_factor_korean

Showcase

Technical Highlights

Overwriting Texts and Encoding

When replacing text with Korean, the game failed to display it correctly. Suspecting an encoding issue, I created a test Unreal Engine project and discovered that the game stored text in UTF-16 with the size recorded as a negative integer. Understanding this allowed me to properly overwrite text while maintaining compatibility.

UObject and Export Map Entry Manipulation

For assets containing multiple UObjects, such as levels and widgets, Unreal Engine stores individual object offsets and sizes within an export map. Modifying text changed the size of these entries, requiring me to adjust offsets for all subsequent entries to maintain file integrity.

↑Parse the existing entry map

↑And calculate new offsets and sizes after overwriting the strings.

Extracting Images and Dialogue Audio Files

Using CUE4Parse, I iterated through the game’s archive files, performed type checks, and decoded and extracted image and audio assets.

Conclusion

Through this project, I gained a deeper understanding of how Unreal Engine packs and stores files, as well as the intricacies of binary file manipulation. This experience strengthened my ability to analyze and modify game assets at a low level, enhancing my skills in reverse engineering and data structure handling.