/** * 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); }