Tactical Combat | Grid-based | Party & Card build
Concept
Development time - 10 Weeks
Hand of Aeralon is a turn-based, grid-based tactical combat game where you control a small squad and win fights through positioning, smart targeting, and chaining abilities at the right moment. It’s built around “board game” style combat: characters stand on tiles, you pick actions by clicking tiles, and every move is about controlling space and setting up the next play.
Combat is heavily ability-driven. Each character has a set of abilities with different targeting rules, cooldowns, and status-effect interactions. A big focus is clarity and feedback: when you hover targets you get previews for what will be hit, how much damage/heal will happen, and which characters will be affected. VFX and audio are timed to match animations so abilities feel punchy and readable, and camera shake is used selectively on heavier hits to sell impact.
The core loop is basically: read the board state, preview options, commit to a play, and watch the combo resolve—where small positioning choices and debuffs/buffs can swing the entire fight.
Game Trailer
Full Game
Main Contribution
Combat Interface
Developed the grid-based combat interaction system, including tile hovering, character selection, and a combat state machine.
Ability System
Built a modular ability framework with base classes, range calculations, AOE patterns, and 16 individual abilities.
Combat Feedback
Implemented ability previews through tile recoloring, HP-bar previews & effects, VFX, and camera shakes.
My Role
My main role in this project was gameplay and systems programming, with a primary focus on developing the game’s combat through a modular combat system.
In addition to programming, I also took on a larger leadership role within the project. Since the scope was very ambitious for a 10-week production, I felt it was important to help create structure and keep the team moving toward a strong result. This included contributing to the overall system design through an early UML diagram, making sure everyone stayed active and participated in daily stand-ups, reviewing other team members’ code, and helping fix bugs outside my own areas.
For marketing, I was solely responsible for recording and editing the in-game footage used in the trailer shown above.
Showcase
Combat board interface & Visual Feedback
Using a state-based approach made the combat interface easier to structure and expand. Since combat is grid-based, nearly all player interaction happens through tiles, which respond differently depending on the current state. See combat at different stages in the playthrough.
Ability System
The ability system was built to support a wide range of unique combat actions while staying modular, scalable, and easy to iterate on. Below is a showcase of the abilities I implemented and the feedback systems that support them.
Barbarian
Skullsplitter
Rupture of the Wilds
Earthquake
Roar of the Ancients
Bard
Song of Renewal
Inspiring Anthem
Resonant Blast
Dissonant Chord
Rogue
Sandfang Strike
Throwing Knives
Desert's Grasp
Veil of Dust
Sorceress
Arcane Bolt
Lightning Storm
Flame Surge
Emberwake
Visual Feedback & Healthbar
Development Process
Goal
My goal was to create a combat experience that felt satisfying to use while remaining easy for the player to learn and understand. At the same time, I wanted the underlying systems to be scalable, modular, and easy for other systems, such as UI, VFX, audio, and AI, to hook into. It was also important that the structure was clear enough for other developers on the team to work with comfortably.
Solution
I approached this by spending a lot of time planning the structure before implementation. The combat interface was designed to handle board interaction, feedback, and combat rules, while each character had its own ability handler responsible for managing ability use. The abilities themselves were built as modular, data-driven objects so they could support a wide range of functionality without becoming tightly coupled.
Implementation
The combat board interface used a state-driven structure to control what was interactable in different combat situations, including tile interaction, character selection, and board feedback for ability range and area.
Each character had an AbilityHandler that managed available abilities, target validation, previews, and execution.
Abilities were built using ScriptableObjects with a shared base class and subclasses such as Single Target and AOE. Area abilities used interchangeable AOE patterns to define affected tiles, while targeting rules were handled through separate range calculation classes that could be swapped per ability.
The system also supported previewing ability effects before use, including potential HP changes, while VFX, audio, animation, and camera shake were triggered during execution to keep feedback synchronized with gameplay.
Reflection & Learnings
This project taught me how important planning and structure are when building larger systems that need to be scalable and usable by other parts of the game. At the same time, it also showed me that no amount of planning can cover every future case. Some parts still needed refactoring as new needs appeared during development.
The biggest lesson I took away is that programming is an iterative process. Strong planning is essential, but trying to design a perfect system for every possible scenario is unrealistic. A big part of development is knowing when to refactor, when to adapt, and when a solution is good enough for the needs of the project.
Contributions List
- Combat Board Interface
-
Built the combat board interface, including a state machine that controlled what was interactable across different combat states.
-
Implemented tile hover and click interactions for the combat grid.
-
Added board highlight and color feedback for abilities, including range, radius, and affected areas.
-
Implemented character selection handling across different combat states.
- Ability System -
-
Developed the core ability system architecture.
-
Built an ability handler for each character to manage ability usage, range calculation, target validation, and pre-cast feedback.
-
Created a shared ability base class with specialized subclasses such as Single Target, AOE, and Directed AOE.
-
Implemented all 16 abilities in the game, plus one additional ability that was later removed during development.
-
Built reusable AOE pattern systems for different ability shapes and behaviors.
-
Built reusable range calculation systems for different targeting rules.
-
Implemented ability previews, allowing players to see an ability’s effect on hover before committing to it.
-
Created execution data handling for passing ability result data into other systems, such as the combat log.
-
Integrated ability animation and audio triggers.
- Visual Feedback
-
Built the ability VFX pipeline and created unique visual effect sequences for every ability in the game.
-
Added visual feedback for characters affected by the currently selected ability.
-
Implemented a camera shake manager to handle combat camera shake events.
-
Created unique camera shake profiles for each ability to match their visual impact.
- Health Bar & Combat Readability
-
Expanded the health bar system with delayed damage feedback, using an additional slider to show previous HP after taking damage.
-
Implemented preview HP feedback, allowing players to see how a target’s health bar would change before using an ability.
- Additional Contributions
-
Contributed smaller fixes and polish across existing systems, including lava and poison tile outlines, traits, animations, and damage text.
-
Helped create the first version of the project-wide UML diagram.
-
Created in-engine camera shots for the trailer.