ability-system
Use when building character abilities — Resource-based abilities with cost/cooldown/cast, buffs/debuffs, stat modifiers, gameplay tags, and HUD binding
jame581 · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add jame581/GodotPrompter --skill ability-system技能说明
name: ability-system description: Use when building character abilities — Resource-based abilities with cost/cooldown/cast, buffs/debuffs, stat modifiers, gameplay tags, and HUD binding
Ability System
Build a data-driven ability system from Godot-native parts: abilities are Resources, an AbilityComponent node owns and runs them, and effects/stats/tags compose on top. No third-party addon required.
Related skills: resource-pattern for the
Resourcedata containers, component-system for the component node pattern, event-bus for cross-system ability events, state-machine for caster states (e.g. casting/stunned), hud-system for cooldown UI.
1. Architecture overview
An ability system in Godot 4.x is built from three collaborating layers:
-
Data layer —
Ability(Resource): Each ability is aResourcesubclass with exported fields (ability_name,cost,cooldown,cast_time) and two methods:can_activate(caster) -> boolto validate preconditions, andactivate(caster) -> voidto execute the effect. Storing abilities as Resources lets designers create and balance them in the Godot editor without touching code. -
Behaviour layer —
AbilityComponent(Node): A single node added to any entity that should use abilities. It holds the granted ability set, enforces cost/cooldown, and drives theAbility.activate()call. Four signals keep the rest of the game informed without coupling:ability_activated(ability),ability_failed(ability, reason),cooldown_started(ability, duration), andcooldown_finished(ability). Grant new abilities at runtime withgrant(ability)and trigger them withtry_activate(ability_name). -
Effects layer — stat modifiers, buffs/debuffs, and gameplay tags: Abilities can read from and write to a caster's
StatSet(a Resource that owns a dictionary of namedStatModifierentries) to apply temporary or permanent stat changes. AGameplayTagContainernode (a child of the caster) gates activation — for example, a "stunned" tag can prevent any ability from firing. These three deep-dives are covered in the reference documents:- Stat modifiers and StatSet
- Gameplay tags and conditions
- HUD binding for cooldowns and resource bars
Core rule: Data in Resources, behavior in the component, communication via signals.
This separation means an Ability resource carries no Node references and can be safely duplicated, saved, and loaded as any other Godot Resource. The AbilityComponent owns runtime state (cooldown timers, active ability set), keeping Ability resources stateless and reusable across multiple casters simultaneously.
2. Abilities (cost / cooldown / cast)
GDScript
# ability.gd
class_name Ability
extends Resource
@export var ability_name: String
@export var cost: float = 0.0
@export var cooldown: float = 1.0
@export var cast_time: float = 0.0
# Override in subclasses or compose via exported effect resources.
func can_activate(caster: Node) -> bool:
return true
func activate(caster: Node) -> void:
pass
# ability_component.gd
class_name AbilityComponent
extends Node
signal ability_activated(ability: Ability)
signal ability_failed(ability: Ability, reason: String)
signal cooldown_started(ability: Ability, duration: float)
signal cooldown_finished(ability: Ability)
@export var resource_pool: float = 100.0
var _granted: Dictionary = {} # ability_name -> Ability
var _cooldowns: Dictionary = {} # ability_name -> seconds remaining
func grant(ability: Ability) -> void:
_granted[ability.ability_name] = ability
func _process(delta: float) -> void:
for name in _cooldowns.keys():
_cooldowns[name] -= delta
if _cooldowns[name] <= 0.0:
_cooldowns.erase(name)
if _granted.has(name):
cooldown_finished.emit(_granted[name])
func try_activate(ability_name: String) -> bool:
var ability: Ability = _granted.get(ability_name)
if ability == null:
return false
if _cooldowns.has(ability_name):
ability_failed.emit(ability, "on_cooldown")
return false
if resource_pool < ability.cost:
ability_failed.emit(ability, "insufficient_resource")
return false
if not ability.can_activate(get_parent()):
ability_failed.emit(ability, "conditions_unmet")
return false
resource_pool -= ability.cost
ability.activate(get_parent())
_cooldowns[ability_name] = ability.cooldown
cooldown_started.emit(ability, ability.cooldown)
ability_activated.emit(ability)
return true
C#
// Ability.cs
using Godot;
[GlobalClass]
public partial class Ability : Resource
{
[Export] public string AbilityName { get; set; } = "";
[Export] public float Cost { get; set; } = 0.0f;
[Export] public float Cooldown { get; set; } = 1.0f;
[Export] public float CastTime { get; set; } = 0.0f;
public virtual bool CanActivate(Node caster) => true;
public virtual void Activate(Node caster) { }
}
// AbilityComponent.cs
using Godot;
using System.Collections.Generic;
public partial class AbilityComponent : Node
{
[Signal] public delegate void AbilityActivatedEventHandler(Ability ability);
[Signal] public delegate void AbilityFailedEventHandler(Ability ability, string reason);
[Signal] public delegate void CooldownStartedEventHandler(Ability ability, float duration);
[Signal] public delegate void CooldownFinishedEventHandler(Ability ability);
[Export] public float ResourcePool { get; set; } = 100.0f;
private readonly Dictionary<string, Ability> _granted = new();
private readonly Dictionary<string, float> _cooldowns = new();
public void Grant(Ability ability) => _granted[ability.AbilityName] = ability;
public override void _Process(double
阅读完整来源 ↗