integration/Source/Integration/IntegrationGameModeBase.cpp

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

#include "IntegrationGameModeBase.h"
#include "drvutil.hpp"
#include "engineutil.hpp"
#include <string>
#include <string_view>



EngineWrapper AIntegrationGameModeBase::Luprex;

//// Main loop.
//while (!engw.get_stop_driver(&engw)) {
//	handle_lua_source();
//	handle_console_output();
//	handle_new_outgoing_sockets();
//	handle_socket_input_output();
//	handle_console_input();
//	handle_console_output();
//	engw.play_invoke_event_update(&engw, drvutil::get_monotonic_clock());
//}

AIntegrationGameModeBase::AIntegrationGameModeBase()
{
	Thread = nullptr;
	ThreadStopRequested = false;
	EngineSeconds = 0.0;
	NextThreadTrigger = 1.0;
	//PrimaryActorTick.bCanEverTick = true; // Probably wrong
	//PrimaryActorTick.bTickEvenWhenPaused = true; // Probably wrong
	//PrimaryActorTick.TickGroup = TG_PrePhysics; // Probably wrong
	SetActorTickEnabled(true);
	SetActorTickInterval(0.05f);
	ThreadEvent = FPlatformProcess::GetSynchEventFromPool(false);
}

AIntegrationGameModeBase::~AIntegrationGameModeBase()
{
	WaitForThread();
	FPlatformProcess::ReturnSynchEventToPool(ThreadEvent);
	ThreadEvent = nullptr;
}

void AIntegrationGameModeBase::HandleLuprexConsoleOutput()
{
	uint32_t ndata; const char* data;
	Luprex.get_outgoing(&Luprex, 0, &ndata, &data);
	if (ndata == 0) return;
	std::string_view src(data, ndata);
	int consumed;
	std::u16string cps = drvutil::utf8_to_ucs2(src, &consumed);
	Luprex.play_sent_outgoing(&Luprex, 0, consumed);
	FString fs(cps.size(), (const UCS2CHAR*)(&cps[0]));
	ConsoleOutput.Append(fs);
}

// Run routine called by the worker thread.
uint32 AIntegrationGameModeBase::Run()
{
	while (true)
	{
		bool triggered = ThreadEvent->Wait(3000);
		if (ThreadStopRequested) {
			engineutil::DPrint("Thread stopping as requested");
			break;
		}
		if (!triggered) {
			engineutil::DPrint("Thread waiting a long time...");
			continue;
		}
		engineutil::DPrint("Thread triggered.");
		{
			FScopeLock lk(&LuprexMutex);
			Luprex.play_invoke_event_update(&Luprex, EngineSeconds);
		}
	}
	return 0;
}

#pragma optimize( "", off )
void AIntegrationGameModeBase::WaitForThread()
{
	if (Thread == nullptr) return;
	ThreadStopRequested = true;
	ThreadEvent->Trigger();
	delete Thread; // This waits for the thread to complete.
	Thread = nullptr;
}

void AIntegrationGameModeBase::Tick(float DeltaSeconds)
{
	Super::Tick(DeltaSeconds);
	{
		FScopeLock lk(&LuprexMutex);
		EngineSeconds += DeltaSeconds;
		HandleLuprexConsoleOutput();
	}
	TArray<FString> prints = engineutil::DPrintGetStored();
	for (const FString& fs : prints) {
		ConsoleOutput.AppendLine(fs);
	}
	if (ConsoleOutput.IsDirty())
	{
		ConsoleSetOutput(ConsoleOutput.Get());
		ConsoleOutput.ClearDirty();
	}
	if ((Thread != nullptr) && (EngineSeconds >= NextThreadTrigger))
	{
		ThreadEvent->Trigger();
		NextThreadTrigger += 1.0;
	}
}

void AIntegrationGameModeBase::ConsoleSendInput(const FString& fs)
{
	if (Luprex.engine != nullptr)
	{
		FScopeLock lk(&LuprexMutex);
		const TCHAR* fstchar = *fs;
		if (sizeof(TCHAR) == 2)
		{
			ConsoleOutput.AppendLine(FString("> ") + fs);
			std::u16string_view fsview((const char16_t*)fstchar, fs.Len());
			std::string utf8 = drvutil::utf16_to_utf8(fsview);
			utf8 = utf8 + "\n";
			Luprex.play_recv_incoming(&Luprex, 0, utf8.size(), utf8.c_str());
		}
	}
}

void AIntegrationGameModeBase::BeginPlay()
{
	Super::BeginPlay();

	// There should be no thread at this point.
	checkf(Thread == nullptr, TEXT("There should be no thread here."));

	// Reinitialize simple state.
	EngineSeconds = 0;
	NextThreadTrigger = 1.0;
	ThreadStopRequested = false;
	ThreadEvent->Wait(0); // Clear the event if set.

	// Try to initialize the wrapper.
	if (Luprex.play_initialize == nullptr)
	{
		engineutil::init_wrapper(&Luprex);
		if (Luprex.play_initialize == nullptr)
		{
			engineutil::DPrint("Luprex wrapper initialization failed");
		}
	}

	// If wrapper is initialized, try to initialize the luprex engine.
	if (Luprex.play_initialize != nullptr)
	{
		Luprex.release(&Luprex);
		Luprex.hook_dprint(engineutil::DPrintHook);

		drvutil::ostringstream srcpak;
		std::string srcpakerr = drvutil::package_lua_source("c:\\Luprex", &srcpak);
		if (!srcpakerr.empty())
		{
			engineutil::DPrint(srcpakerr.c_str());
		}
		std::string_view srcpakv = srcpak.view();
		char* argv[1];
		argv[0] = const_cast<char*>("lpxserver");
		Luprex.play_initialize(&Luprex, 1, argv, srcpakv.size(), srcpakv.data(), "");
		if (Luprex.error[0])
		{
			engineutil::DPrint(Luprex.error);
		}
		else
		{
			engineutil::DPrint("Luprex initialize success");
		}
	}

	// If we successfully created a Luprex engine, create a worker thread.
	if (Luprex.engine != nullptr)
	{
		Thread = FRunnableThread::Create(this, TEXT("Worker Thread"));
	}
}

void AIntegrationGameModeBase::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	WaitForThread();
}