Is there a way to dynamically change a comparison operator?

Question

I'm creating an AI Director and need a way to change when the AI needs to pressure the player and when they need to move away. I've got a TArray of Objects and am checking the distance from the player. I'd like to either get the largest distance or the smallest distance.

I know this doesn't work:

operator comparer = PlayerTensionLevel > BackstageThreshold ? > : <;

Both of the variables used in the one line Bool are floats. I'm hoping that the comparer can be used in a situation like:

if(DistanceSquared(objectA, objectB) comparer _currentThresholdDistance){
    _currentObject = objectA;
    _currentThresholdDistance = DistanceSquared(objectA, objectB);
}

`#define comparer(a,b) ((PlayerTensionLevel > BackstageThreshold) ? (a>b) : (a — Jerry Jeremiah, Jan 17 '23 at 02:53
Use `std::function`, and initialize it with either `std::less` or `std::greater`? — Sam Varshavchik, Jan 17 '23 at 02:57
Do not use the macro method. What you need is a strategy pattern, so either you have two compare objects with the same interface that you can switch. Or as sam says you have a way to switch between two functions at runtime. — Pepijn Kramer, Jan 17 '23 at 04:50

score 2 · Answer 1 · answered Jan 17 '23 at 03:41

You can compute with bool! If you aren’t concerned with differing behavior for ties, you can just write

if((DistanceSquared(objectA, objectB) > _currentThresholdDistance) ==
   (PlayerTensionLevel > BackstageThreshold)) …

(Technically, the extra parentheses here are unnecessary, but it’s probably not reasonable to expect the reader to know that relational operators have higher precedence than equality operators.)

wohlstad · Answer 2 · 2023-01-18T13:26:38.367

As already mentioned in @SamVarshavchik's comment above,
You can use std::function and assign it to either std::less or std::greater based on PlayerTensionLevel and BackstageThreshold.

After you determine the comparator you can use it against the current values of _currentThresholdDistance and the the squared distance between the objects (here I just used dist2 to represent it).

#include <iostream>
#include <functional>

std::function<bool(float a, float b)>
     GetComp(float PlayerTensionLevel, float BackstageThreshold)
{
    if (PlayerTensionLevel > BackstageThreshold) {
        return std::less<float>{};
    }
    return std::greater<float>{};
}

int main() {
    float _currentThresholdDistance = 1;
    float dist2 = 2;

    float PlayerTensionLevel = 100;
    float BackstageThreshold;

    BackstageThreshold = 101;
    std::cout << GetComp(PlayerTensionLevel, BackstageThreshold)
                        (dist2, _currentThresholdDistance) << std::endl;

    BackstageThreshold = 99;
    std::cout << GetComp(PlayerTensionLevel, BackstageThreshold)
                        (dist2, _currentThresholdDistance) << std::endl;
}

Output:

1
0

To add to this, Unreal has its own `TLess` and `TGreater` templated predicates, which is advised to use when writing Unreal specific code. — goose_lake, Jan 24 '23 at 11:46
@goose_lake my solution can be easily adapted to use `TLess` etc. if needed - just replace `std::less` etc. with it in `GetComp` . — wohlstad, Jan 24 '23 at 11:48

Is there a way to dynamically change a comparison operator?

2 Answers2