integration/Source/Integration/LuaCallNode.cpp

// Copyright Epic Games, Inc. All Rights Reserved.


#include "LuaCallNode.h"
#include "StreamBuffer.h"

#include "GameFramework/Actor.h"
#include "BlueprintActionDatabaseRegistrar.h"
#include "BlueprintNodeSpawner.h"
#include "Containers/EnumAsByte.h"
#include "Containers/UnrealString.h"
#include "EdGraph/EdGraph.h"
#include "EdGraph/EdGraphSchema.h"
#include "EdGraphSchema_K2.h"
#include "EdGraphSchema_K2_Actions.h"
#include "EditorCategoryUtils.h"
#include "Engine/Blueprint.h"
#include "HAL/PlatformCrt.h"
#include "Internationalization/Internationalization.h"
#include "K2Node_CallFunction.h"
#include "K2Node_MakeArray.h"
#include "K2Node_MakeStruct.h"
#include "Kismet/KismetMathLibrary.h"
#include "Kismet/KismetTextLibrary.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "Kismet2/CompilerResultsLog.h"
#include "KismetCompiler.h"
#include "LuaCall.h"
#include "Math/Vector2D.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "ScopedTransaction.h"
#include "Templates/Casts.h"
#include "Templates/SubclassOf.h"
#include "UObject/Class.h"
#include "UObject/ObjectPtr.h"
#include "UObject/Package.h"
#include "UObject/UnrealNames.h"
#include "UObject/UnrealType.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"

#define LOCTEXT_NAMESPACE "LuaCall"

#define LuaCallLibraryFunction(name) (UlxLuaCallLibrary::StaticClass()->FindFunctionByName(GET_MEMBER_NAME_CHECKED(UlxLuaCallLibrary, name)))

// All argument pins will have internal Names that start with "A:"

const FName UK2Node_LuaInvoke::FunctionPinName(TEXT("Lua Function Prototype"));
const FName UK2Node_LuaInvoke::PlacePinName(TEXT("Place Tangible"));
const FName UK2Node_LuaInvoke::ExtraResultsPinName(TEXT("Extra Results"));
const FName UK2Node_LuaInvoke::ErrorPinName(TEXT("Error"));

bool UK2Node_LuaInvoke::IsPrefix(const UEdGraphPin *Pin, char Prefix)
{
	TCHAR pname[FName::StringBufferSize];
	Pin->PinName.ToString(pname);
	return pname[0] == Prefix && pname[1] == ':';
}

FName UK2Node_LuaInvoke::AddPrefix(const FString &Name, char Prefix)
{
	TCHAR PrefixChars[3];
	PrefixChars[0] = Prefix;
	PrefixChars[1] = ':';
	PrefixChars[2] = 0;
	FString Prefixed = PrefixChars + Name;
	return FName(*Prefixed);
}

FString UK2Node_LuaInvoke::RemovePrefix(FName Name, char Prefix)
{
	TCHAR pname[FName::StringBufferSize];
	Name.ToString(pname);
	check(pname[0] == Prefix);
	check(pname[1] == ':');
	return FString(pname + 2);
}

static FEdGraphPinType GetPinType(const FProperty *Property)
{
	FEdGraphPinType PinType;
	bool IsWeak;
	FName PinCat, PinSubCat;
	UObject *PinSubCatObj = nullptr;
	UEdGraphSchema_K2::GetPropertyCategoryInfo(Property, PinCat, PinSubCat, PinSubCatObj, IsWeak);
	PinType.PinCategory = PinCat;
	PinType.PinSubCategory = PinSubCat;
	PinType.PinSubCategoryObject = PinSubCatObj;
	return PinType;
}


UK2Node_LuaInvoke::UK2Node_LuaInvoke(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer), NodeTooltip(MakeTooltip())
{
}

UK2Node_LuaProbe::UK2Node_LuaProbe(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
}


FText UK2Node_LuaInvoke::MakeTooltip() const
{
	// TODO: replace this string manipulation with text manipulation.
	FString ArgTypes = UlxLuaCallLibrary::AllKnownArgumentTypes();
	FString RetTypes = UlxLuaCallLibrary::AllKnownReturnValueTypes();
	return FText::FromString(FString::Printf(TEXT(
		"Call a Lua function.\n"
		"\n"
		"The lua function prototype must be a hardwired string which must look like\n"
        "one of the following:\n"
		"\n"
        "  classname.funcname(int arg1, int arg2)\n"
        "  classname.funcname(int arg1, int arg2) : int ret1, int ret2\n"
        "  classname.funcname(int arg1, int arg2) : int ret1, int ret2, ...\n"
		"\n"
        "You must specify types for the argument and return value pins.  The:\n"
        "types that you may specify are:\n"
		"\n"
        "Arguments: %s\n"
		"Return Values: %s\n"
		"\n"
		"The prototype is parsed to determine what lua function to call.\n"
        "The lua call node will automatically add pins for the arguments and\n"
        "return values.  If the function has no return values, you can omit those\n"
        "from the proto.  If you put an ellipsis at the end of the return values,\n"
        "then any additional return values will be collected into a\n"
        "dynamically typed array of values which you can iterate over later.\n"
        "\n"
		"Optionally, you may use the * wildcard for the classname.  In that\n"
		"case, the class of the 'place' tangible will be used.\n"
		"\n"), *ArgTypes, *RetTypes));
}

void UK2Node_LuaInvoke::AllocateDefaultPins()
{
	Super::AllocateDefaultPins();
	CreateCorrectPins();
}

void UK2Node_LuaInvoke::CreateCorrectPins()
{
	if (LuaFunctionPrototype.IsEmpty())
	{
		LuaFunctionPrototype = TEXT("class.func(int arg1, int arg2) : int ret1, int ret2");
	}

	// Parse the lua function prototype.
	FlxParsedProto ParsedProto(LuaFunctionPrototype);
	if (!ParsedProto.ErrorMessage.IsEmpty())
	{
		bHasCompilerMessage = true;
		ErrorType = EMessageSeverity::Error;
		ErrorMsg = FString::Printf(TEXT("Syntax error in lua function prototype: %s"), *ParsedProto.ErrorMessage);
	}

	// Transfer all pins to the old pins map and clear the pin list.
	TMap<FName, UEdGraphPin *> OldPins;
	for (auto It = Pins.CreateIterator(); It; ++It)
	{
		UEdGraphPin* CheckPin = *It;
		OldPins.Add(CheckPin->PinName, CheckPin);
	}
	Pins.Empty();

	// KeepPin is a function that moves a pin from the old pins
	// map back onto the pins list.
	auto KeepPin = [&](FName Name, FEdGraphPinType Type = FEdGraphPinType()) -> bool
	{
		UEdGraphPin **OldPin = OldPins.Find(Name);
		if ((OldPin != nullptr) && (((*OldPin)->PinType == Type) || (Type.PinCategory == FName())))
		{
			Pins.Emplace(*OldPin);
			OldPins.Remove(Name);
			return true;
		}
		return false;
	};

	if (!KeepPin(UEdGraphSchema_K2::PN_Execute))
	{
		CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Execute);
	}

	if (!KeepPin(UEdGraphSchema_K2::PN_Then))
	{
		CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Then);
	}

	if (!IsInvoke())
	{
		if (!KeepPin(ErrorPinName))
		{
			CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, ErrorPinName);
		}
	}

	if (!KeepPin(FunctionPinName))
	{
		UEdGraphPin *P = CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_String, FunctionPinName);
	}

	if (!KeepPin(PlacePinName))
	{
		UEdGraphPin *P = CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Object, AActor::StaticClass(), PlacePinName);
	}

	// Copy the property names into the pins.
	UEdGraphPin *FunctionPin = FindPinChecked(FunctionPinName);
	FunctionPin->DefaultValue = LuaFunctionPrototype;

	// Create Argument pins in the correct order, reusing old pins where possible.                                                                    
	for (const FlxParsedProto::Pin & Pin : ParsedProto.Arguments)
	{
		FName PrefixedName = AddPrefix(Pin.Name, 'A');
		UFunction *Accessor = UlxLuaCallLibrary::GetArgumentPacker(Pin.Type);
		if (Accessor == nullptr) {
			bHasCompilerMessage = true;
			ErrorType = EMessageSeverity::Error;
			ErrorMsg = FString::Printf(TEXT("Unknown argument type: %s"), *Pin.Type);
			continue;
		}
		FEdGraphPinType PinType = GetPinType(Accessor->FindPropertyByName(TEXT("Value")));
		if (!KeepPin(PrefixedName, PinType))
		{
			CreatePin(EGPD_Input, PinType, PrefixedName);
		}
	}

	// Create ReturnValue pins in the correct order, reusing old pins where possible.                                                                    
	for (const FlxParsedProto::Pin & Pin : ParsedProto.ReturnValues)
	{
		FName PrefixedName = AddPrefix(Pin.Name, 'R');
		UFunction *Accessor = UlxLuaCallLibrary::GetReturnValueUnpacker(Pin.Type);
		if (Accessor == nullptr) {
			bHasCompilerMessage = true;
			ErrorType = EMessageSeverity::Error;
			ErrorMsg = FString::Printf(TEXT("Unknown return value type: %s"), *Pin.Type);
			continue;
		}
		FEdGraphPinType PinType = GetPinType(Accessor->FindPropertyByName(TEXT("Result")));
		if (!KeepPin(PrefixedName, PinType))
		{
			CreatePin(EGPD_Output, PinType, PrefixedName);
		}
	}

	if (ParsedProto.ExtraReturnValues)
	{
		if (!KeepPin(ExtraResultsPinName))
		{
			CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Object, UlxLuaValues::StaticClass(), ExtraResultsPinName);
		}
	}

	// Delete any unused pins.                                                                                                                
	for (auto &iter : OldPins)
	{
		iter.Value->Modify();
		iter.Value->MarkAsGarbage();
	}
	OldPins.Empty();
}


FText UK2Node_LuaInvoke::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
	if (IsInvoke())
	{
		return LOCTEXT("LuaInvoke_Title", "Invoke a Lua Function");
	}
	else
	{
		return LOCTEXT("LuaProbe_Title", "Probe a Lua Function");
	}
}

FText UK2Node_LuaInvoke::GetPinDisplayName(const UEdGraphPin* Pin) const
{
	// The exec pins don't need labels.
	if ((Pin->PinName == UEdGraphSchema_K2::PN_Execute) || (Pin->PinName == UEdGraphSchema_K2::PN_Then))
	{
		return FText::GetEmpty();
	}
	
	// Many pins can go unlabeled if they have default values.
	if (Pin->PinName == FunctionPinName)
	{
		if (Pin->LinkedTo.Num() == 0)
		{
			return FText::GetEmpty();
		}
	}

	// For argument pins, we must strip off the Argument Pin Prefix.
	if (IsPrefix(Pin, 'A'))
	{
		return FText::FromString(RemovePrefix(Pin->PinName, 'A'));
	}

	// For return value pins, we must strip off the Return Value Pin Prefix.
	if (IsPrefix(Pin, 'R'))
	{
		return FText::FromString(RemovePrefix(Pin->PinName, 'R'));
	}

	// Otherwise, just return the Pin Name the normal way.
	return FText::FromName(Pin->PinName);
}

void UK2Node_LuaInvoke::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent)
{
	Super::PostEditChangeProperty(PropertyChangedEvent);
	GetGraph()->NotifyNodeChanged(this);
}

void UK2Node_LuaInvoke::PinConnectionListChanged(UEdGraphPin* Pin)
{
	Modify();
}

void UK2Node_LuaInvoke::PinDefaultValueChanged(UEdGraphPin* Pin)
{
	if(Pin->PinName == FunctionPinName)
	{
		LuaFunctionPrototype = Pin->DefaultValue;
		CreateCorrectPins();
		GetGraph()->NotifyNodeChanged(this);
	}
}

FText UK2Node_LuaInvoke::GetTooltipText() const
{
	return NodeTooltip;
}

void UK2Node_LuaInvoke::PostReconstructNode()
{
	Super::PostReconstructNode();
	CreateCorrectPins();
}

#define LuaCallLibraryFunction(name) (UlxLuaCallLibrary::StaticClass()->FindFunctionByName(GET_MEMBER_NAME_CHECKED(UlxLuaCallLibrary, name)))


void UK2Node_LuaInvoke::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
	Super::ExpandNode(CompilerContext, SourceGraph);
	const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();

	// Define a local function that creates a CallFunctionNode
	auto MakeCallFunctionNode = [&](UFunction *func)
	{
		UK2Node_CallFunction* CallNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
		CallNode->SetFromFunction(func);
		CallNode->AllocateDefaultPins();
		CompilerContext.MessageLog.NotifyIntermediateObjectCreation(CallNode, this);
		return CallNode;
	};

	// The BeginNode function packs the class name and function name into the call buffer.
	FlxParsedProto ParsedProto(LuaFunctionPrototype);
	UK2Node_CallFunction* BeginNode = MakeCallFunctionNode(LuaCallLibraryFunction(LuaCallBegin));
	Schema->TrySetDefaultValue(*BeginNode->FindPinChecked(TEXT("ClassName")), ParsedProto.ClassName);
	Schema->TrySetDefaultValue(*BeginNode->FindPinChecked(TEXT("FunctionName")), ParsedProto.FunctionName);
	UEdGraphPin *ThenPin = BeginNode->GetThenPin();
	
	// Add Packing operations for all argument pins.
	for (const FlxParsedProto::Pin &PinInfo : ParsedProto.Arguments)
	{
		UEdGraphPin *Pin = FindPinChecked(AddPrefix(PinInfo.Name, 'A'));
		UFunction *PackingFunc = UlxLuaCallLibrary::GetArgumentPacker(PinInfo.Type);
		if (PackingFunc == nullptr)
		{
			// This codepath should be unreachable, but just in case.
			CompilerContext.MessageLog.Error(TEXT("All argument pins must have known types"));
			continue;
		}
		UK2Node_CallFunction *PackNode = MakeCallFunctionNode(PackingFunc);
		CompilerContext.MovePinLinksToIntermediate(*Pin, *PackNode->FindPinChecked(TEXT("Value")));
		ThenPin->MakeLinkTo(PackNode->GetExecPin());
		ThenPin = PackNode->GetThenPin();
	}

	// Add the invoke or probe node.
	UEdGraphPin *ReturnArrayPin = nullptr;
	if (IsInvoke())
	{
		UK2Node_CallFunction* ActionNode = MakeCallFunctionNode(LuaCallLibraryFunction(LuaCallInvoke));
		CompilerContext.MovePinLinksToIntermediate(*FindPinChecked(PlacePinName), *ActionNode->FindPinChecked(TEXT("Place")));
		ThenPin->MakeLinkTo(ActionNode->GetExecPin());
		ThenPin = ActionNode->GetThenPin();
	}
	else
	{
		UK2Node_CallFunction* ActionNode = MakeCallFunctionNode(LuaCallLibraryFunction(LuaCallProbe));
		CompilerContext.MovePinLinksToIntermediate(*FindPinChecked(PlacePinName), *ActionNode->FindPinChecked(TEXT("Place")));
		CompilerContext.CopyPinLinksToIntermediate(*FindPinChecked(ErrorPinName), *ActionNode->FindPinChecked(TEXT("False")));
		ReturnArrayPin = ActionNode->FindPinChecked(TEXT("ReturnArray"));
		ThenPin->MakeLinkTo(ActionNode->GetExecPin());
		ThenPin = ActionNode->FindPinChecked(TEXT("True"));
	}
	
	if (IsInvoke())
	{
		// Make sure we didn't have return values for an invoke.
		if (IsInvoke() && ((ParsedProto.ReturnValues.Num() > 0) || (ParsedProto.ExtraReturnValues)))
		{
			CompilerContext.MessageLog.Error(TEXT("Lua Call in Invoke mode does not support return values"));
		}
	}
	else
	{
		// Add Unpacking operations for all return value pins.
		for (const FlxParsedProto::Pin &PinInfo : ParsedProto.ReturnValues)
		{
			UEdGraphPin *Pin = FindPinChecked(AddPrefix(PinInfo.Name, 'R'));
			UFunction *UnpackingFunc = UlxLuaCallLibrary::GetReturnValueUnpacker(PinInfo.Type);
			if (UnpackingFunc == nullptr)
			{
				// This codepath should be unreachable, but just in case.
				CompilerContext.MessageLog.Error(TEXT("All return value pins must have known types."));
				continue;
			}
			UK2Node_CallFunction *UnpackNode = MakeCallFunctionNode(UnpackingFunc);
			ReturnArrayPin->MakeLinkTo(UnpackNode->FindPinChecked(UEdGraphSchema_K2::PN_Self));
			CompilerContext.CopyPinLinksToIntermediate(*FindPinChecked(ErrorPinName), *UnpackNode->FindPinChecked(TEXT("WrongType")));
			CompilerContext.MovePinLinksToIntermediate(*Pin, *UnpackNode->FindPinChecked(TEXT("Result")));
			ThenPin->MakeLinkTo(UnpackNode->GetExecPin());
			ThenPin = UnpackNode->FindPinChecked(TEXT("Success"));
		}

		// If there is an extra results pin, hook it up.
		if (ParsedProto.ExtraReturnValues)
		{
			UEdGraphPin *ExtraPin = FindPinChecked(ExtraResultsPinName);
			UFunction *DiscardFunc = UlxLuaValues::StaticClass()->FindFunctionByName(TEXT("DiscardBeforeCursor"));
			UK2Node_CallFunction *DiscardNode = MakeCallFunctionNode(DiscardFunc);
			ReturnArrayPin->MakeLinkTo(DiscardNode->FindPinChecked(UEdGraphSchema_K2::PN_Self));
			ThenPin->MakeLinkTo(DiscardNode->GetExecPin());
			ThenPin = DiscardNode->GetThenPin();
			CompilerContext.MovePinLinksToIntermediate(*ExtraPin, *ReturnArrayPin);
		}
	}

	// Link up the Exec pins.
	CompilerContext.MovePinLinksToIntermediate(*GetExecPin(), *BeginNode->GetExecPin());
	CompilerContext.MovePinLinksToIntermediate(*GetThenPin(), *ThenPin);
	

	BreakAllNodeLinks();
}


UK2Node::ERedirectType UK2Node_LuaInvoke::DoPinsMatchForReconstruction(const UEdGraphPin* NewPin, int32 NewPinIndex, const UEdGraphPin* OldPin, int32 OldPinIndex) const
{
	ERedirectType RedirectType = ERedirectType_None;

	// if the pin names do match
	if (NewPin->PinName.ToString().Equals(OldPin->PinName.ToString(), ESearchCase::CaseSensitive))
	{
		// Make sure we're not dealing with a menu node
		UEdGraph* OuterGraph = GetGraph();
		if( OuterGraph && OuterGraph->Schema )
		{
			const UEdGraphSchema_K2* K2Schema = Cast<const UEdGraphSchema_K2>(GetSchema());
			if( !K2Schema || K2Schema->IsSelfPin(*NewPin) || K2Schema->ArePinTypesCompatible(OldPin->PinType, NewPin->PinType) )
			{
				RedirectType = ERedirectType_Name;
			}
			else
			{
				RedirectType = ERedirectType_None;
			}
		}
	}
	else
	{
		// try looking for a redirect if it's a K2 node
		if (UK2Node* Node = Cast<UK2Node>(NewPin->GetOwningNode()))
		{	
			// if you don't have matching pin, now check if there is any redirect param set
			TArray<FString> OldPinNames;
			GetRedirectPinNames(*OldPin, OldPinNames);

			FName NewPinName;
			RedirectType = ShouldRedirectParam(OldPinNames, /*out*/ NewPinName, Node);

			// make sure they match
			if ((RedirectType != ERedirectType_None) && (!NewPin->PinName.ToString().Equals(NewPinName.ToString(), ESearchCase::CaseSensitive)))
			{
				RedirectType = ERedirectType_None;
			}
		}
	}

	return RedirectType;
}

bool UK2Node_LuaInvoke::IsConnectionDisallowed(const UEdGraphPin* MyPin, const UEdGraphPin* OtherPin, FString& OutReason) const
{
	// The function pin cannot be connected.
	if (MyPin->PinName == FunctionPinName)
	{
		OutReason = LOCTEXT("Error_FunctionPrototypeMustBeHardwired", "Lua function prototype must be a hardwired constant.").ToString();
		return true;
	}

	return Super::IsConnectionDisallowed(MyPin, OtherPin, OutReason);
}

void UK2Node_LuaInvoke::GetMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
{
	// actions get registered under specific object-keys; the idea is that 
	// actions might have to be updated (or deleted) if their object-key is  
	// mutated (or removed)... here we use the node's class (so if the node 
	// type disappears, then the action should go with it)
	UClass* ActionKey = GetClass();
	// to keep from needlessly instantiating a UBlueprintNodeSpawner, first   
	// check to make sure that the registrar is looking for actions of this type
	// (could be regenerating actions for a specific asset, and therefore the 
	// registrar would only accept actions corresponding to that asset)
	if (ActionRegistrar.IsOpenForRegistration(ActionKey))
	{
		UBlueprintNodeSpawner* NodeSpawner = UBlueprintNodeSpawner::Create(GetClass());
		check(NodeSpawner != nullptr);

		ActionRegistrar.AddBlueprintAction(ActionKey, NodeSpawner);
	}
}

FText UK2Node_LuaInvoke::GetMenuCategory() const
{
	return FText::FromString(FString(TEXT("Luprex|Lua")));
}


#undef LOCTEXT_NAMESPACE