Hyunwoo Yang

Quarter-view city-builder simulation inspired by Caesar 3 and SimCity 2000, built from the ground up on a custom C++/OpenGL engine. As Tech Lead I owned the engine and technical architecture across rendering, simulation, and AI.

### Architecture & Leadership

• Owned the overall technical architecture, defining module boundaries and the main update/render loop so simulation, rendering, and AI could evolve independently
• Set technical direction for a team of 7: made the core engine and tooling decisions, ran code reviews, and coordinated integration of each member's systems into a single build
• Onboarded teammates with little graphics or engine experience, writing usage examples and lightweight docs so they could contribute gameplay and AI features without touching low-level code

### Engine — Dokev

• Grew my Computer Graphics course renderer into a reusable engine, Dokev, wrapping raw OpenGL state and draw calls into single-function shape drawing, coloring, and texturing
• Built core engine modules: a scene graph for hierarchical transforms, a resource manager for textures and shared assets, and an event bus for decoupled communication between systems
• Added a pan/zoom camera and texture atlasing so tile, building, and agent sprites could share a single bound texture

### Rendering — GPU Instancing

• Replaced the immediate-mode 2D renderer with a GPU-instanced batch renderer across the 67×67 isometric tile world, cutting draw calls from 9,256 to 11 per frame at an identical ~9,300 quad workload and improving frame time from 58.6 ms to 38.3 ms (17 → 26 FPS)
• Eliminated all 46,353 per-draw uniform uploads and cut redundant texture binds from 9,232 to 157 per frame by packing a 3×3 transform, four UV pairs, tint, and SDF parameters into a 96-byte instance record, batching up to 10,000 quads across 64 texture slots in a single DrawElementsInstanced call
• Unified textured sprites and SDF primitives — circles, rectangles, lines — into one instance buffer so UI and debug geometry batch through the same path instead of falling back to per-shape draw calls

### Pathfinding — A*

• Profiled the pathfinder in-engine and found 91% of all node-reset work was wasted: 1,934,759 grid nodes cleared to expand only 160,603 over a nine-second window, because every query cleared the full 4,489-tile grid before knowing which region the search would visit — a two-tile walk reset 4,489 nodes to expand three
• Rewrote the search with generation-stamped lazy initialization so reset cost scales with the visited region instead of the whole grid, and replaced the per-expansion heap-allocated neighbor vector with a stack array, removing all 160,172 allocations observed in that window
• Cut cost per expanded node from 1.6 µs to 0.84 µs in-game, and 31.2 µs to 18.7 µs per query on NPC-range paths in a controlled 2,000-query benchmark, with node resets falling from 4,489 to 145 and heap allocations to zero — verified to return identical paths across all 2,000 queries
• Isolated a 179 ms frame spike where 184 simultaneous path requests consumed 83% of the frame, resetting 825,976 grid nodes and allocating 95,973 times in a single frame, and projected the rewrite to cut that spike to 111 ms by reducing its pathfinding cost from 148 ms to 80 ms

### Instrumentation

• Built an in-engine profiling HUD with runtime A/B switches for the renderer and the pathfinder, tracking draw calls, batch flushes, uniform uploads, texture binds, and per-query search cost, with CSV capture for offline comparison
• Used it to establish that rendering was no longer the bottleneck after instancing, redirecting optimization effort to the CPU-side simulation

### Simulation & Agent AI

• Implemented a seven-state NPC agent FSM covering work, rest, gambling, and fire response, driven by A* over terrain with height-based climb costs
• Built 22 simulation managers for population, happiness, taxation, immigration, weather, and disaster events

LostGuns is a self-driven copy-study project where I recreated the core mechanics of the mobile game LostGuns in Unity, pushed all the way to functional online multiplayer over Unity Relay so friends could connect and play together. The game features a pre-match lobby, 4 combat maps, 2 characters sharing a 9-weapon roster, and a Gun Game mode that unlocks each weapon in sequence on kills.

### Networking — NGO + Unity Relay

• Built netcode on Netcode for GameObjects 2.11.1 over Unity Relay, syncing position/rotation, animation state, HP, team, and match/bomb progress through NetworkVariables and [ServerRpc]/[ClientRpc] calls, with a low-level FastBufferWriter channel reserved for chat
• Split authority by concern: movement is client-authoritative (ClientNetworkTransform, each owner writes its own transform) for responsive controls, while hit registration is fully server-authoritative — HP is a server-write-locked NetworkVariable, and all bullet and melee damage resolves only on the server
• Cut redundant transform traffic by suppressing NetworkTransform updates below a 0.005 position / 0.01 scale threshold, while disabling interpolation on bullets specifically so hits register instantly instead of lagging behind their travel

### Lag Compensation — Rewind-Based Hit Registration

• Found that the original hit-scan mixed a fixed rewind offset with both the target's current and rewound positions, so shots could land on hits that looked dodged on the client's screen
• Rewrote it around a per-shot view delay — RTT/2 plus a two-tick interpolation buffer, clamped to 0.4 s — recomputed by the server every FixedUpdate, resolving player hitboxes only against the rewound position while static geometry like walls still raycasts against the current position, and extended the position-history buffer from 0.5 s to 1 s to support it
• Unified melee attacks onto the same rewind path, and designed grenades — a delayed-area attack — to rewind against the victim's own screen state instead, separating aimed-attack and timed-attack fairness into two distinct resolution models

### Session Flow

• Built the join flow on UGS anonymous auth plus PlayFab, with the host creating a Relay allocation and join code and clients joining directly with it, then routing through a dedicated Plaza lobby scene where teams ready up before picking a map

A minigame collection built in C++ with Raylib. Rather than one big game, I used it as a sandbox to implement two self-contained games, each exploring a distinct technical problem — pathfinding at scale and constraint solving.

### 01  Shooter  // A* + Flow Field

A top-down shooter on a procedurally generated 40×40 tile grid — tiles are randomized and the map is regenerated until an A* check confirms a path exists corner to corner. The player aims and fires at the cursor; hitting an enemy scores and removes it, touching one ends the run, and clearing every enemy or reaching the finish tile wins.

• Started with each enemy running its own A* search toward the player every time it needed a new tile, which duplicates the same search once per enemy — O(enemies × grid) in the worst case
• Replaced it with a single flow field shared by every enemy: one BFS pass from the player's tile floods a cost value outward to every walkable tile, then each cell's direction is set toward its lowest-cost neighbor — a one-time gradient that turns "find a path" into "read a direction," cutting the per-frame cost to O(grid) regardless of enemy count
• Enemies that spawn on or next to an obstacle snap to the nearest walkable tile via an 8-directional BFS fallback

### 02  Sudoku  // Backtracking

A playable 9×9 Sudoku board with cell selection, same-number highlighting, and a run timer.

• Generates a fresh solved board every run with randomized backtracking — shuffling the candidate order at each cell before recursing — then clears 45 cells to produce the puzzle
• Reuses the same row/column/3×3-box constraint check for both generation (rejecting placements that break Sudoku's rules) and win detection (validating the completed board), instead of duplicating that logic

2D vertical-scrolling escape-action game. Dr. Water climbs a volcano on the verge of eruption, fighting through enemies and boss encounters with an arsenal of weapons. Awarded Microdegree Expo Best Award 2023.

### QA & Playtesting

• Ensured gameplay quality through systematic playtesting across all stages and bosses
• Identified and documented bugs in enemy behaviour, weapon interactions, and level progression
• Worked closely with engineers to validate fixes and regression tests

### Gameplay Programming

• Implemented boss attack mechanics — multi-phase patterns with distinct telegraphed moves, timed attack sequences, and phase transitions tied to boss health
• Built enemy attack mechanics for regular encounters, including projectile spreads, charge attacks, and spawn/wave behavior
• Implemented the player's 5 weapons, each with its own damage, fire rate, and projectile behavior

Won Microdegree Expo Best Award, 2023.

A top-down action-survival shooter set in a dragon-vs-dragon world. The player carves through enemy waves across multiple stages, capped by two boss fights.

• Led development of core gameplay systems including enemy wave mechanics and stage progression
• Directed technical architecture as Tech Lead, coordinating system integration across a team of 4
• Designed and implemented 6 distinct enemy attack patterns, tuning telegraphs, timing, and projectile behavior for each
• Built the player's arsenal of 5 weapons, each with its own fire rate, damage, and projectile pattern

A single-page math toolkit that shows its work, built to make my Computer Graphics coursework easier to get through. It covers the linear-algebra and calculus operations I kept reaching for, and renders every intermediate step as a proper formula instead of a final answer.

Four calculators — matrix, calculus, vector, and 3D graphics — sharing one step-by-step solver and KaTeX rendering. Full Korean / English toggle across the UI, solution steps, and error messages.

• Implemented matrix routines (determinant, inverse, rank, LU, SVD, eigenvalues) with per-row-operation step output
• Built the calculus engine — derivatives, integrals, limits, Taylor series — on top of math.js with live LaTeX preview
• Wrote real-time Three.js viewers for the MVP pipeline, lighting/shadow mapping, and vector dot/cross products
• Added a runtime i18n layer (ko/en) and a responsive layout that re-fits the 3D viewport to any window ratio
• Cut the initial JS payload 83% — 504 KB to 85 KB gzip — with route-level code splitting, deferring Three.js, math.js and KaTeX to the routes that actually need them
• Took the project from first prototype to production build and static deployment on GitHub Pages entirely on my own

At DigiPen Korea, we held a weekly "Hangout" every Tuesday or Wednesday — professors and students stayed late at school, working on our own projects or sharing a meal together. It became some of the most focused, productive time I've ever had, and that memory still means a lot to me. I built this timer to hold onto that feeling, and I still use it today to study while looking back on those hangouts.

A web app that turns the Pomodoro technique into a shared activity. Built end-to-end as a full-stack developer, with AI-assisted iteration on UX flows and backend logic.

• Designed and built the full stack — frontend, real-time sync, and persistence
• Implemented shared room logic so friends can join and run a timer together
• Used Claude and Gemini Pro for rapid prototyping and code review
• Shipped as a deployable web application used by DigiPen peers