Attributes
Health, stamina, hunger, armor and strength are attributes: numbers of an actor that conditions, costs, rewards, HUDs, AI and quests of every Pulse plugin read and change. They all ask one small contract, IPulseAttributeSource (Attributes/PulseAttributeSource.h, module PulseFoundation), and never need to know who keeps the numbers. Per actor the answer comes from
- the Pulse Attributes component (without GAS, in Pulse Foundation),
- the GAS adapter (module
PulseFoundationGAS: the attributes of an ability system component), or - a system of the game, in C++ or Blueprint (A source of your own).
GAS players and Pulse enemies mix: each actor answers with the source it has.
Every attribute is a gameplay tag below Pulse.Stat; the stat register gives its name, format and icon. Pulse Foundation registers Pulse.Stat.Health, .MaxHealth, .Stamina and .MaxStamina; plugins and games register the rest (shield, hunger, armor). Pulse Foundation knows values, bounds, rates, bands and modifiers, but no rules of a game: damage, shields, death and “downed” belong to the combat plugins.
Pools and stats
| Kind | Examples | What it is |
|---|---|---|
| Pool | Health, stamina, hunger | A stored value between Min and Max, with a rate per second on the game clock. Modifiers change only Min, Max and Rate. |
| Stat | Strength, armor, speed | A base value plus modifiers: (Base + sum of Add) x (1 + sum of Multiply). No rate. |
A modifier on the value of a pool answers Pulse.Result.Failure.Invalid: a healing potion is a change, not a modifier.
Reading
Pulse::Attributes::Read (Attributes/PulseAttributes.h) works on every machine and answers FPulseAttributeValue:
| Field | What it is |
|---|---|
Value | The value, clamped to Min and Max. |
Base | The stored value of a pool or the base of a stat, not clamped; only with bHasBase (false on clients that do not own the actor). |
Min, Max, Percent | The bounds and where the value is between them (0 to 1, 0 for an empty range). |
RatePerSecond | The rate now, on the game clock (0 for stats). |
Band | The active band of a pool (a tag such as “hungry”), empty for none. |
bKnown, bDepleted | The source knows the attribute on this machine; the value is at its minimum. |
An actor without a source, or a source that does not know the attribute, answers bKnown false. Conditions treat that as “unknown” on clients and as failed on the server.
GetTimeToReach(Value) says how many game seconds the rate needs to get to a value: 0 when the value equals it (also without a rate) or is past it in the direction of the rate, -1 when it never gets there (no rate, the wrong direction, beyond Min or Max). Rates run without a tick and send no message while they run, so this is the way to wait for them.
const FPulseAttributeValue health = Pulse::Attributes::Read(Actor, Pulse::Foundation::Tags::Stat_Health);
if (health.IsKnown() && health.Percent < 0.25)
ShowLowHealthWarning();
Changing
Changes run on the server. Pulse::Attributes::Change takes an FPulseAttributeChangeRequest: the attribute, the op, the amount and a context (Instigator, Source, Tags; the target is set to the actor). The result is clamped to Min and Max.
| Op | Value afterwards |
|---|---|
Add | Value + Amount |
Set | Amount |
AddPercentOfMax | Value + Amount x (Max - Min); 0.25 = 25 % of the range |
SetPercentOfMax | Min + Amount x (Max - Min) |
Reset | The start value of the source; sources without one refuse it |
The answer FPulseAttributeChangeResult has Before, After, Applied and an FPulseResult with these reasons (results):
| Reason | When |
|---|---|
Pulse.Result.Failure.Attribute.Unknown | The actor has no source, or the source does not know the attribute. |
Pulse.Result.Failure.Attribute.NotAuthority | Called on a client. The log names the actor and says to call it on the server. |
Pulse.Result.Failure.Attribute.Refused | The source does not take this request (an op it does not have, a modifier GAS has no effect for). |
Pulse.Result.Failure.Invalid | The request does not fit the attribute: no attribute or an amount that is not finite, a percent of a stat without Max, a value modifier on a pool, a rate modifier on a stat, a Min or Max modifier on an open bound or on bounds that come from GAS. |
FPulseAttributeChangeRequest request;
request.Attribute = Pulse::Foundation::Tags::Stat_Health;
request.Op = EPulseAttributeChangeOp::Add;
request.Amount = 25.0;
request.Context.Instigator = Healer;
request.Context.Source = Potion;
const FPulseAttributeChangeResult result = Pulse::Attributes::Change(Target, request);
Modifiers
Pulse::Attributes::Modify adds, removes and lists modifiers (FPulseAttributeModifyRequest, adding and removing on the server). A modifier (FPulseAttributeModifierSpec) has:
| Field | What it is |
|---|---|
Attribute, Target | What it changes: Value (stats), Min, Max or Rate. A Min or Max that points to another attribute (health up to max health) moves the modifier to that attribute. |
Op, Magnitude | Add adds the magnitude; Multiply adds it to the factor (0.2 = +20 %, -0.5 = half). |
Duration | Seconds on the game clock; 0 until it is removed. |
SourceKey | Who gave it (“Sprint”, an item id). A modifier with the same attribute, target and key replaces the old one; None is never replaced. RemoveBySource removes all of a key. |
EffectTag | An effect for the status bar, may be empty. |
Visibility | Who sees it: None (the server), Owner, All. |
bSaved | Saved with the source. Equipment and skills set it to false and give their modifiers again after a load. |
There is no override with a priority: a fixed value is a new base (Set on a stat).
Finding the source
Pulse::Attributes::FindSource looks, in this order, at
- the actor itself, if it implements the interface, then its first component that does;
- for a controller or a player state: the own source of its pawn (attributes live on the body), unless that source answers only for its own actor (
bOwnActorOnlyin its capabilities, set by vehicles such as the PulseWater boat hull: the driver is not the boat); - the player state of a pawn or controller (games that keep attributes there).
Owners and attach parents are not followed: a hit on a projectile never reaches its owner. An actor that forwards hits (a weak spot) implements the interface itself.
One source per actor and player is the rule. A second source on the same actor, or sources on both the pawn and the player state of one player, log a warning with both sources, the one that answers and the fix, and the debugger shows it next to the source. The first source found answers. Pawn and player state are checked again whenever the player state gets another pawn, so a pawn possessed after its source was ready is checked too.
Events and messages
Every source hands its events to UPulseAttributeSubsystem (one per world, every machine). An event (FPulseAttributeEvent) is one of Changed, Depleted, Restored, RangeChanged (the band changed), ModifiersChanged, SourceReady, SourceRemoved and RateChanged, with the owner, the source object, the values and the context of the change that caused it. RateChanged (native only) tells that the rate or a bound moved without a jump in value: new owner tags or tuning, a rate modifier, a Max that moved. Readers that show a running rate or Max (the attribute view model, the wait node) read again; it goes to OnAttributeEventNative and the watches only, never to Blueprint events or the message bus. The subsystem passes the others on in this order:
OnAttributeEventNativeand the watches of the actor;OnAttributeEvent(Blueprint, the whole world);- the message bus:
| Channel | Payload | Sent |
|---|---|---|
Pulse.Message.Attribute.Changed | FPulseAttributeChangedMessage | On the server after changes, on clients with the values they received. Only while someone listens. |
Pulse.Message.Attribute.Depleted | FPulseAttributeEdgeMessage | On the server, when the value reaches its minimum. Clients get it through the message relay. |
Pulse.Message.Attribute.Restored | FPulseAttributeEdgeMessage | On the server, when it leaves the minimum again. |
Pulse.Message.Attribute.RangeChanged | FPulseAttributeRangeMessage | On the server, when the band of a pool changes. |
The context of a message is the context of the change: Instigator, Source and Tags of the request, Target the owner, Amount the applied change for Changed, CatchUp for loads and late joins. All channels with their details are in message channels.
A watch follows one actor: a health bar, an AI agent or a wait node gets every event of its source. A watch on an actor of a player also gets the events of the source FindSource gives it at the time of the event: a controller or player state those of the pawn (not of a boat hull or another source with bOwnActorOnly), a pawn or controller those of the player state. So a HUD that watches its pawn from BeginPlay, before the possession, gets the events of attributes on the player state. A watch stays when the source of the actor is replaced and ends with RemoveWatch or with the actor. The subsystem keeps bOwnActorOnly of each source when it is ready or rebound (Pulse::Attributes::IsOwnActorOnly), so events do not ask the capabilities.
UPulseAttributeSubsystem* attributes = UPulseAttributeSubsystem::Get(this);
WatchHandle = attributes->WatchActor(Target, FOnPulseAttributeEventNative::FDelegate::CreateUObject(this, &UMyHealthBar::HandleAttributeEvent));
Blueprint
Category Pulse > Foundation > Attributes; the actor pin defaults to self.
| Node | What it does |
|---|---|
| Read Attribute | The whole value (pure). |
| Get Attribute Value, Get Attribute Percent | The value, or where it is between Min and Max; 0 when it is not known. |
| Has Attribute | The source knows it on this machine. |
| Change Attribute | Add, Set, Add/Set Percent Of Max or Reset (server only), with instigator and source. |
| Add Attribute Modifier, Remove Attribute Modifiers | Add one modifier, remove all of a source key (server only). |
| Get Attribute Modifiers | The modifiers this machine knows. |
| Get Time To Reach | Game seconds the rate needs to a value. |
| Find Attribute Source | The object that answers for the actor. |
| Notify Owner Tags Changed | After you changed tags that pause or override rates. |
When a change fails because the actor has no source or the attribute is unknown, the node writes the actor, the attribute and the fix (the setup step, the profile, the map) to the Blueprint message log.
Wait For Attribute
Wait For Attribute fires On Reached once an attribute compares true with a value (health below 25 %, stamina full again); with Percent it compares the part of the range (0 to 1). It checks at once, after every change, band change and modifier change of the actor, and at the time the rate needs to get there (a timer on the game clock), so it needs no tick. With Only Once off it fires again each time the comparison turns true, until you cancel it. On Failed fires when the actor has no attribute source or is destroyed.
Profiles and store
The Pulse Attributes component takes its attributes from a profile, a data asset UPulseAttributeProfile (Attributes/PulseAttributeProfile.h). A profile has a list of FPulseAttributeDefinition, an optional Parent (its entries come first; an entry of the child with the same tag replaces the entry of the parent) and a Usage: Component (the profile defines every attribute) or GASRules (rates, bands and pause tags for mapped GAS attributes; Min, Max and start come from the attribute set). Validate and IsDataValid name every problem with the path of the value (“Attributes[2].Bands[0].AtOrBelow”).
| Field of a definition | What it is |
|---|---|
Attribute, Kind | The tag (Pulse.Stat.*); pool or stat. |
StartMode, Start | The start value, or the part of the range (1 = full). |
Min, Max | A bound: None (stats only), a fixed Value that Min and Max modifiers change, or another Attribute (health up to max health). |
Rate, RateOverrides, PauseTags, PauseMode | The change per second, minute or hour on the game clock, or per hour of the day (DayHour, see below); other rates while the owner has a tag; tags that hold the pool: every rate (All) or only a rising one (GainOnly). |
Bands | Ranges of a pool with a tag and modifiers while the value is in them (“hungry” at or below 30 %), with a LeaveAbove against flicker. |
MaxChangeRule | What a change of Max in the game does to the value: KeepValue, KeepFraction, AddGain. Never while loading. |
Visibility, bSaveGame | Who sees it; saved with the source. |
Hour or Day Hour. Hour is an hour on the game clock (3600 game seconds). DayHour is an hour of the day: game clock hours times the day rate that a calendar (Pulse Time) sets, so hunger “4 per hour of the day” empties in the same day hours whether a day takes 24 minutes or 24 hours. Without a calendar the day rate is 1 and both are the same. The day rate counts before the modifiers: a Multiply modifier stays relative (+100 % doubles the day hour rate), an Add modifier stays per game second. The rate overrides use it too. A new day rate (Pulse.Message.Clock.DayRateChanged) is planned like new owner tags: the store advances with the old rate, then runs with the new one. FPulseAttributeRate::GetPerSecond(DayRate) gives the rate per game second; GetPerSecond() counts with day rate 1.
The rate of a pool is worked out in this order: the first rate override whose tags the owner has (else Rate), then the rate modifiers, then the pause (any pause tag makes it 0, whatever the modifiers add; with PauseMode GainOnly only a rate above 0 is held, so a drain of a band goes on), then the tuning knobs Pulse.Tuning.Attributes.RateGain (rising) and .RateLoss (falling). GainOnly is the mode for health regeneration that pauses after a hit (Pulse.Combat.State.RecentlyDamaged): the dead and the hit regenerate nothing, but starving still costs health.
Default profiles. Pulse::Attributes::MakeDefaultProfile (Attributes/PulseAttributeDefaults.h) gives the profiles that come with Pulse Foundation as C++ data: PlayerDefault (health 100 without regeneration, stamina 100 that regenerates 20 per second with the band Exhausted from empty until 20 %), Enemy (health 100, KeepFraction), Destructible (health 50) and ProjectDefault (the profile of the project settings, else PlayerDefault). The assets DA_PulseAttributes_* are copies of them.
Attributes of plugins. A plugin adds attributes without a change to any profile: Pulse::Attributes::RegisterDefinitions(Owner, Definitions, Target) in StartupModule (target Players, NonPlayers or All), UnregisterDefinitions(Owner) in ShutdownModule. The components mix them into their resolved profile at BeginPlay; an entry of the profile wins, and a tag two plugins register stays with the first (warning in the log). A pawn is a player only once it is possessed: the automatic component starts inside SpawnActor, before the game mode possesses the pawn (also after every respawn). When its pawn gets a player controller, the component adds the definitions for players it is missing; the attributes it has keep their values and modifiers, and it sends SourceReady again. An unpossession removes nothing.
void FPulseSurvivalModule::StartupModule()
{
Pulse::Attributes::RegisterDefinitions(TEXT("PulseSurvival"), { MakeHunger(), MakeThirst() }, EPulseAttributeDefinitionTarget::Players);
}
The store. Pulse::Attributes::Store (Attributes/PulseAttributeStore.h) holds the rules as plain data and pure functions, so specs test them without a world: MakeStore builds an FPulseAttributeStore from definitions, Evaluate and GetRate read it, and AdvanceTo, PlanChange, PlanAddModifier, PlanRemoveModifiers, PlanExpire, PlanEnvironment, PlanExternalDelta, PlanExternalBounds, PlanReleasePending and PlanReset return an FPulseAttributePlan (the new state, the result and the notices in time order) that ApplyPlan takes over. GetNextEvent gives the time of the next band boundary, edge or end of a modifier, so a source needs a timer, not a tick. Worth knowing:
- A change that leaves the value as it is sends no
Changed; where its rate, Min or Max moved, it sendsRateChanged. - A pool that starts at its minimum is depleted from the start without a
Depletednotice, so its firstRestoredhas noDepletedbefore it. AdvanceTotakes at most 64 steps; the rest goes in one step that removes every ended modifier (bStepLimitReachedand a log line; the component puts a warning on the debug timeline).- Min and Max modifiers on bounds that come from outside (
PlanExternalBounds, GAS) answerInvalid.
In the workshop. Profiles open in the config workshop of the editor kit: the attributes on the left, the values of the selected one on the right, and the preview Curves as a column of its own. It runs the profile with the store above, without a world and without PIE:
- Curves: the value of every attribute over the time chosen at the top (1 min to 1 week of game time), its Max dashed, the edges of its bands dashed and the time a band holds shaded, and when it is empty or full. Selecting an attribute in the workshop shows only its curve, larger; Edit › at a curve selects its attribute.
- Timeline (the test panel): the owner tags at the start (every pause tag and tag of a rate override of the profile) and events in session seconds: Tag on, Tag off, Clock jump (the game clock jumps ahead, as after a rest; the curve steps) and Change (adds an amount to a value, as a meal or a hit).
- Compare: the profile next to others picked above the table, a row per attribute: range and start, rate per hour of the day (the workshop runs with day rate 1), when it is empty or full without events, the bands with their edges.
The same runs are plain functions for specs and tools: Pulse::Editor::Kit::Attributes::Simulate and MakeComparison in the editor module (Kit/Attributes/PulseAttributeCurves.h).
Save format. MakeSaveData gives FPulseAttributeSaveData (Attributes/PulseAttributeSave.h), format version 1 (Pulse::Attributes::Save::CurrentVersion): the values at the time of saving without stamps, the active band, and the saved modifiers (not those of bands) with their remaining time. WriteSaveBytes and ReadSaveBytes turn it into versioned bytes (Serialization); PlanLoad loads it without clamping and without the max change rule. Newer and damaged data are rejected with an error in the import report, unknown tags are skipped, and attributes the save does not have keep their start value.
The Pulse Attributes component
UPulseAttributeComponent (Attributes/PulseAttributeComponent.h, Pulse Attributes in the Add Component list) keeps the attributes of an actor without GAS. Add it to the player pawn with the Set Up step of Foundation in the Pulse window (it turns on the automatic component AttributeComponent of Project Settings > Pulse > Foundation, off by default) or by hand to any actor: enemies, destructible props, a vehicle.
Which profile. A value set on the component always wins over the project:
Profile, if set (a profile withUsageGASRulesis refused with an error and the fix);- else
Default Profile, unless it isProject Default: an enemy withEnemynever gets the player profile of the project; - else
Default Attribute Profileof Project Settings > Pulse > Foundation > Attributes, elsePlayerDefault; - then the definitions of plugins (
RegisterDefinitions) whose tag is still missing (those for players also when the pawn is possessed afterBeginPlay).
An entry with a broken bound (a cycle, a bound that points to an unknown attribute) is left out with a log line that names the actor, the profile and the attribute, and an error on the debug timeline; the others work.
On the server the store is the truth (see Profiles and store). Every change, modifier, load, tag change and clock jump is planned by Pulse::Attributes::Store and committed at once: the plan is applied, the values replicate, the next timer is set and then the events go out. Rates run without a tick: one timer on the game clock wakes the component at the next band boundary, edge or end of a modifier (GetNextEventTime). The component follows the game clock (a pause holds the rates, a jump forward walks the events in order, a jump back only moves the stamps), the day rate of the clock (DayHour rates) and the tuning knobs Pulse.Tuning.Attributes.RateGain and .RateLoss of its owner. Max Attribute Steps Per Advance (default 64) caps the events one step walks; the rest is caught up at once with a warning on the timeline.
A listener may change attributes while the events of a change go out (combat sets a “dead” tag on Depleted and calls Pulse::Attributes::NotifyOwnerTagsChanged): that change runs at once on the new state, and the timer is set again at the end for the final state. A pool that reaches its minimum while its rate would fill it again sends Restored one frame later at the earliest, so a listener of Depleted can pause it first.
Owner tags. Pause tags and rate overrides read the tags of the owner (for a player: pawn, controller and player state together, without the component itself). Call Notify Owner Tags Changed (or RefreshOwnerTags on the component) after you change such tags; the component plans only when they differ.
Saving. The component saves itself as bytes (IPulseByteSaveable, identity Pulse.Attribute.Save.Values, for player actors with the player id), so Pulse Save keeps it without a bridge. A load never clamps and carries CatchUp = Load; ResetToDefaults (a respawn, PlanReset) builds the start values again and removes every modifier, also saved ones and those with a source key (buffs, equipment): the systems that gave them add them again. The band modifiers of the start bands come back with new ids. The events follow the rules of the store, so server and clients agree: ModifiersChanged, Changed (Cause Change) for the values that differ, RangeChanged, Restored or Depleted, then RateChanged.
Default profile assets. DA_PulseAttributes_PlayerDefault, DA_PulseAttributes_Enemy and DA_PulseAttributes_Destructible in the folder Attributes of the Pulse Foundation content are copies of MakeDefaultProfile to duplicate as a start. The console command Pulse.Attributes.WriteDefaultProfiles (editor) writes them again from the C++ data; assets there are overwritten in place, so their paths stay.
Replication
The component replicates with push model properties only (no RPCs, no tick), so it works with classic replication and Iris. The base class UPulseAttributeComponentBase does it for the Pulse Attributes component and the GAS adapter alike:
| Property | Goes to | Holds |
|---|---|---|
OwnerAttributes | The owning client (COND_OwnerOnly) | Every attribute the owner sees (Visibility All and Owner), with its base value |
PublicAttributes | Everyone else (COND_SkipOwner) | The attributes with Visibility All, without the base value |
OwnerModifiers, PublicModifiers | The same split | The modifiers by their Visibility; None stays on the server |
BandTags | Everyone | The tags of the active bands |
An item holds the stored value at its stamp, Min, Max, the rate, the band and bDepleted; clients project it to the game time now, so a running rate needs no updates. The server stamps a pool again only when its own rate or value changes: a band change of hunger leaves the item of the running stamina as it is and costs no bandwidth.
On clients the updates of one frame are bundled. Both the last item and the new one are projected to the same time; only a jump in value sends Changed (Cause Replication), so a new stamp of a running pool sends nothing; a new rate, Min or Max without a jump sends RateChanged, also for modifiers with Visibility None that clients never see. Edges and band changes on clients go to the events of the component and the watches, never to the message bus (the server sends those). The first values after a join or when the actor becomes relevant carry CatchUp = Replication, also with an active band.
A client reads the owner arrays only while it owns the actor. After an unpossess the server stops sending them, but their last items stay on the client: from then on the client reads the public items (without base, without Owner attributes and modifiers), and the next frame compares every attribute again and sends the events of the difference. The arrays are not emptied on purpose: once the client owns the actor again, the server sends only what changed since.
The band tags are the gameplay tags of the component (IGameplayTagAssetInterface), so Pulse::Conditions, GetActorTags and the tag queries of other plugins see Pulse.Attribute.Band.Exhausted on every machine.
Events per actor
Every attribute component has events for its own actor, on the server and on clients, so a Blueprint binds On Attribute Changed of the component directly instead of filtering the world event:
| Event | Native (C++, bridges) | When |
|---|---|---|
| On Attribute Changed | OnAttributeChangedNative | A value changed (Before, After, Applied, Cause). |
| On Depleted | OnDepletedNative | A value reached its minimum (death at health 0). |
| On Restored | OnRestoredNative | A value left its minimum again. |
| On Range Changed | OnRangeChangedNative | The band of a pool changed (OldBand, NewBand). |
| On Modifiers Changed | OnModifiersChangedNative | Modifiers were added, removed or ended. |
OnAttributeEventNative gets all of them and RateChanged, which has no event of its own. The component fires them from a watch on its actor that starts in BeginPlay and ends in EndPlay, for its own events only. After EndPlay a change still applies (a listener of SourceRemoved may make one), but no timer is set again. Find Pulse Attributes Component (UPulseAttributeComponent::FindAttributeComponent) finds the component from any actor of a player, like FindSource.
A source of your own
In C++, implement IPulseAttributeSource on an actor or component and override what your system can do; every function has a default answer (unknown, refused, empty), so new fields in requests and answers break nothing:
| Function | Default |
|---|---|
Read | bKnown false |
Change, Modify | Pulse.Result.Failure.Attribute.Refused |
GetCapabilities | Empty: the attributes it knows, what it can do, bOwnActorOnly for a vehicle that is not the body of its driver, SourceName and DefinedBy for logs |
OnOwnerTagsChanged | Nothing; sources with rates read pause and override tags again |
Report the source with UPulseAttributeSubsystem::NotifySourceReady in BeginPlay and NotifySourceRemoved in EndPlay (NotifySourceRebound sends SourceReady again when a known source got another backend), and hand every change to Dispatch, so watches, HUDs and the message bus hear of it. Pulse::Attributes checks the authority before it calls Change and Modify.
In Blueprint, derive from Pulse Attribute Source (Blueprint) (UPulseAttributeSourceComponent), override On Read, On Change, On Modify and On Get Capabilities, and call Notify Attribute Changed, Notify Depleted and Notify Restored when your values change. The component reports itself; events you do not override give the default answers, and an empty source name becomes “Blueprint”.
Debugging
- Snapshot category Attributes (gameplay debugger, Pulse Debugger, visual logger): one row per source with its actor, kind and number of attributes, the warning about a second source, and the last events of the world (kept while the timeline records).
- The debug timeline records every event under
Foundation/Attributes; the Pulse Attributes component adds its changes, edges, band changes, modifiers and loads. - The Pulse Attributes component has a snapshot of its own (category Attributes): “n attributes, next event in x s”, then its attributes (value, base, Min, Max, rate per second, band, depleted, stamp), its modifiers and its environment (owner tags, tuning factors, day rate).
- The Pulse Debugger page Attributes lists the sources of the world with their warnings and shows the attributes, modifiers and last events of the selected one live.
- Console:
PulseAttributeListlists the attributes of your pawn;PulseAttributeAdd,PulseAttributeSet,PulseAttributeModifierandPulseAttributeResetchange them on the server (console). - MCP: the toolset
PulseFoundationToolset.PulseFoundationAttributeToolset(plugin PulseFoundationToolset) lists the sources of a PIE world, reads and changes attributes and adds or removes modifiers, all through this contract. - Requests refused on a client log the actor, the attribute and what to do to
LogPulseFoundation.