Homses Battle
Project Info
Gameplay/AI Programmer
Action
Unreal Engine
w/ AngelScript
Ongoing
1 Programmer
Project Summary
Homses Battle is a solo-developed action game prototype focused on building a robust foundation for fast-paced, character-driven gameplay. The project began in mid-January and is currently centered on designing responsive modular abilities, and a flexible component system to support future expansion.
Originally envisioned as a testbed for the Capabilities Pattern, Homses Battle has grown into a sandbox for gameplay experimentation - prioritizing player control, combat flow, and dynamic systems architecture. AI behaviors remain a planned milestone once the gameplay loop is fully established and refined.
Built using Hazelight’s modified version of Unreal Engine 5 with AngelScript support, the project takes advantage of scripting flexibility to rapidly prototype complex mechanics and build reusable systems.
Capabilties
How and Why Capabilities
In Homses Battle, the Capabilities Pattern serves as the backbone for managing gameplay mechanics. A Capability represents a self-contained module of behavior, such as movement, attacking, or special abilities like dashing or jumping. Each capability handles its own logic, making the system highly modular, reusable, and easy to manage.
Capabilities are attached to entities through a Capability Component, which acts as a manager, enabling or disabling specific capabilities based on the game's context. For example, the MovementCapability handles character locomotion, while the RangedAttackCapability manages projectile-based attacks. This structure allows for the seamless addition, removal, or modification of abilities without affecting other systems.
A key design principle is that Capabilities handle all the logic, while Components act solely as data holders. This separation ensures that each capability remains completely self-contained, focusing purely on behavior. All relevant data and context are stored in components, making it easy to share information between capabilities or with other systems when needed. This approach enhances code clarity, promotes reusability, and simplifies data management across the project.
The system integrates perfectly with AngelScript, allowing for real-time modification during runtime. Capabilities can be toggled on or off dynamically by temporarily setting ShouldActivate to false and ShouldDeactivate to true. This instantly deactivates the selected capability, preventing it from reactivating until the values are changed back. The combination of this runtime flexibility and the modular nature of capabilities makes iteration and development of new systems extremely fast and efficient.
Why it's effective
-
High Modularity: Each capability operates independently, allowing easy updates or expansions without impacting other systems.
-
Self-Contained Logic: Capabilities manage all behavior, while components store data, ensuring clear separation of concerns and easy maintenance.
-
Shared Data Context: Components hold data that can be accessed by multiple capabilities or systems, improving reusability and reducing redundancy.
-
Runtime Flexibility: Capabilities can be toggled on and off during gameplay, making testing and iteration quick and effective.
-
Reusability: The same capability can be applied across different characters or entities, reducing redundant code.
-
Seamless Integration with AngelScript: Real-time adjustments without the need for recompiling, speeding up development workflows.
-
Scalable Design: Adding new mechanics is straightforward: New capabilities can be introduced without overhauling existing code.
-
Improved Debugging: Isolated functionality makes it easier to identify and fix issues without unintended side effects.
Abilities: Modular and Data-Driven Design
The ability system in Homses Battle has evolved into a modular, highly data-driven architecture that separates behavior, configuration, and logic for maximum flexibility and reusability.
​From Capabilities to Abilities
At its core, the system builds upon the Capabilities Pattern by introducing AbilityCapabilities, which encapsulate gameplay logic such as dashing, jumping, or spawning projectiles. These are paired with AbilityModifier objects that define the specific parameters—like damage, cooldowns, and visual effects—enabling designers to configure and reuse behavior across characters or game states without duplicating code.
​
-
Slot-Based Assignment & Runtime Flexibility:
Abilities are assigned to characters via a slot-based mapping in the AbilityComponent. Each slot is associated with an AbilityData asset that defines both the capability class and its unique configuration. This makes it easy to customize loadouts or design contextual ability sets for different gameplay scenarios. At runtime, abilities can be dynamically added or removed. When added, the component registers the linked capability with the CapabilityComponent, and when removed, it automatically cleans up unless the same capability is still in use by another ability.
-
Input-Driven Activation:
Every tick, the system evaluates which abilities are active based on player input and internal conditions. The AbilityComponent exposes functions like IsAbilityActive and GetAbilityData, providing other systems with clean, reliable access to ability states—whether for visual feedback, combat logic, or AI decision-making.
Data-Driven Ability Example: Lobbed Projectile
Projectiles: Modular, Bahaviour-Driven Logic
Lobbed Projectile with gravity and trajectory visual.
Repeating and Bouncing Projectile. Different behaviour only using other data, no logic changes.
The projectile system in Homses Battle is built using a modular component-based architecture that separates behavior, visuals, and data - allowing for flexible creation of complex projectile types with minimal code changes.
Behaviors via Capabilities
Each projectile is constructed from a set of capabilities, with each capability handling a specific aspect of its behaviour such as movement, gravity, collision, damage, or special effects. This approach avoids hardcoding functionality into a single projectile class and instead allows for easy separation of logic into behaviour-driven logic components.
​
For Example:
-
ProjectileBounceCapability handles bounce count and energy retention.
-
ProjectileGravityEffectCapability applies scaled gravity curves.
-
ProjectileDamageCapability determines hit effects, damage values, and applies gameplay effects like knockback or stun.
These are automatically attached and configured via data assets when the projectile is spawned.
​
Data-Driven Initialization
Projectiles are spawned using a ProjectileData asset, which serves as a container for:
​
-
Visual configuration (mesh, scale, material)
-
Physics and behaviour components (bounce, drag, gravity)
-
Hit response logic (damage values, on-hit effects)
-
Spawn conditions (offset, velocities, actor tracking logic)
This enables a single behaviour to be reused in different contexts changing the associated data asset.
​
Work in Progress & Next Steps
While Homses Battle is moving along well, it remains an active work in progress. Core gameplay systems, including the modular ability framework, data-driven projectile logic, and movement mechanics, are now functional and form a good foundation for further development.
The next major focus will be on expanding the depth of player abilities and beginning integration of more complex AI systems using the same modular, capability-driven approach. Improvements to combat feel, visual feedback, and system scalability are also on the roadmap.
Development is ongoing and transparent. The project is open-source and available on GitHub, where progress can be followed and contributions are welcome.