Level & Design Philosophy
The goal of this project was to create a tower defense experience that is easy to read, strategically engaging, and satisfying to master. This was a two-week project in Unreal Engine where I worked as the primary designer in close collaboration with a programmer. Within that timeframe, the focus was on giving players clear information and meaningful choices while still leaving room for experimentation and personal strategy.
Clarity and consistency guided most design decisions. Enemy paths are clearly defined, tower placement follows a grid-based system, and visual feedback such as range indicators and placement outlines helps players quickly understand what is possible and why. Verticality was introduced as a strategic layer, where towers placed on higher ground gain increased effective range, encouraging thoughtful positioning instead of flat, uniform layouts.
A key challenge was balancing accessibility with depth under a tight schedule. To address this, systems were kept simple to understand but designed to scale through wave progression, enemy variety, economy pacing, and terrain usage. This kept the experience engaging without becoming overwhelming or unfair.
Learn more about my level design process here.
Level Design
I designed levels to be clear and readable while supporting long-term strategic planning. Layouts were built iteratively in Unreal using blockouts and Modeling Mode to shape paths, choke points, and buildable areas directly in-engine.
Readability and balance were constant priorities. Enemy paths communicate direction and pressure points, while grid-based tower placement ensures consistency and fairness. Elevation adds a strategic layer, allowing towers placed on higher ground to gain increased range.
Between waves, players have time to explore the map, so I placed landmarks and visual points of interest beyond the main paths. This helped give the levels a sense of place and rewarded curiosity without distracting from core gameplay.
To reinforce strategic depth, I designed levels around choke points, vertical variation, and overlapping tower coverage. When certain layouts made it too easy to lock down enemy waves, I adjusted path width, spacing, angles, and elevation to reintroduce meaningful trade-offs.
Throughout development, I evaluated player flow and spatial clarity through testing and iteration. Adjustments were based on how players interpreted paths, responded to wave pressure, and positioned towers in practice.
Learn more about my overall level design process here, or click “Read more” on the images for an in-depth explanation of the design.
Game Design
I designed and helped implement core systems including tower placement, targeting logic, wave progression, enemy behaviors, resource management, and lose conditions. Each system was built to support strategic decision-making and provide clear feedback to the player.
I worked closely with a programmer to define tower targeting priorities, enemy behaviors, and how economy and wave scaling influence difficulty. The goal was to keep systems easy to understand while still allowing depth through varied tower roles, enemy compositions, and pacing.
Balancing was an ongoing process. To support rapid iteration, key values such as tower cost, damage, range, attack rate, enemy health, and wave scaling were exposed in the editor. This allowed faster testing and reduced dependency on code changes.
Technical Design & UI/UX
Because this was a two-person project, I was responsible for all UI and UX implementation. Using Unreal’s UMG system, I built the main menu, level select, pause and options menus, HUD elements, and a lore widget to establish tone and context at the start of the game.
Performance and clarity were key priorities. UI was built using overlays instead of canvas panels to reduce draw calls, and feedback systems such as tower placement indicators, range visualization, health bars, and wave information were designed to communicate game state clearly under pressure.
On the technical side, I structured Blueprint systems to be clean and maintainable. This included consistent naming conventions, reusable functions, and editor-facing parameters to reduce spaghetti code and improve iteration speed. These workflow decisions helped keep the project scalable and readable despite the short timeframe.