CPP:
#include "AtecConnectPluginPrivatePCH.h"
#include "AtecConnectLibrary.h"
#include "Engine.h"
 FSocket* Socket;
 int32 BufferSize;
 bool connected;
 FString API_KEY;
 FString PROJECT_ID;
 UAtecConnectLibrary::UAtecConnectLibrary(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{

}

 UAtecConnectLibrary* UAtecConnectLibrary::MakeAtecConnect(UObject* WorldContextObject)
 {
	 return NewObject<UAtecConnectLibrary>();
 }

int32 UAtecConnectLibrary::ConnectToServer(FString APIKEY, FString PROJECTID, FString IP)
{
	StartTCP("RamaSocketListener", IP, APIKEY, PROJECTID, 8890);


	return 12;
}

void UAtecConnectLibrary::Test()
{
	GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Green, TEXT("TEST"));
}

void UAtecConnectLibrary::GetGameServers()
{
	//OnRecieveServersDelegate.AddDynamic(this, &UAtecConnectLibrary::Test);
	FServerStruct test;
	test.IP = TEXT("13123123123");
	test.PORT = TEXT("13123123123");
	SendTCP("GET_GAMESERVERS|API_KEY=" + API_KEY + ";PROJECT_ID=" + PROJECT_ID+";");


	TestDelegate.Broadcast(); // <<<<<<< -----------------------------


	if (TestDelegate.IsBound())

	{
		GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Green, TEXT("BOUND"));
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Green, TEXT("NOT BOUND"));
	}

}

bool UAtecConnectLibrary::StartTCP(
	const FString& YourChosenSocketName,
	const FString& TheIP,
	const FString APIKEY, const FString PROJECTID,
	const int32 ThePort
	)
{
	Socket =
		ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, TEXT("default"), false);

	API_KEY = APIKEY;
	PROJECT_ID = PROJECTID;



	FString address = TEXT("127.0.0.1");
	int32 port = 7000;
	FIPv4Address ip;
	FIPv4Address::Parse(address, ip);

	TSharedRef<FInternetAddr> addr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
	addr->SetIp(ip.GetValue());
	addr->SetPort(port);

	connected = Socket->Connect(*addr);

	BufferSize = 1024;
	Socket->SetSendBufferSize(BufferSize, BufferSize);
	Socket->SetReceiveBufferSize(BufferSize, BufferSize);
	Socket->SetNonBlocking(true);

	GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Red, TEXT("SENDING CONNECTION STRING!"));

	if (connected)
	{
		GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Red, TEXT("CONNECTED!"));
		SendTCP("GAME_CONNECTED|API_KEY=" + API_KEY + ";PROJECT_ID=" + PROJECT_ID + ";");
	}
	return connected;
}

bool UAtecConnectLibrary::SendTCP(FString Message)
{
	FString serialized = Message;
	TCHAR *serializedChar = serialized.GetCharArray().GetData();
	int32 size = FCString::Strlen(serializedChar);
	int32 sent = 0;
	bool successful = Socket->Send((uint8*)TCHAR_TO_UTF8(serializedChar), size, sent);
	return successful;
}
void UAtecConnectLibrary::RecieveLoop()
{
	TArray<uint8> ReceivedData;
	TSharedRef<FInternetAddr> ReceivedAddr =
		ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();

	uint32 Size;
	bool bIsDataReceived = false;

	if (Socket->HasPendingData(Size))
	{
		ReceivedData.Init(FMath::Min(Size, 65507u));

		int32 Read = 0;
		Socket->RecvFrom(ReceivedData.GetData(), BufferSize, Read, *ReceivedAddr);

		if (Read > 0)
		{
			FString ConvertedData = StringFromBinaryArray(ReceivedData);
			bIsDataReceived = true;
			//FString ID = GetParameterFromString(ConvertedData , "ID");
			GEngine->AddOnScreenDebugMessage(-1, 15.0f, FColor::Green, ConvertedData);
			FString COMMAND = GetCommandFromString(ConvertedData);
			RecieveSwitch(ConvertedData);

		}
	}
}

void UAtecConnectLibrary::RecieveSwitch(FString Data)
{
	if (GetCommandFromString(Data) == TEXT("GET_SEVERS"))
	{
		TArray<FString> OBJECTS = GetArrayFromString(Data, "servers", "SERVER");
		TArray<FServerStruct> Servers;
		for (int i = 0; i < OBJECTS.Num(); i++)
		{
		   FServerStruct ServerToAdd;
		   ServerToAdd.IP = GetParameterFromString(OBJECTS[i], TEXT("IP"));
			ServerToAdd.PORT = GetParameterFromString(OBJECTS[i], TEXT("PORT"));




		}



	}
}

FString UAtecConnectLibrary::StringFromBinaryArray(const TArray<uint8>& BinaryArray)
{
	//Create a string from a byte array!
	std::string cstr(reinterpret_cast<const char*>(BinaryArray.GetData()), BinaryArray.Num());

	return FString(cstr.c_str());
}

FString UAtecConnectLibrary::GetCommandFromString(FString raw)
{
	FString commandReturn = "SEARCH_FAILED";
	FString val = "";

	commandReturn = raw.Mid(0, raw.Find((TEXT("|"))));

	if (val != TEXT(""))
	{
		commandReturn = val;
	}

	return commandReturn;
}

FString UAtecConnectLibrary::GetParameterFromString(FString raw, FString toSearch)
{
	int32 KeyPostion;

	int32 ValuePosition;
	FString Value = "SEARCH_FAILED";

	int32 EndPostion;

	bool IsArray;
	bool IsObject;

	KeyPostion = raw.Find(toSearch);
	ValuePosition = raw.Find("=",ESearchCase::IgnoreCase,ESearchDir::FromStart,KeyPostion + toSearch.Len());

	IsArray = raw.Contains("[");
	IsObject = raw.Contains("{");


	if (IsArray)
	{
		int32 ClosingBracket;
		ClosingBracket = raw.Find("]");
		if (ClosingBracket == -1)
		{
			return "NO_CLOSING_BRACKET";

		}

		EndPostion = raw.Find(";", ESearchCase::IgnoreCase, ESearchDir::FromStart, ClosingBracket);
		if (EndPostion == -1)
		{

			return "NO_CLOSING_SEMICOLON";
		}
	}
	else if (IsObject)
	{
		int32 ClosingBracket;
		ClosingBracket = raw.Find("}");
		if (ClosingBracket == -1)
		{
			return "NO_CLOSING_BRACKET";
		}

		EndPostion = raw.Find(";", ESearchCase::IgnoreCase, ESearchDir::FromStart, ClosingBracket);
		if (EndPostion == -1)
		{

			return "NO_CLOSING_SEMICOLON";
		}
	}
	else
	{
		EndPostion = raw.Find(";");
		if (EndPostion == -1)
		{
			return "NO_CLOSING_SEMICOLON";
		}
	}

	Value = raw.Mid(ValuePosition + 1, EndPostion - ValuePosition -1);

	return Value;
}

 TArray<FString> UAtecConnectLibrary::GetArrayFromString(FString raw,
	 FString arrayName, FString objectName)
{
	//ARRAY STRING: SERVERS=[SERVER={IP:0.0.0.0;PORT=7777;};SERVER={IP:0.0.0.0;PORT=7777;};];


	FString ArrayString = GetParameterFromString(raw, arrayName);
	//EXPECTED RETURNS; [SERVER={IP:0.0.0.0;PORT=7777;};SERVER={IP:0.0.0.0;PORT=7777;};];

	//Trim String
	int32 ArrayDataStart = ArrayString.Find("[") + 1;
	int32 ArrayDataEnd = ArrayString.Find("]");
	FString ArrayData = ArrayString.Mid(ArrayDataStart, ArrayDataEnd - ArrayDataStart);

	TArray<int32> ObjectIndexes;
	bool ObjectFinderCompleted = false;
	int32 LastIndex = 0;

	TArray<FString> ArrayReturn;
	int32 LoopCount = 0;


	while (!ObjectFinderCompleted)
	{
		int32 CurrentIndex = ArrayData.Find(objectName, ESearchCase::CaseSensitive, ESearchDir::FromStart, LastIndex);
		LastIndex = CurrentIndex + objectName.Len();


		LoopCount++;

		if (CurrentIndex == -1 || LoopCount == 5)
		{
			ObjectFinderCompleted = true;
		}
		else
		{

			ObjectIndexes.Add(CurrentIndex);
		}
	}

	for (int i = 0; i < ObjectIndexes.Num(); i++)
	{
		int32 ObjectLength = ArrayData.Find(TEXT(";"), ESearchCase::CaseSensitive,
			ESearchDir::FromEnd, ObjectIndexes[i] + objectName.Len()) - ObjectIndexes[i];

		FString ObjectToParse = ArrayData.Mid(ObjectIndexes[i]);


		FString ObjectToAdd = GetObjectFromString(ObjectToParse, objectName);
		ArrayReturn.Add(ObjectToAdd);
	}

	return ArrayReturn;
}

FString UAtecConnectLibrary::GetObjectFromString(FString raw, FString objectName)
{

	//OBJECT STRING: SERVER={IP:0.0.0.0;PORT=7777;};

	FString ObjectString = GetParameterFromString(raw, objectName);
	//EXPECTED RETURN: {IP:0.0.0.0;PORT=7777;};

	//Trim String
	int32 ObjectDataStart = ObjectString.Find("{") + 1;
	int32 ObjectDataEnd = ObjectString.Find("}");
	FString ObjectData = ObjectString.Mid(ObjectDataStart, ObjectDataEnd - ObjectDataStart);

	//RETURN: IP:0.0.0.0;PORT=7777;
	return ObjectData;
}