/* This only exists so it can be hooked up to a multicast delegate */
public void RemoveActiveGameplayEffect_NoReturn(FActiveGameplayEffectHandle Handle, int StacksToRemove = -1)
{
RemoveActiveGameplayEffect(Handle, StacksToRemove);
}
public float GetGameplayEffectDuration(FActiveGameplayEffectHandle Handle)
{
return(1f);
}
/* Gets the FActiveGameplayEffect based on the passed in Handle */
public UGameplayEffect GetGameplayEffectDefForHandle(FActiveGameplayEffectHandle Handle)
{
return(null);
}
/* Removes GameplayEffect by Handle. StacksToRemove=-1 will remove all stacks. */
public bool RemoveActiveGameplayEffect(FActiveGameplayEffectHandle Handle, int StacksToRemove = -1)
{
return(false);
}
/**
* Attempts to calculate the contribution of the specified GE to the captured attribute given the specified parameters. Can fail if the spec doesn't have
* a valid capture yet.
*
* @param InEvalParams Parameters to evaluate the attribute under
* @param ActiveHandle Handle of the gameplay effect to query about
* @param OutBonusMagnitude [OUT] Computed bonus magnitude
*
* @return True if the bonus magnitude was successfully calculated, false if it was not
*/
public bool AttemptCalculateAttributeContributionMagnitude(FAggregatorEvaluateParameters InEvalParams,
FActiveGameplayEffectHandle ActiveHandle, ref float OutBonusMagnitude)
{
return(false);
}
public void RemoveDependent(FActiveGameplayEffectHandle Handle)
{
}
/** Evaluates the contribution from the GE associated with ActiveHandle */
public float EvaluateContribution(FAggregatorEvaluateParameters Parameters,
FActiveGameplayEffectHandle ActiveHandle)
{
return(1f);
}
// Not happy with this interface but don't see a better way yet. How should outside code (UI, etc) ask things like 'how much is this gameplay effect modifying my damage by'
// (most likely we want to catch this on the backend - when damage is applied we can get a full dump/history of how the number got to where it is. But still we may need polling methods like below (how much would my damage be)
public float GetGameplayEffectMagnitude(FActiveGameplayEffectHandle Handle, FGameplayAttribute Attribute)
{
return(1);
}
/** Removes all mods for the passed in handle and marks this as dirty to recalculate the aggregator */
public void RemoveAggregatorMod(FActiveGameplayEffectHandle ActiveHandle)
{
}
/** Updates the aggregators for the past in handle, this will handle it so the UAttributeSets stats only get one update for the delta change */
public void UpdateAggregatorMod(FActiveGameplayEffectHandle ActiveHandle, FGameplayAttribute Attribute,
FGameplayEffectSpec Spec, bool bWasLocallyGenerated, FActiveGameplayEffectHandle InHandle)
{
}
public void AddAggregatorMod(float EvaluatedData, EGameplayModOp ModifierOp, EGameplayModEvaluationChannel ModifierChannel, FGameplayTagRequirements SourceTagReqs, FGameplayTagRequirements TargetTagReqs, bool IsPredicted, FActiveGameplayEffectHandle ActiveHandle)
{
}
/**
* Remove all mods from the channel that match the specified gameplay effect handle
*
* @param Handle Handle to use for removal
*/
public void RemoveModsWithActiveHandle(FActiveGameplayEffectHandle Handle)
{
}
/**
* Add a modifier to the channel
*
* @param EvaluatedMagnitude Magnitude of the modifier
* @param ModOp Operation of the modifier
* @param SourceTagReqs Source tag requirements of the modifier
* @param TargetTagReqs Target tag requirements of the modifier
* @param bIsPredicted Whether the mod is predicted or not
* @param ActiveHandle Handle of the active gameplay effect that's applying the mod
*/
public void AddMod(float EvaluatedMagnitude, EGameplayModOp ModOp, FGameplayTagRequirements SourceTagReqs,
FGameplayTagRequirements TargetTagReqs, bool bIsPredicted, FActiveGameplayEffectHandle ActiveHandle)
{
}
public void GetGameplayEffectStartTimeAndDuration(FActiveGameplayEffectHandle Handle, float StartEffectTime,
float Duration)
{
}
public FGameplayModifierEvaluatedData(FGameplayAttribute InAttribute, EGameplayModOp InModOp, float InMagnitude,
FActiveGameplayEffectHandle InHandle)
{
}
/* Updates the level of an already applied gameplay effect. The intention is that this is 'seemless' and doesnt behave like removing/reapplying */
public void SetActiveGameplayEffectLevel(FActiveGameplayEffectHandle ActiveHandle, int NewLevel)
{
}
public int GetTypeHash(FActiveGameplayEffectHandle InHandle)
{
return(InHandle.Handle);
}
/* Returns current stack count of an already applied GE */
public int GetCurrentStackCount(FActiveGameplayEffectHandle Handle)
{
return(1);
}
// ---------------------------------------------------------------------------------------------------------------------------------
// IMPORTANT: Any new state added to FActiveGameplayEffect must be handled in the copy/move constructor/operator
// (When VS2012/2013 support is dropped, we can use compiler generated operators, but until then these need to be maintained manually)
// ---------------------------------------------------------------------------------------------------------------------------------
FActiveGameplayEffect(FActiveGameplayEffectHandle InHandle, FGameplayEffectSpec InSpec,
float CurrentWorldTime, float InStartServerWorldTime)
{
}
/** Unregisters any linked aggregators from notifying this active handle if they are dirtied */
public void UnregisterLinkedAggregatorCallbacks(FActiveGameplayEffectHandle Handle)
{
}
public void AddDependent(FActiveGameplayEffectHandle Handle)
{
}