Unreal Gameplay Ability System

Name: Unreal Gameplay Ability System
Author: quodsoler

Work with the Unreal Gameplay Ability System: GameplayAbility, GameplayEffect, AttributeSet, GameplayTags, buffs, debuffs, cooldowns and…

You say

Buy it · $24 Read it before you buy $24 Written by quodsoler · unverified publisher

Context cost: 13.9k tokensestimated from the bundle, loaded when it triggers
Bundle: 4 files · 55.7 kBtext throughout, nothing executable
Licence: MITpaid listing
Last change: —v1.0.0
Servers it uses: Noneruns standalone

What it does

Use this skill when working with GAS, Gameplay Ability System, GameplayAbility, GameplayEffect, AttributeSet, GameplayTags, ability system, buffs, debuffs, cooldowns, or attribute modification. See references/ for detailed setup patterns, effect configuration, and ability task usage.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Expertise

Domain judgement the base model does not have.

unrealgasgameplaycpp

Filed under

Gaming & Entertainment

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md19.0 kB · 493 lines

--- name: ue-gameplay-abilities description: "Use this skill when working with GAS, Gameplay Ability System, GameplayAbility, GameplayEffect, AttributeSet, GameplayTags, ability system, buffs, debuffs, cooldowns, or attribute modification. See references/ for detailed setup patterns, effect configuration, and ability task usage." metadata: version: 1.0.0 ---

8# Gameplay Ability System (GAS)

10You are an expert in Unreal Engine's Gameplay Ability System (GAS).

12## Context Check

14Before proceeding, read .agents/ue-project-context.md to determine:

15- Whether the GameplayAbilities plugin is enabled

16- Which actors own the AbilitySystemComponent (PlayerState vs Character)

17- The replication mode in use (Minimal, Mixed, Full)

18- Any existing AttributeSets or ability base classes

20## Information Gathering

22Ask the developer:

231. What type of abilities are needed? (active, passive, triggered, instant)

242. What attributes are required? (health, mana, stamina, custom stats)

253. Is this multiplayer? If so, which actors carry the ASC?

264. Are cooldowns and costs required, or is this a passive/trigger system?

275. Do abilities need prediction (local-only feedback before server confirms)?

29---

31## GAS Architecture Overview

33GAS has three pillars that live on UAbilitySystemComponent (ASC):

35| Pillar | Class | Purpose |

36|--------|-------|---------|

37| Abilities | UGameplayAbility | Logic for what happens when activated |

38| Effects | UGameplayEffect | Data-driven stat mutations (instant, duration, infinite) |

39| Attributes | UAttributeSet | Float properties representing character stats |

41GameplayTags thread through all three as requirements, grants, and blockers.

43---

45## GAS Setup

47### 1. Enable the Plugin

49Enable GameplayAbilities in .uproject Plugins array, then in [ProjectName].Build.cs:

50```csharp

51PublicDependencyModuleNames.AddRange(new string[]

52{

53 "GameplayAbilities", "GameplayTags", "GameplayTasks"

54});

55```

57### 2. AbilitySystemComponent Ownership

59**PlayerState (recommended for multiplayer):** ASC persists across respawns because PlayerState

60is not destroyed on death. Use this for player characters in networked games.

62**Character/Pawn:** Simpler. Use for AI characters or single-player games where persistence

63across respawns is not required.

65See references/gas-setup-patterns.md for full initialization sequences for both patterns.

67### 3. IAbilitySystemInterface

69Every actor that owns or exposes an ASC must implement IAbilitySystemInterface:

71```cpp

72#include "AbilitySystemInterface.h"

74UCLASS()

75class AMyCharacter : public ACharacter, public IAbilitySystemInterface

76{

77 GENERATED_BODY()

78public:

79 virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override

80 { return AbilitySystemComponent; }

81 UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "GAS")

82 TObjectPtr<UAbilitySystemComponent> AbilitySystemComponent;

83};

84```

86### 4. Replication Modes

88Set on the ASC after creation (server-side only):

90```cpp

91// In BeginPlay or PossessedBy on the server:

92AbilitySystemComponent->SetReplicationMode(EGameplayEffectReplicationMode::Mixed);

93```

95| Mode | When to Use |

96|------|-------------|

97| Minimal | AI or non-player actors; no GE replication to simulated proxies |

98| Mixed | Player-controlled characters (owner gets full info, others get minimal) |

99| Full | Non-player games or debugging; all GEs replicate to all clients |

100

101### 5. InitAbilityActorInfo

102

103Must be called on both server and client after possession. Call in PossessedBy (server)

104and OnRep_PlayerState (client): ASC->InitAbilityActorInfo(OwnerActor, AvatarActor).

105See references/gas-setup-patterns.md for full dual-path code with respawn handling.

106

107---

108

109## GameplayAbilities

110

111### Subclass UGameplayAbility

112

113```cpp

114#include "Abilities/GameplayAbility.h"

115

116UCLASS()

117class UMyFireballAbility : public UGameplayAbility

118{

119 GENERATED_BODY()

120public:

121 UMyFireballAbility();

122 virtual void ActivateAbility(const FGameplayAbilitySpecHandle Handle,

123 const FGameplayAbilityActorInfo* ActorInfo,

124 const FGameplayAbilityActivationInfo ActivationInfo,

125 const FGameplayEventData* TriggerEventData) override;

126 virtual void EndAbility(const FGameplayAbilitySpecHandle Handle,

127 const FGameplayAbilityActorInfo* ActorInfo,

128 const FGameplayAbilityActivationInfo ActivationInfo,

129 bool bReplicateEndAbility, bool bWasCancelled) override;

130 // Ability Tasks — async building blocks for latent abilities:

131 // UAbilityTask_WaitTargetData — waits for targeting (crosshair/AoE confirm)

132 // UAbilityTask_WaitGameplayEvent — waits for a GameplayEvent tag (e.g., anim notify)

133 // UAbilityTask_WaitDelay — simple timer

134 // UAbilityTask_PlayMontageAndWait — montage with callbacks (see ue-animation-system)

135 // See references/ability-task-reference.md for full list and custom task pattern.

136 // CancelAbility — called by CancelAbilitiesWithTag or ASC->CancelAbility(Handle)

137 // Internally calls EndAbility with bWasCancelled=true. Override to add cleanup:

138 virtual void CancelAbility(const FGameplayAbilitySpecHandle Handle,

139 const FGameplayAbilityActorInfo* ActorInfo,

140 const FGameplayAbilityActivationInfo ActivationInfo,

141 bool bReplicateCancelAbility) override;

142 // Custom activation guard — return false to block activation beyond tag checks

143 virtual bool CanActivateAbility(const FGameplayAbilitySpecHandle Handle,

144 const FGameplayAbilityActorInfo* ActorInfo, /*...*/) const override;

145 // Must call Super first. Add custom checks (resource availability, cooldown state).

146protected:

147 UPROPERTY(EditDefaultsOnly, Category = "GAS")

148 TSubclassOf<UGameplayEffect> DamageEffect;

149};

150```

151

152### ActivateAbility Pattern

153

154```cpp

155void UMyFireballAbility::ActivateAbility(const FGameplayAbilitySpecHandle Handle,

156 const FGameplayAbilityActorInfo* ActorInfo,

157 const FGameplayAbilityActivationInfo ActivationInfo,

158 const FGameplayEventData* TriggerEventData)

159{

160 // 1. Commit: validates and applies cost + cooldown

161 if (!CommitAbility(Handle, ActorInfo, ActivationInfo))

162 {

163 EndAbility(Handle, ActorInfo, ActivationInfo, true, true);

164 return;

165 }

166 // 2. Apply effect / spawn projectile / etc.

167 FGameplayEffectSpecHandle Spec = MakeOutgoingGameplayEffectSpec(DamageEffect, GetAbilityLevel());

168 FGameplayAbilityTargetDataHandle TargetData =

169 UAbilitySystemBlueprintLibrary::AbilityTargetDataFromActor(

170 ActorInfo->AvatarActor.Get());

171 ApplyGameplayEffectSpecToTarget(Handle, ActorInfo, ActivationInfo, Spec, TargetData);

172 // 3. End (instant abilities end immediately; latent abilities wait for tasks)

173 EndAbility(Handle, ActorInfo, ActivationInfo, true, false);

174}

175```

176

177CommitAbility is shorthand for CommitAbilityCost + CommitAbilityCooldown. Call them

178separately when needed -- e.g., commit cost without starting cooldown for a channeled ability,

179or commit cooldown without cost for a free ability.

180

181### Instancing and Net Execution Policy

182

183Set in the ability constructor:

184

185```cpp

186UMyFireballAbility::UMyFireballAbility()

187{

188 // InstancedPerActor - one instance per actor; cheapest for persistent abilities

189 // InstancedPerExecution - new instance each activation; safe for concurrency

190 // NonInstanced - CDO runs the ability; no per-execution state

191 InstancingPolicy = EGameplayAbilityInstancingPolicy::InstancedPerActor;

192

193 // LocalPredicted - client runs immediately, server validates (player abilities)

194 // ServerOnly - authority only, no prediction

195 // LocalOnly - local client only (UI, cosmetic)

196 // ServerInitiated - server activates, clients run non-authoritative predicted copy

197 NetExecutionPolicy = EGameplayAbilityNetExecutionPolicy::LocalPredicted;

198}

199```

200

201### Granting and Activating Abilities

202

203```cpp

204// Grant (server/authority only):

205FGameplayAbilitySpecHandle Handle = ASC->GiveAbility(

206 FGameplayAbilitySpec(UMyFireballAbility::StaticClass(), 1 /*Level*/));

207

208ASC->TryActivateAbility(Handle); // by handle

209ASC->TryActivateAbilityByClass(UMyFireballAbility::StaticClass()); // by class

210ASC->TryActivateAbilitiesByTag( // by tag

211 FGameplayTagContainer(FGameplayTag::RequestGameplayTag("Ability.Skill.Fireball")));

212```

213

214### Ability Tags

215

216Configure in the ability CDO constructor:

217

218```cpp

219// Tags this ability grants to its owner while active:

220ActivationOwnedTags.AddTag(FGameplayTag::RequestGameplayTag("Ability.Active.Casting"));

221// Tags that prevent this ability from activating:

222ActivationBlockedTags.AddTag(FGameplayTag::RequestGameplayTag("State.Stunned"));

223// Cancel other active abilities with these tags on activation:

224CancelAbilitiesWithTag.AddTag(FGameplayTag::RequestGameplayTag("Ability.Active.Melee"));

225```

226

227---

228

229## GameplayEffects

230

231### Duration Policies

232

233| Policy | Behavior |

234|--------|----------|

235| Instant | Executes once; modifies attribute base value permanently |

236| HasDuration | Active for set duration; uses DurationMagnitude (seconds) |

237| Infinite | Active until RemoveActiveGameplayEffect is called |

238

239### Applying Effects

240

241```cpp

242FGameplayEffectContextHandle Ctx = ASC->MakeEffectContext();

243FGameplayEffectSpecHandle Spec = ASC->MakeOutgoingSpec(UMyDamageEffect::StaticClass(), Level, Ctx);

244

245// SetByCaller: inject runtime magnitude using a tag key

246Spec.Data->SetSetByCallerMagnitude(

247 FGameplayTag::RequestGameplayTag("SetByCaller.Damage"), 75.f);

248

249ASC->ApplyGameplayEffectSpecToSelf(*Spec.Data.Get()); // self

250ASC->ApplyGameplayEffectSpecToTarget(*Spec.Data.Get(), TargetASC); // target

251

252ASC->RemoveActiveGameplayEffect(ActiveHandle); // by handle

253ASC->RemoveActiveGameplayEffectBySourceEffect(

254 UMyDamageEffect::StaticClass(), nullptr); // by class

255```

256

257See references/gameplay-effect-reference.md for stacking (AggregateBySource/AggregateByTarget),

258periodic effects (damage over time), UGameplayEffectExecutionCalculation (complex modifier logic),

259conditional effects, and immunity.

260

261---

262

263## AttributeSet

264

265### Define Attributes

266

267```cpp

268// MyHealthSet.h

269#include "AttributeSet.h"

270#include "AbilitySystemComponent.h"

271

272// Convenience macro - define in your project headers

273#define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \

274 GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \

275 GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \

276 GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \

277 GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName)

278

279UCLASS()

280class UMyHealthSet : public UAttributeSet

281{

282 GENERATED_BODY()

283public:

284 UMyHealthSet();

285

286 // Called BEFORE any modification - use for clamping current value

287 virtual void PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue) override;

288

289 // Called AFTER instant GE executes - react to changes (death, events)

290 virtual void PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data) override;

291

292 virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;

293

294 UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Health, Category = "Health")

295 FGameplayAttributeData Health;

296 ATTRIBUTE_ACCESSORS(UMyHealthSet, Health)

297

298 UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_MaxHealth, Category = "Health")

299 FGameplayAttributeData MaxHealth;

300 ATTRIBUTE_ACCESSORS(UMyHealthSet, MaxHealth)

301

302protected:

303 UFUNCTION()

304 void OnRep_Health(const FGameplayAttributeData& OldHealth);

305

306 UFUNCTION()

307 void OnRep_MaxHealth(const FGameplayAttributeData& OldMaxHealth);

308};

309```

310

311In the .cpp, implement replication and callbacks:

312

313```cpp

314void UMyHealthSet::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const

315{

316 Super::GetLifetimeReplicatedProps(OutLifetimeProps);

317 DOREPLIFETIME_CONDITION_NOTIFY(UMyHealthSet, Health, COND_None, REPNOTIFY_Always);

318 DOREPLIFETIME_CONDITION_NOTIFY(UMyHealthSet, MaxHealth, COND_None, REPNOTIFY_Always);

319}

320

321void UMyHealthSet::OnRep_Health(const FGameplayAttributeData& OldHealth)

322{

323 GAMEPLAYATTRIBUTE_REPNOTIFY(UMyHealthSet, Health, OldHealth);

324}

325

326// PreAttributeChange: clamp CURRENT value before any modification

327void UMyHealthSet::PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue)

328{

329 Super::PreAttributeChange(Attribute, NewValue);

330 if (Attribute == GetHealthAttribute())

331 NewValue = FMath::Clamp(NewValue, 0.f, GetMaxHealth());

332}

333

334// PostGameplayEffectExecute: react AFTER instant GE modifies base value (damage, death)

335void UMyHealthSet::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)

336{

337 Super::PostGameplayEffectExecute(Data);

338 if (Data.EvaluatedData.Attribute == GetHealthAttribute())

339 {

340 SetHealth(FMath::Clamp(GetHealth(), 0.f, GetMaxHealth()));

341 if (GetHealth() <= 0.f) { /* trigger death */ }

342 }

343}

344```

345

346### Register AttributeSet on ASC

347

348```cpp

349// In PlayerState or Character constructor:

350// Option 1: CreateDefaultSubobject (auto-registered as subobject)

351HealthSet = CreateDefaultSubobject<UMyHealthSet>(TEXT("HealthSet"));

352

353// Option 2: Runtime (authority only) — create and register as subobject:

354UMyHealthSet* NewSet = NewObject<UMyHealthSet>(this);

355AbilitySystemComponent->AddSpawnedAttribute(NewSet);

356

357// Read attribute value:

358float CurrentHealth = AbilitySystemComponent->GetNumericAttribute(

359 UMyHealthSet::GetHealthAttribute());

360```

361

362**Multiple AttributeSets**: An ASC can host multiple UAttributeSet subclasses (e.g.,

363UHealthSet + UOffenseSet), each auto-discovered via subobject enumeration. Never register

364two instances of the same class -- the second is silently ignored.

365

366---

367

368## GameplayTags

369

370### Defining Tags

371

372In Config/DefaultGameplayTags.ini or via native tags (preferred for code references):

373

374```cpp

375// MyGameplayTags.h

376#include "NativeGameplayTags.h"

377UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Ability_Fireball)

378UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_State_Stunned)

379

380// MyGameplayTags.cpp

381UE_DEFINE_GAMEPLAY_TAG_COMMENT(TAG_Ability_Fireball, "Ability.Skill.Fireball", "Fireball ability")

382UE_DEFINE_GAMEPLAY_TAG_COMMENT(TAG_State_Stunned, "State.Stunned", "Actor is stunned")

383```

384

385### Tag Matching

386

387"A.1".MatchesTag("A") == true (hierarchical); MatchesTagExact requires exact match.

388

389```cpp

390FGameplayTagContainer Tags;

391Tags.HasTag(FireballTag); // parent-aware match

392Tags.HasTagExact(FireballTag); // exact only

393Tags.HasAny(OtherContainer);

394Tags.HasAll(OtherContainer);

395

396// Query ASC:

397ASC->HasMatchingGameplayTag(TAG_State_Stunned);

398ASC->GetOwnedGameplayTags(); // FGameplayTagContainer

399

400// Listen for changes:

401ASC->RegisterGameplayTagEvent(TAG_State_Stunned, EGameplayTagEventType::NewOrRemoved)

402 .AddUObject(this, &AMyCharacter::OnStunnedTagChanged);

403```

404

405### Loose Tags (Manual, No GE)

406

407```cpp

408ASC->AddLooseGameplayTag(TAG_State_Stunned);

409ASC->RemoveLooseGameplayTag(TAG_State_Stunned);

410// Loose tags are NOT replicated by default. To replicate a loose tag,

411// pass EGameplayTagReplicationState::TagOnly as the third argument:

412ASC->AddLooseGameplayTag(TAG_State_Buffed, 1, EGameplayTagReplicationState::TagOnly);

413ASC->RemoveLooseGameplayTag(TAG_State_Buffed, 1, EGameplayTagReplicationState::TagOnly);

414```

415

416---

417

418## GameplayCues

419

420Cosmetic-only (particles, sounds, decals). Never affect gameplay state. Tag prefix: GameplayCue.

421

422In the GE asset, add FGameplayEffectCue entries with GameplayCueTags and level range.

423

424```cpp

425// Burst (one-shot):

426ASC->ExecuteGameplayCue(FGameplayTag::RequestGameplayTag("GameplayCue.Hit.Fire"),

427 ASC->MakeEffectContext());

428

429// Persistent (add/remove pair):

430ASC->AddGameplayCue(FGameplayTag::RequestGameplayTag("GameplayCue.Buff.Speed"));

431ASC->RemoveGameplayCue(FGameplayTag::RequestGameplayTag("GameplayCue.Buff.Speed"));

432

433// Poll active state:

434bool bActive = ASC->IsGameplayCueActive(FGameplayTag::RequestGameplayTag("GameplayCue.Buff.Speed"));

435```

436

437Cue Notify classes:

438- AGameplayCueNotify_Actor: Persistent/looping. Overrides OnActive, WhileActive, OnRemove.

439- AGameplayCueNotify_Static: Burst/one-shot. Overrides OnExecute.

440

441Place cue notify assets in /Game/GAS/GameplayCues/ for UGameplayCueManager auto-discovery.

442

443---

444

445## Common Mistakes and Anti-Patterns

446

447**ASC ownership confusion:** Implement IAbilitySystemInterface on the class that *owns* the ASC

448(PlayerState), not just on the Pawn. Otherwise UAbilitySystemBlueprintLibrary lookups fail.

449

450**InitAbilityActorInfo only on server:** Clients need it too. Call in OnRep_PlayerState (client)

451and PossessedBy (server). Skipping client-side init breaks attribute replication on the owning client.

452

453**GEs applied before InitAbilityActorInfo:** The ASC is not ready; attributes are not registered.

454Always complete init before granting abilities or applying effects.

455

456**PreAttributeChange vs PostGameplayEffectExecute:** PreAttributeChange fires on every current-value

457change (aggregator updates, buff adds/removes). Use it only to clamp. Use PostGameplayEffectExecute

458to react to instant GE base-value execution (damage, death). Never send game events from PreAttributeChange.

459

460**Forgetting CommitAbility:** Without it, the ability runs but consumes no mana and starts no cooldown.

461

462**Loose tags not replicated:** AddLooseGameplayTag does not replicate by default. Pass

463EGameplayTagReplicationState::TagOnly as the third argument to replicate the tag, or grant

464via a GE for fully replicated effect-driven tags.

465

466**Effect stacking overflow:** Stacks beyond LimitCount are silently rejected. Use GetCurrentStackCount

467to inspect the current level before attempting further stack applications.

468

469**GAS with AI:** AI has no PlayerState. Place the ASC on the AICharacter, call

470InitAbilityActorInfo(AICharacter, AICharacter), set replication mode to Minimal.

471

472**Hot-joining**: Late-joining clients receive active effects via FActiveGameplayEffectsContainer

473replication after InitAbilityActorInfo. Never apply startup GEs in BeginPlay unconditionally

474-- server-only, or late joiners double-apply.

475

476---

477

478## Reference Files

479

480- references/gas-setup-patterns.md — Full ASC ownership patterns and initialization sequences

481 for PlayerState and Character owners, multiplayer and single-player

482- references/gameplay-effect-reference.md — Effect configuration, stacking rules, modifier

483 types, execution calculations, periodic effects, conditional effects

484- references/ability-task-reference.md — Common built-in ability tasks and custom task patterns

485

486## Related Skills

487

488- ue-actor-component-architecture — Component setup and subobject registration

489- ue-networking-replication — Replication modes, RPCs, prediction keys

490- ue-animation-system — Montage ability tasks (PlayMontageAndWait)

491- ue-gameplay-framework — PlayerState ownership pattern, Pawn/Controller lifecycle

492- ue-cpp-foundations — Delegate binding, UPROPERTY macros, TSubclassOf patterns

493

In the file

SKILL.md1,808 words

Files4

LicenceMIT

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈90

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

13,835

on trigger

The instruction body and 3 supporting files, read only when the skill fires.

7.0%

of a 200k window

Ten skills this size would take about 70% of the window before you open a file.

050k100k150k200k context window

13.9k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

15 other skills in Gaming & Entertainment

What is in the bundle

4 files, 55.7 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

SKILL.md19.0 kB
references/ability-task-reference.md12.9 kB
references/gameplay-effect-reference.md13.7 kB
references/gas-setup-patterns.md10.1 kB

What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 4 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$24 once

Unreal Gameplay Ability System · MIT · quodsoler

one-time

Price$24 once

LicenceMIT — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery release of 1.x through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Version1.0.0

Publishedno release date on file

Price$24

Referencequodsoler/unreal-gameplay-ability-system

Versions

v1.0.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v1.0.0

No earlier releases have been published to the marketplace.

Pinning

Put quodsoler/unreal-gameplay-ability-system@1.0.0 in the install command to hold this exact version. Without the suffix you get whatever is current the day you install, and nothing moves under you afterwards.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

quodsoler

Publishes on mcprush.

0 servers listed2 skills listednot claimed

Profile

Publisher

Servers0