Modern C++ Development
Expertise in C++17/20 features, STL, smart pointers, and design patterns for robust applications.
Section 1
C++ Programming Competencies
SOLID Principles
Implementing SOLID Principles in C++ to create robust and maintainable code.
C++/UI State Synchronization
Ensured low-latency UI feedback by managing game state in C++ setters, utilizing the **Unreal Reflection System** to reliably update Blueprint UMG widgets.
Always Learning
I'm not afraid of learning new things, always eager to expand my skillset.
Section 2
Design & Planning: UML/Relational Modeling
UML/Relational Modeling
Detailed C++ class architecture, relational DB design before implementation ensuring SOLID principles and clean code.
UI & UX Design
Wireframing and creating high fidelity mockups for game HUDs and menus.
C++ Architectural Depth & Projects
Showcasing projects, architecture, and code maturity. Click any row for a deep dive.
Project
Field
Information
The Blind Necromancer
Game development in TDD fashion
Game Systems Library in C++
You wander blindly through a mystery world.
The Blind Necromancer is a C++ game library that I've been working on to practice Test-Driven Development (TDD) in a game development context. I very much enjoyed working on this project as it allowed me to focus on building clean, modular C++ systems with a strong emphasis on testing and code quality.
Removing the need for visuals enabled me to focus on the core game logic and architecture, ensuring that my C++ code is robust, maintainable, and well-tested. By writing tests first, I can ensure that my code is designed for testability and that I catch bugs early in the development process. This project has been a great way for me to hone my C++ skills and practice good software engineering principles.
Please do give it a try and let me know what you think!
Welcome to The Blind Necromancer!
Type a command (try "move north") and press Enter.
>
The Eternal Legion
System Architecture & Scalable Object-Oriented
Design (OOP)
A horde-survival game in Unreal engine with C++
Necromancy Wave game
This is very much a work-in-progress, concept game where I focus on building scalable C++ systems around object-oriented design (OOP) and game architecture.
By structuring gameplay systems around clear, data-driven states (e.g. movement, targeting, AI, and abilities), I can expose just the right parameters and events to the animation layer. This separation of concerns keeps the C++ side focused on authoritative game rules while giving animators clean hooks (tags, notifies, and state enums) to sync motion, VFX, and UI feedback without constantly revisiting core code.
Professional Experience: Bridging JavaScript/Lua to C++ Systems
Leveraging architectural maturity, data integrity focus, and pipeline awareness from my professional background to build robust game systems. Click any row for a deep dive.
Experience Area
Transferable Skillset
Application in C++ / Unreal Engine
Advanced Geo-Mapping
Spatial Data Structures, Rendering
Optimization.
World Partition, Complex
Coordinate Systems.
Deep Dive: Data Optimization & World Partition
Transforming conceptual ideas into high-performance prototypes. I engineered a global hexagonal grid system where each individual cell features:
- Procedural Cube Coordinates: Optimized (qrs) logic for pathfinding and spatial visuals.
- Dynamic Topography: Heights mapped directly from real-world elevation data.
- Satellite Fidelity: WorldCover colors synchronized with global satellite imagery.
By leveraging PostGIS and a Martin tile server, I streamlined the pipeline from GeoJSON to vector tiles—enabling full-world generation in seconds.
Geospatial queries? Multiplayer? I build robust, scalable solutions. If you have a technical challenge, I’ll get it done.
Casino Game Systems (Lua)
FSMs, Logic Integrity, Animation Sync.
Robust Finite State Machines,
Animation linking.
Deep Dive: Finite State Machine (FSM) Design
I specialized in designing rock-solid Finite State Machines (FSMs) for complex logic (e.g., Poker and Blackjack). The primary focus was transaction integrity and reliable state synchronization with visual assets.
This proves/helps my competence in building reliable, state-driven C++ game systems and creating interfaces. that ensure game logic and animations remain perfectly in sync, enhancing player experience.
Horizontally scaled for hundreds of game tables!
Due to roblox restrictions, this project development was stopped. Roblox game
Here's a compilation video! Project active: 2023 – 2024Backend API Design (Node.js)
Architectural Maturity, State Management
(SOLID).
Designing modular C++
Subsystems,
Reliable State Synchronization.
Deep Dive: Architectural Maturity & Subsystems
Three years of professional experience designing scalable, modular APIs using Node.js instilled a firm commitment to clean interfaces, SOLID principles, and dependency management.
This maturity is critical for game development, directly informing the architecture of clean C++ Engine Subsystems that are loosely coupled, unit-testable, and maintainable. I build systems that scale, not just features that work!
Containerization (Docker)
Deployment Reliability, CI/CD Pipeline.
Managing Unreal Build Farms,
Optimizing Build Workflow.
Deep Dive: Build Reliability & CI/CD
My proficiency with Docker and deployment pipelines (CI/CD) ensures I understand how to create standardized, reproducible environments.
The ability to manage complex toolchains and dependencies directly translates to optimizing Continuous Integration/Deployment (CI/CD) pipelines in a C++ environment, meaning fewer "works on my machine" bugs.
Hobby 3D Pipeline Awareness
Asset Pipeline & Animation Integration.
Communicating with Artists.
Deep Dive: Artist-Programmer Collaboration
Beyond code, my hobby knowledge (Sculpting, Retopology, Animation) provides an understanding of asset constraints and the artist's workflow. For smooth collaboration between the programming and art teams.