UFUNCTION(BlueprintCallable,meta = (DefaultToSelf = "Object"))
static bool CallFunctionByName(UObject* Object, FName FunctionName)
{
if (Object)
{
if (UFunction* Function = Object->FindFunction(FunctionName))
{
Object->ProcessEvent(Function, nullptr); return true;
} return false;
} return false;
}
You’re welcome 
might be cleaner to use an interface to call it and then switch on name
do you have any example?
You don’t need any switch but you do need an interface.
#pragma once
#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "HitInterface.generated.h"
UINTERFACE(NotBlueprintable)
class UHitInterface : public UInterface {
GENERATED_BODY()
};
class IHitInterface {
GENERATED_BODY()
public:
UFUNCTION(BlueprintCallable, BlueprintPure = false)
virtual void OnHit() = 0;
};
#pragma once
#include "CoreMinimal.h"
#include "MyCar.generated.h"
UCLASS()
class UMyCar : public UObject, public IHitInterface {
GENERATED_BODY()
public:
virtual void OnHit() override;
};
This ensures the implementation of what happens on “hit” is written in the classes themselves, not switched on some kind of manager. Whenever you feel like you need a switch or casts (if many) you want to move logic into separate classes, or component. Components can have interfaces too. Then you’d get the component by class (no need for any tags as well), call the interface on it.
thats call function by hit, if you want call function by name as the title suggest you need a switch
Yes I did assume this is more logical based on what I see on the use case image.
*Edit * If you do go the “call by name” route, then →
There are downsides to calling a function name by FName. If you were to change your function name at any point any stored function FName will not change and will not notify you that they will not work anymore.
In C++ I can give an example how to pass around UFunction a safe way, that if the name were changed the code would not compile:
template<typename UserClass>
void __Internal_DoStuff(UserClass* InObject, typename TMemFunPtrType<false, UserClass, void()>::Type InFunc, const FName& InFuncName) {
...........
}
#define DoStuff(InObject, InFunc) __Internal_DoStuff(InObject, InFunc, STATIC_FUNCTION_FNAME(TEXT(#InFunc)))
Usage:
DoStuff(this, &AMyActor::MyUFunction);
It’s quite critical to get such functionality right, wouldn’t try to do this in blueprints in the first place, risking FNames going outdated just anywhere.
yeah the base idea is the generic access of functions by name
I’m mostly seeing cons especially on the blueprint side, and especially if you store the function names up front.
Not seeing the pros yet 
my example where I pass along a function pointer was for a specific use case where I want to bind a function on a delegate along with other data.
well i use gameplay tags instead of names which fixes some of that, but also the switch node has a default for fail checking
UFUNCTION(BlueprintCallable,meta = (DefaultToSelf = "Object"))
static bool CallFunctionByName(UObject* Object, FName FunctionName)
{
if (Object)
{
if (UFunction* Function = Object->FindFunction(FunctionName))
{
Object->ProcessEvent(Function, nullptr); return true;
}
else
{
UE_LOG(LogTemp,Warning,TEXT("Trying to run function named %s but is not found"), *FunctionName.ToString() );
return false;
}
} return false;
}
now it notifies if function is not found also the node returns a success bool
I know a lot of people dont recommend using BP nodes like ‘set timer by function name’ as it is error prone and this call function by name can be too but idk…I like it and who doesnt just dont use. Its just a feature.
I made adjustments to a function that I was calling using “Set Timer By Function Name” The function was called BP_SelectActors. I did not notice at some point it changed the name ti BP Select Actors. I thought I had done something in the function to break it. I ended up rolling back to an earlier commit and it still didn’t work. I then noticed the function name had changed.
I switched it to “Set Timer by Event” and pull off from event and 'Create Event". The pull down has a list off all functions in the blue print and will update if the name changes.
cool, now how can we use this to bind to a delegate without casting to the base class? 
you want something like this ‘callFuncByname’ but as ‘bindFuncByName’ 
no idea LOL
i think its possible with K2 nodes, the problem is you’d need to return the signature but i have been meaning to look into it
it doesn’t work if called from c++ static context didn’t try to call from object. I’m passing arguments instead of nullptr to as *void as well. Works if called from blueprints.
My problem was I tried to call bp function on editor time but function wasn’t flagged as editor function, once I flagged it everything worked fine and even *void argument passed as struct reference was properly read.