Developer settings and combat data

This page covers the configuration objects an attack reads as it moves from a request into EffectContext and then into an attack result. Runtime flow is in Combat Flow and attack results and Attack definitions and requests.

`UGCS_DeveloperSettings`

A project-level UDeveloperSettings with Config=Game. Its Details name is Generic Combat System Developer Settings. Read it with the Blueprint node Get GCS Developer Settings or UGCS_DeveloperSettings::Get(). It only exposes two global lookup / debug switches. It does not own Combat Flow, processors, or attack tables.

Field	Purpose	When to change	Misconfiguration
`CharacterMeshLookupTag`	Component tag used to find the character’s main skeletal mesh. Default `"Main"`. Function library code calls `GetComponentsByTag` with this name.	The character mesh is tagged something other than `Main`.	A mismatched tag makes melee / bullet socket origins fall back to the actor origin or a null component.
`bDisableAffiliationCheck`	Debug switch that turns off affiliation filtering so cross-team damage and lock-on are allowed.	Local tests for friendly fire or training dummies.	Leaving it on in default ini makes `GCS:FilterTask (Affiliation)` always pass, including in multiplayer.

After edits, check [/Script/GenericCombatSystem.GCS_DeveloperSettings] in DefaultGame.ini. The character mesh tag must match this value.

`FGCS_AttackDefinition`

A Data Table row (display name GCS Attack Definition). Melee requests, bullet definitions, and the function library all read “what to apply on hit” from here. Lifecycle: authored in a table → a request or bullet carries the row handle → applying a GE writes the handle into FGCS_ContextPayload_Combat → Combat Flow / processors read it back.

TargetEffectClass and TargetEffectContainer are not exclusive. When both are valid they apply independently, and the handle is written into each spec’s EffectContext. AttackTags are appended as dynamic AssetTags. SetByCallerMagnitudes only writes entries whose Value > 0.

Field	Purpose	When to change	Misconfiguration
`AttackTags`	Describes the attack (melee/ranged, slash/strike).	Processors or tag relationships branch on attack type.	An empty container leaves Cue / Event processors matching only other aggregated tags.
`SetByCallerMagnitudes`	Fills SetByCaller on the spec.	Damage scales, force factors.	Entries with `Value <= 0` are skipped, so the map looks configured but does nothing.
`TargetEffectClass`	Soft-referenced GE class applied to the hit target.	One hit changes one attribute set, such as health.	An unloaded soft reference never builds that GE.
`TargetEffectClassLevel`	Level for that GE. Default 1. Values `< 1` use the ability level.	Scaling with ability level.	`0` falls through to ability level; if that is also unset the spec is weaker than expected.
`TargetEffectContainer`	A GGA effect container applied alongside `TargetEffectClass`. Container GE level follows the ability.	Damage plus a status, or when a TargetingPreset picks targets.	An invalid container leaves only the single GE. Both empty means the hit has no settlement GE.
`TargetGameplayCues`	Cue tags to execute on the target.	Hit flashes, material pulses.	A non-empty list replaces the built-in GameplayCue processor’s own cue list.
`KnockbackDistance` / `KnockbackMultiplier`	Knockback distance (cm) and multiplier. Defaults 100 / 1. Multiplier ClampMin=1.	A project processor or hit-react ability reads knockback from the definition.	The plugin has no built-in knockback processor. Numbers alone do not move the target.
`HitStallingDuration`	Hit-stall seconds. `<= 0` disables it.	Heavy hits that freeze animation.	Project code must read it. Changing the field does nothing without a reader.
`HitPlayRateFactor`	Hit animation play-rate factor. Clamped 0.1–0.9, default 0.1.	Slow-mo with the stall.	Same as above: definition payload only.
`NativeExtension`	C++ `TInstancedStruct<FGCS_AttackDefinitionExtension>`.	Native code adds fields to the row.	Blueprint cannot read this struct.
`Extension`	Blueprint `FInstancedStruct`.	Designers add custom row data.	The wrong struct type makes `Get` fail and selection / settlement treat it as missing.

Melee stores the row handle on UGCS_AttackRequest_Melee. Ranged hangs the same row on FGCS_BulletDefinition.AttackDefinition. The bullet system builds GEs on the authority and calls AddAttackHandleToGameplayEffectSpec.

Attack requests

UGCS_AttackRequest_Base is an Abstract, Const, DefaultToInstanced, EditInlineNew UObject. The base GetAttackDefinitionHandle is empty; concrete types must supply a row handle. GetAttackDefinition() reads the table and returns a default empty definition when the row is invalid.

`UGCS_AttackRequest_Melee`

An animation window or Collision Trace Task carries this request while the window is active. TracesToControl decides which traces start and stop; AttackDefinitionHandle points at an FGCS_AttackDefinition row.

Field	Purpose	When to change	Misconfiguration
`TracesToControl`	Trace tags this window controls.	One weapon has blade and tip traces.	Tags that do not match `FGCS_TraceDefinition.TraceTag` leave the window idle.
`AttackDefinitionHandle`	Attack-definition row used after a hit.	One row per melee move.	An empty handle leaves GEs without combat context, so processors read an empty definition.

`UGCS_AttackRequest_Bullet`

A bullet request also decides spawn origin, aim, and whether a lock is required. GetTargetingTransform, GetWeaponTargetingSourceLocation, and GetPawnTargetingSourceLocation can be overridden. Socket fields hide when the source is CameraTowardsFocus. AI or non-locally-controlled shots spawn on the authority and skip local trajectory prediction.

Field	Purpose	When to change	Misconfiguration
`BulletDefinitionHandle`	Bullet-definition row.	One row per ammo type.	An empty handle or wrong row struct never spawns a bullet.
`TargetingSourceType`	Where the launch transform comes from. Default `PawnForward`. Options: camera toward focus, pawn/weapon forward or toward focus, `Custom`.	Muzzle follows the hand, camera, or lock-on.	`Custom` without overriding `GetTargetingTransform` yields a wrong origin.
`SourceComponentLookupTagName`	Tag used to find the source component.	The mesh is not the default component.	`None` falls back to the pawn / weapon default location.
`SourceSocketName` / `SourceWeaponSocketName`	Character or weapon socket. Missing sockets fall back to the source location.	Muzzle, bowstring.	A typo spawns from the hand or weapon origin and looks like “shots go wide.”
`LocationOffset`	Extra offset on the source location.	Nudge the muzzle forward.	A large offset can spawn inside the shooter’s collision.
`bRequireTargeting`	Whether a locked target is required.	Lock-on shots, guided attacks.	When true, an empty `GetTargetActor` will not aim at a lock.
`TargetingPreset`	A targeting preset used only for this shot.	A one-off search that does not use the pawn’s targeting component.	An empty preset plus `bRequireTargeting` leaves no target.

GetAttackDefinitionHandle forwards to the bullet definition’s AttackDefinition. Settlement GEs still come from that row, not from a second copy on the request.

`FGCS_AttackResult`

One result produced by Combat Flow after an attribute PostGameplayEffectExecute (and after a local predicted execute when the predictive-execute component is present). Authoritative results replicate through the FGCS_AttackResultContainer FastArray. Predicted results stay local until a matching PredictionKey arrives and sets bWasPredicated.

Field	Purpose	When it appears	Misconfiguration
`OptionalObject`	Optional object related to the attack.	Project flow attaches a process object.	The pointer may be invalid after replication. Do not treat it as authoritative state.
`EffectContextHandle`	GE context that carries the combat payload, hit result, and causer.	Every result built from an attribute callback.	If the attack-definition handle was never written, processors read an empty definition.
`AggregatedSourceTags` / `AggregatedTargetTags`	Aggregated source / target tags. `HandleAttackResult` also merges payload `DynamicTags`.	Processors with tag requirements.	Empty source tags make Event / Cue processors with a query never match.
`bConsumed`	Local: whether this result was consumed. Not replicated.	A processor or project mark “already used.”	Consumed results do not enter processors again.
`bWasPredicated`	Local: the replicated result matched a local prediction via PredictionKey. Not replicated.	After a predicted hit lines up with authority.	When true, LocalPredicted processors do not run a second time.
`bWasReplicated`	Local: this entry arrived through the FastArray. Not replicated.	After the client receives an authoritative entry.	ServerOnly processors skip it.

The container has a size cap (default 10 on the component). It is a history buffer, not an authoring asset. Base HandleGameplayEffectExecute is empty. A project Combat Flow must fill the result from the attribute callback and call RegisterAttackResult.

`FGCS_ContextPayload_Combat`

Combat payload attached to a GGA EffectContext. The function library writes table and row names when applying an attack definition. The predictive-execute component writes PredictionKey and bIsPredictingContext. Ability System Globals must be the GGA class, or this payload is never allocated.

Field	Purpose	When it is written	Misconfiguration
`bIsPredictingContext`	The spec is executing locally as a prediction.	When the predictive-execute component runs on AutonomousProxy.	Default / ServerOnly processors skip it.
`PredictionKey`	Pairs a local predicted result with the replicated authority result.	Predictive-execute `OnGameplayEffectApplied`.	Without it, the replicated result cannot set `bWasPredicated` and cues may play twice.
`AtkDataTable` / `AtkRowName`	Attack-definition table and row.	`AddAttackHandleToGameplayEffectSpec`.	Applying a GE without the function library leaves processors with no definition.
`BulletDataTable` / `BulletRowName`	Bullet-definition table and row.	When a bullet builds its GE.	Empty on melee results is normal.
`DynamicTags`	Tags appended while applying the GE, for example from an MMC. `HandleAttackResult` merges them into source tags.	Flow PreApply or a calculation class.	The Event processor merges them into Instigator Tags.
`TaggedValues`	Tagged floats. The Cue processor can read Raw / Normalized Magnitude by tag.	Settlement writes a damage magnitude.	A mismatched Magnitude tag on the Cue yields 0.

SetTaggedValue / GetTaggedValue overwrite or read by tag. A missing value returns 0.

`UGCS_AbilityActionSetSettings`

A DataAsset (display name GCS Ability Action Set). It is not Developer Settings and not a character component. QueryAbilityActionsByContext on the combat entity typically hands the current weapon or ability context to this asset and receives the montage and optional Cost GE for this move.

SelectBestAbilityActions(SourceTags, TargetTags, AbilityTags, OutActions) picks the first ActionSets entry whose AbilityTag MatchesAny(AbilityTags). It then walks Layered; the first layer whose Source and Target queries both match supplies Actions. Otherwise it falls back to that set’s default Actions. No AbilityTag match returns false.

`FGCS_AbilityAction`

Field	Purpose	When to change	Misconfiguration
`Animation`	`UAnimMontage` to play.	One row per move.	An empty montage can still be selected, so the ability fires with no animation.
`PlayRate`	Playback rate. Default 1.	Fast / slow versions of the same montage.	A very low rate stretches the Trace window and looks like a lingering hitbox.
`CostGameplayEffect`	Cost GE applied when this action is chosen.	Different moves spend different stamina.	Pairing this with the ability’s own Cost GE spends twice.
`Extension`	C++ `TInstancedStruct<FGCS_AbilityActionExtension>`.	Native fields on the action.	There is no Blueprint InstancedStruct on this field.

The same struct also has StartSection, bStopWhenAbilityEnds, and root-motion scale. Layered overrides default Actions with Source / Target TagQueries, which fits “play a different montage against an airborne target.”

`UGCS_GEComponent_PredictivelyExecute`

An Effect Component on an instant Gameplay Effect. When AutonomousProxy applies the effect locally, it writes the current PredictionKey into the combat payload, sets bIsPredictingContext, then calls PredictivelyExecuteEffectSpec. Local attribute callbacks therefore enter Combat Flow and produce a predicted FGCS_AttackResult.

Field	Purpose	When to enable	Misconfiguration
`bPredictGameplayCues`	Also predict Cue execution with the effect.	Hit flashes that must appear immediately.	The Cue processor still needs `LocalPredicted`, or the replicated pass may play the cue again.

Local bullet prediction only predicts trajectory and presentation. It does not use this GE path. For local melee hit feedback, add this component to the target Instant GE and keep processors on the matching ExecutePolicy. See Processors and combat hooks.

Table of contents