/**
* Attempts to calculate the magnitude of the captured attribute given the specified parameters, up to the specified evaluation channel (inclusive).
* Can fail if the spec doesn't have a valid capture yet.
*
* @param InEvalParams Parameters to evaluate the attribute under
* @param FinalChannel Evaluation channel to terminate the calculation at
* @param OutMagnitude [OUT] Computed magnitude
*
* @return True if the magnitude was successfully calculated, false if it was not
*/
public bool AttemptCalculateAttributeMagnitudeUpToChannel(FAggregatorEvaluateParameters InEvalParams, EGameplayModEvaluationChannel FinalChannel, ref float OutMagnitude)
{
return(false);
}
/**
* Attempts to calculate the magnitude of the captured attribute given the specified parameters, including a starting base value.
* Can fail if the spec doesn't have a valid capture yet.
*
* @param InEvalParams Parameters to evaluate the attribute under
* @param InBaseValue Base value to evaluate the attribute under
* @param OutMagnitude [OUT] Computed magnitude
*
* @return True if the magnitude was successfully calculated, false if it was not
*/
public bool AttemptCalculateAttributeMagnitudeWithBase(FAggregatorEvaluateParameters InEvalParams, float InBaseValue, ref float OutMagnitude)
{
return(false);
}
/** Gathers made for a given capture. Note all mods are returned but only some will be qualified (use Qualified() func to determine) */
public bool AttemptGatherAttributeMods(FAggregatorEvaluateParameters InEvalParams,
Dictionary <EGameplayModEvaluationChannel, List <FAggregatorMod> > OutModMap)
{
return(false);
}
/**
* Attempts to calculate the magnitude of 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 OutMagnitude [OUT] Computed magnitude
*
* @return True if the magnitude was successfully calculated, false if it was not
*/
public bool AttemptCalculateAttributeMagnitude(FAggregatorEvaluateParameters InEvalParams, ref float OutMagnitude)
{
return(true);
}
/** Evaluates the contribution from the GE associated with ActiveHandle */
public float EvaluateContribution(FAggregatorEvaluateParameters Parameters,
FActiveGameplayEffectHandle ActiveHandle)
{
return(1f);
}
/**
* 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);
}
/** Evaluates the Aggregator with an arbitrary base value */
public float EvaluateWithBase(float InlineBaseValue, FAggregatorEvaluateParameters Parameters)
{
return(1f);
}
/** Evaluates the Aggregator to compute its "bonus" (final - base) value */
public float EvaluateBonus(FAggregatorEvaluateParameters Parameters)
{
return(1f);
}
/** Evaluates the aggregator with the internal base value and given parameters, up to the specified evaluation channel (inclusive) */
public float EvaluateToChannel(FAggregatorEvaluateParameters Parameters,
EGameplayModEvaluationChannel FinalChannel)
{
return(1f);
}
/** Works backwards to calculate the base value. Used on clients for doing predictive modifiers */
public float ReverseEvaluate(float FinalValue, FAggregatorEvaluateParameters Parameters)
{
return(1f);
}
/** Calls ::UpdateQualifies on each mod */
public void EvaluateQualificationForAllMods(FAggregatorEvaluateParameters Parameters)
{
}
/**
* Similar to EvaluateWithBase (see comment there for details), but terminates early after evaluating the specified final channel instead of
* continuing through every possible channel
*
* @param InlineBaseValue Initial base value to use in the first evaluation channel
* @param Parameters Additional evaluation parameters
* @param FinalChannel Channel to terminate evaluation with (inclusive)
*
* @return Result of the specified base value run through each modifier in each evaluation channel in numeric order
*/
public float EvaluateWithBaseToChannel(float InlineBaseValue, FAggregatorEvaluateParameters Parameters,
EGameplayModEvaluationChannel FinalChannel)
{
return(1f);
}
/** runs UpdateQualifies on all mods */
public void UpdateQualifiesOnAllMods(FAggregatorEvaluateParameters Parameters)
{
}
/**
* Evaluates a final value in reverse, attempting to determine a base value from the modifiers within the channel.
* Certain conditions (such as the use of override mods) can prevent this from computing correctly, at which point false
* will be returned. This is predominantly used for filling in base values on clients from replication for float-based attributes.
*
* @note This will be deprecated/removed soon with the transition to struct-based attributes.
*
* @param FinalValue Final value to reverse evaluate
* @param Parameters Evaluation parameters to use for the reverse evaluation
* @param ComputedValue [OUT] Reverse evaluated base value
*
* @return True if the reverse evaluation was successful, false if it was not
*/
public bool ReverseEvaluate(float FinalValue, FAggregatorEvaluateParameters Parameters, ref float ComputedValue)
{
return(false);
}
/**
* Helper function to sum all of the mods in the specified array, using the specified modifier bias and evaluation parameters
*
* @param InMods Mods to sum
* @param Bias Bias to apply to modifier magnitudes
* @param Parameters Evaluation parameters
*
* @return Summed value of mods
*/
public static float SumMods(List <FAggregatorMod> InMods, float Bias, FAggregatorEvaluateParameters Parameters)
{
return(1f);
}
