Dev Diary #3: Combat System - Echoes of Aethel

Combat Gameplay Systems AI

📅 March 15, 2026

Combat System: The Heart of Battle

By David — Lead Developer

Welcome to the third development diary for Echoes of Aethel. Today we're diving into the combat system — arguably the most important system in any action RPG. I'll walk you through the design philosophy, core mechanics, enemy AI, and the technical implementation behind every swing, parry, and Echo ability.

Combat in Echoes of Aethel is designed to be skill-based, responsive, and rewarding. We wanted players to feel like every victory was earned, not just handed to them through stats alone. The system rewards timing, positioning, and decision-making.

"I wanted combat to feel like a dance — a back-and-forth between the player and the enemy. You attack, they defend. They attack, you parry. Every action has a reaction. That's what makes it feel alive." — David, Lead Developer

🎯 Design Philosophy: Skill Over Stats

From the very beginning, we knew we wanted combat to be skill-based. We took heavy inspiration from games like Dark Souls, Elden Ring, and Sekiro — games where understanding enemy patterns and timing is more important than just having high numbers.

That doesn't mean stats don't matter — they do. But we've designed the combat so that a skilled player can overcome a stronger enemy with good timing and positioning. Conversely, a player with high stats but poor timing will still struggle against a well-designed enemy.

⚡ Combat Style Skill-Based / Timing

🎮 Core Mechanics 7 Core Systems

🧠 Enemy AI States 5 States

🔥 Echo Abilities 4 Elements

⚔️ Core Combat Mechanics

Here's a breakdown of the core combat mechanics we've implemented. Each one has been tested, iterated, and refined through hundreds of internal playtests.

🗡️ Light Attack Offensive

The basic attack — fast, low damage, and builds your combo meter. Light attacks are the bread and butter of combat. They allow you to chip away at enemies, interrupt their attacks, and set up heavier strikes.

Damage: 10 + Strength * 0.5 Speed: 0.35s animation Stamina Cost: 5 Combo Build: +15%

⚔️ Heavy Attack Offensive

A slower, more powerful strike that deals significantly more damage and can stagger enemies. Heavy attacks consume more stamina and have a longer wind-up, making them risky but rewarding.

Damage: 25 + Strength * 0.8 Speed: 0.8s animation Stamina Cost: 15 Stagger: 0.4s

🛡️ Parry Defensive

The highest skill-ceiling mechanic in the game. Perfectly timed blocks reflect enemy attacks, dealing damage back to the attacker and opening them up for a counter-attack. Normal parries block the attack and reduce stamina damage.

Perfect Window: 0.12s Normal Window: 0.25s Reflect Damage: 30% Stamina Cost: 8

💨 Dodge Roll Defensive

A quick roll that provides invincibility frames. The dodge roll is essential for avoiding heavy attacks and repositioning. It consumes stamina and has a brief recovery animation.

IFrames: 0.2s Distance: 4 studs Stamina Cost: 10 Recovery: 0.3s

🔮 Echo Abilities Utility

The signature mechanic of Echoes of Aethel. Echo Abilities are powerful elemental attacks tied to the old gods. Each ability has a unique effect, cooldown, and elemental type.

Fire: Damage over time Ice: Slow enemies Shadow: Life steal Light: Heal + damage

🔥 Combo System Offensive

Landing consecutive attacks builds your combo meter. At higher combo levels, your damage increases and you unlock special finisher moves. Taking damage resets the combo.

Max Combo: 20 hits Damage Bonus: +5% per 5 hits Finisher: At 15 hits Reset Timer: 2s

🔮 Echo Abilities: The Power of the Old Gods

Echo Abilities are the cornerstone of combat in Echoes of Aethel. Each ability is tied to one of the four old gods: Ignis (Fire), Glaciel (Ice), Nocturn (Shadow), and Lux (Light).

Here's the detailed breakdown of each Echo Ability, including their stats, effects, and use cases.

🔥 Ignis — Fireball Offensive

Launches a projectile of fire that explodes on contact, dealing damage over time to enemies in the blast radius. Effective against grouped enemies and enemies weak to fire.

Damage: 30 + Intelligence * 1.2 DoT: 5 damage/s for 3s Cooldown: 8s Mana Cost: 15

❄️ Glaciel — Ice Shard Defensive

Fires a projectile of ice that slows enemies on contact. Excellent for controlling enemy movement and creating distance between you and dangerous foes.

Damage: 15 + Intelligence * 0.8 Slow: -40% speed for 3s Cooldown: 6s Mana Cost: 10

🌑 Nocturn — Shadow Strike Offensive

A teleport attack that allows you to instantly close the gap between you and your target. Deals bonus damage from behind and leaches health from the enemy.

Damage: 20 + Agility * 1.0 Life Steal: 15% of damage Cooldown: 10s Mana Cost: 12

✨ Lux — Light Beam Utility

A beam of light that damages enemies and heals allies. The healing effect is doubled on yourself. This ability is essential for sustain in longer fights.

Damage: 25 + Wisdom * 1.0 Heal: 15 + Wisdom * 0.8 Cooldown: 12s Mana Cost: 18

🧠 Enemy AI: Behavior & States

Combat is only as good as the enemies you fight. We've spent a significant amount of time designing enemy AI that is challenging, fair, and varied. Each enemy type has a unique behavior tree with multiple states.

Here's the AI state machine that drives all enemy behavior:

Idle — Enemy is patrolling or standing still. Will transition to Alert if player is detected.
Alert — Enemy has detected the player. Will begin tracking and moving toward the player.
Engage — Enemy is in combat range. Will attack, block, and dodge based on its type.
Retreat — Enemy is low on health. Will attempt to create distance and heal if possible.
Death — Enemy is defeated. Plays death animation and drops loot.

                Lua
                -- Enemy AI State Machine
                local EnemyStates = {
                    Idle = {
                        Enter = function(self)
                            self.Humanoid.WalkSpeed = 2
                            self.Animation = "Idle"
                        end,
                        Update = function(self)
                            if self:DetectedPlayer() then
                                self:TransitionTo("Alert")
                            end
                        end
                    },
                    Alert = {
                        Enter = function(self)
                            self.Humanoid.WalkSpeed = 8
                            self.Animation = "Alert"
                        end,
                        Update = function(self)
                            self:MoveTowardPlayer()
                            if self:IsInCombatRange() then
                                self:TransitionTo("Engage")
                            end
                        end
                    },
                    Engage = {
                        Enter = function(self)
                            self.Humanoid.WalkSpeed = 12
                            self.Animation = "Combat"
                            self.LastAttackTime = 0
                        end,
                        Update = function(self)
                            local now = tick()
                            if now - self.LastAttackTime > self.AttackCooldown then
                                self:Attack()
                                self.LastAttackTime = now
                            end
                            if self.Health < 0.2 then
                                self:TransitionTo("Retreat")
                            end
                        end
                    },
                    Retreat = {
                        Enter = function(self)
                            self.Humanoid.WalkSpeed = 15
                            self.Animation = "Retreat"
                        end,
                        Update = function(self)
                            self:MoveAwayFromPlayer()
                            if self.Health > 0.5 then
                                self:TransitionTo("Engage")
                            end
                        end
                    },
                    Death = {
                        Enter = function(self)
                            self.Humanoid.WalkSpeed = 0
                            self.Animation = "Death"
                            self:DropLoot()
                            task.wait(2)
                            self:Destroy()
                        end
                    }
                }
            

🧠 AI Stats:

We currently have 12 enemy types with unique behavior trees, attack patterns, and stats. Each enemy type has been playtested extensively to ensure fair and challenging encounters.

👹 Enemy Types: Meet Your Foes

Here are the enemy types we've designed so far. Each one has a unique role in combat and requires a different strategy to defeat.

Shadow Stalker — Fast, agile, and attacks in packs. They use hit-and-run tactics and are vulnerable to fire abilities.
Crystal Golem — Slow but devastating. High health, high damage. Weak to lightning attacks.
Echo Wraith — A boss-type enemy that can phase through walls. Requires careful timing and positioning to defeat.
Plague Spawn — Weak individually but spawn in large numbers. They explode on death, dealing damage to nearby players.
Shadow Archer — Ranged attacker that fires shadow projectiles. Dodging and closing the distance is key.
Obsidian Knight — A heavily armored enemy with a large shield. Requires parrying or flanking to damage.

👾 Enemy Concepts — Shadow Stalker & Crystal Golem (Early sketches by Sarah)

⚙️ Technical Implementation: Behind the Scenes

Building a combat system in Roblox is no small feat. Here are some of the technical challenges we encountered and how we solved them.

1. 🎯 Hit Detection

Roblox's built-in collision detection isn't precise enough for a fast-paced combat system. We had to build our own custom hit detection system using raycasting and collision boxes.

                Lua
                -- Custom Hit Detection System
                local function CheckHit(origin, direction, range)
                    local raycastParams = RaycastParams.new()
                    raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
                    raycastParams.FilterDescendantsInstances = {character}
                    raycastParams.IgnoreWater = true

                    local raycastResult = workspace:Raycast(origin, direction * range, raycastParams)

                    if raycastResult then
                        local hit = raycastResult.Instance
                        if hit.Parent and hit.Parent:FindFirstChild("Humanoid") then
                            return hit.Parent
                        end
                    end
                    return nil
                end
            

✅ Solution:

Our custom hit detection system is now 99.7% accurate in playtests, with minimal false positives or negatives.

2. ⏱️ Network Latency

Roblox's networking can introduce latency, making timing-based mechanics (like parrying) feel unreliable. We implemented a client-side prediction system to compensate.

                Lua
                -- Client-Side Prediction for Parry
                local function ClientParry()
                    local predicted = true
                    local serverTime = game:GetService("ReplicatedStorage"):WaitForChild("ServerTime")
                    
                    -- Predict the server's state based on ping
                    local ping = game:GetService("Stats").Network.ServerStatsItem:GetValueString()
                    local predictedTime = serverTime.Value + ping

                    if predictedTime > 0.5 then
                        predicted = false
                    end

                    return predicted
                end
            

📊 Performance Stats:

Combat system maintains 60 FPS on average desktop and 45 FPS on mobile devices with our optimizations.

3. 🔄 Animation Blending

Smooth transitions between attack animations are critical for responsive combat. We used Roblox's AnimationTrack system with custom blending logic to ensure seamless transitions.

                Lua
                -- Animation Blending System
                local function PlayAnimation(character, animationId, blendTime)
                    local animator = character:FindFirstChildOfClass("Animator")
                    if not animator then return end

                    local animation = Instance.new("Animation")
                    animation.AnimationId = animationId

                    local track = animator:LoadAnimation(animation)
                    track:Play()
                    track.TimePosition = 0
                    track.Weight = 1

                    -- Blend with current animation
                    for _, activeTrack in ipairs(animator:GetPlayingAnimationTracks()) do
                        if activeTrack ~= track then
                            activeTrack:Stop(blendTime or 0.2)
                        end
                    end

                    return track
                end
            

📊 Current Status & Next Steps

Here's where we stand with the combat system as of April 2026:

✅ Core Combat — Light/Heavy attacks, parry, dodge roll, and combo system are fully implemented and polished.
✅ Echo Abilities — All four abilities are implemented and balanced.
✅ Enemy AI — 10 enemy types fully implemented with unique behavior trees.
🔄 Animation Blending — 90% complete. Needs polish on transition timing for some attacks.
🔄 Boss Encounters — 2 of 4 bosses fully implemented. Remaining: Obsidian Knight and the Final Boss.
📋 PvP System — In planning. Will be added post-launch.

Our next steps for the combat system:

Polish Animation Transitions — Ensure all attack animations blend smoothly.
Implement Boss Encounters — Build the remaining two bosses, including unique mechanics.
Balance Pass — Adjust damage values, cooldowns, and stamina costs based on playtest feedback.
Sound Design Integration — Add final sound effects for all attacks, abilities, and hit impacts.

🎯 Target:

We're aiming to have the combat system feature-complete by May 2026, with full polish and balancing completed in time for the closed beta.

🎯 Combat Pro Tips

Here are some tips from our internal playtesters to help you master combat in Echoes of Aethel:

Learn enemy patterns — Every enemy has a tell before they attack. Watch for the visual or audio cue and react accordingly.
Don't spam attacks — Spamming leaves you vulnerable. Mix light and heavy attacks to keep enemies guessing.
Use your Echo Abilities — They're powerful and can turn the tide of a fight. Don't save them for emergencies.
Manage your stamina — Running out of stamina leaves you unable to dodge or attack. Pace yourself.
Practice parrying — A well-timed parry can stagger even the toughest enemies.

💭 Final Thoughts

Building the combat system has been one of the most challenging aspects of developing Echoes of Aethel. There were moments when I wanted to scrap everything and start over. But seeing the combat system come together — the way the animations flow, the way the enemies react, the way players get better with practice — it's all worth it.

We've built a combat system that's deep, responsive, and rewarding. It's not perfect yet — but it's getting closer every day.

"Every battle is a story. Every victory is earned."

— David, Lead Developer
Next diary: Progression & Skill Trees — Coming Soon