Games

Games built on my own time.

Created couch multiplayer minigames with AI opponents.

  • Built Behavior Tree bots that predict the ball's path and steer it to targets.
  • Made data-driven Unreal GAS power-ups, with payload-configured variations.
  • Rubber-banded power-up odds with per-item score curves.

Made a third-person platformer shooter work on spherical planets.

  • Built A* on spherical planet meshes since Unity NavMesh couldn't handle it.
  • Made async planet transitions that generate and load the next planet mid-launch.
  • Built a sensor-based rigidbody controller for planets.
  • Generated cube-sphere planets at runtime, with a two-level LOD system.

Made physics-driven tennis play like an arcade game.

  • Created a fixed-step ball physics predictor that drives swings and AI.
  • Built a swing selector that syncs animations to predicted ball arrival.
  • Buffered swing input across Update/FixedUpdate, fixing lost presses above 50 fps.
  • Built a ball launch algorithm that fits angle and speed to the aimed box.

Designed an action shooter on the fusion method for educational games.

  • Built a collectable spawning system that adapts to the player's learning pace.
  • Created a weighted enemy spawner with rubber-banding and snowball prevention.
  • Pooled all runtime spawns, sizing the pools from measured expected growth.
  • Built an encrypted save system, composing eight subsystems on one interface.

Libraries

Reusable code for my games.

Created a reusable layer of systems and tools for my games.

  • Built a centralized object pool serving Unreal actors, UObjects and UMG widgets.
  • Created a data-driven FSM that reuses states: allocation-free after init.
  • Gave UMG widgets a component system for reuse: animation, fades, locking.
  • Built local-multiplayer controller management with device-stable seats.

Collected and refined frequently used systems into a base for my games.

  • Designed a framework that provides DI and a service locator with scoped lifecycles.
  • Built gameplay systems: ragdolls, interactions, ground detection and modifiers.
  • Built a Unity visual logger that records and replays debug-draw commands.
  • Created data-driven catalogs for color palettes, enums and strings.

Systems

Low-level code.

Created a ray tracer for spheres and triangles from first principles.

  • Wrote a recursive CPU ray tracer in C++, rendering reflective scenes.
  • Implemented Phong and Lambert shading with per-object material properties.
  • Added an OpenGL-style matrix stack for transforming geometry per object.