unreal/AdventureMap.cpp

// Fill out your copyright notice in the Description page of Project Settings.


#include "AdventureMap.h"
#include "HexTile.h"
#include "AdventureCameraPawn.h"
#include "AdventureCharacter.h"
#include "Kismet/GameplayStatics.h"
#include "Algo/Reverse.h"
#include <unordered_map>

// Sets default values
AAdventureMap::AAdventureMap()
{
}

// Called when the game starts or when spawned
void AAdventureMap::BeginPlay()
{
	Super::BeginPlay();
	World = GetWorld();
	if (IsValid(BaseTileClass)) 
	{ 
		MakeGrid();
	}
}

// Called once on Begin Play
void AAdventureMap::MakeGrid() 
{	
	FVector NextHexAt = FVector();
	float HexWidth = sqrt(3) * TileSize;
	int QOffset = 0;

	for (int r = 1; r <= GridSize; r++) 
	{
		float XOffset = 0.f;

		if (r % 2 != 0)
		{
			if (r > 1)
			{
				QOffset--;
			}
		}
		else { XOffset = HexWidth / 2; }

		for (int q = 1; q <= GridSize; q++)
		{
			NextHexAt.X = XOffset + (HexWidth * q);
			NextHexAt.Y = TileSize * 1.5f * r;
			NextHexAt.Z = 0.f;

			FTransform SpawnTransform = FTransform(NextHexAt);
			AHexTile* Tile = World->SpawnActor<AHexTile>(BaseTileClass, SpawnTransform);

			Tile->Q = q - 1 + QOffset;
			Tile->R = r - 1;

			Grid.Add(Tile);
		}
	}

	for (auto& tile : Grid)
	{
		tile->Index = GridIndex(tile->Q, tile->R);
	}

	bHexGridReady = true;
}

// Every Hex Tile's index within the Grid Array can be derived from its Q and R coordinates
int32 AAdventureMap::GridIndex(int32 qAxial, int32 rAxial)
{
	/*
	*	The Q axis is (i.e. columns are) oriented diagonally.
	*	The Hex Grid has a rough square shape, hence the Q coordinates must be offset by -1 every other row.
	*/
	int32 column = qAxial + FMath::FloorToInt(rAxial / 2);
	return (rAxial * GridSize) + column;
}

AHexTile* AAdventureMap::RandomHex()
{
	int32 RandHex = GridIndex(FMath::RandRange(0, GridSize-1), FMath::RandRange(0, GridSize-1));
	return Grid[RandHex];
}

TArray<AHexTile*> AAdventureMap::Neighbors(AHexTile* OfHex)
{
	TArray<AHexTile*> Neighbors;
	int32 I;

	I = GridIndex(OfHex->Q + 1	, OfHex->R + 0	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	I = GridIndex(OfHex->Q + 1	, OfHex->R - 1	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	I = GridIndex(OfHex->Q + 0	, OfHex->R - 1	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	I = GridIndex(OfHex->Q - 1	, OfHex->R + 0	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	I = GridIndex(OfHex->Q - 1	, OfHex->R + 1	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	I = GridIndex(OfHex->Q + 0	, OfHex->R + 1	);
	if (Grid.IsValidIndex(I) && OfHex->Distance(Grid[I]) == 1) { Neighbors.Add(Grid[I]); }

	return Neighbors;
}

// Massive memory leak when Goal is more than 2 distance away from Start (leading to the Editor freezing)
// Also freezes when the Goal is on the Edge of the map (i.e. has only 3 Neighbors)
TArray<AHexTile*> AAdventureMap::FindPathAStar(AHexTile* Start, AHexTile* Goal)
{
	TArray<AHexTile*> PQ; // Makeshift Priority Queue.	(High value = Low priority)
	PQ.Init(Start, 1);

	// The goal of this loop is to edit the Hex->CameFrom pointers, So as to chain Hexes from Goal to Start
	while (!PQ.IsEmpty())
	{
		AHexTile* Current = PQ[0];
		PQ.RemoveAt(0);
		UE_LOG(LogTemp, Warning, TEXT("Popping top priority Hex Q:%d|R:%d"), Current->Q, Current->R);

		if (Current == Goal) // early exit
		{ 
			UE_LOG(LogTemp, Warning, TEXT("Goal found!!!")); // debug
			break; 
		}

		UE_LOG(LogTemp, Warning, TEXT("Expanding the frontier...")); // debug
		for (AHexTile* Next : Neighbors(Current))
		{
			int32 NewCost = Current->CostSoFar + Next->MoveCost;			
			if (NewCost < Next->CostSoFar || !PQ.Contains(Next))
			{
				Next->CostSoFar = NewCost;
				Next->CameFrom = Current;
				PQ.Remove(Next);
				int32 NewPrio = NewCost + Next->Distance(Goal); // Higher value = Lower priority

				UE_LOG(LogTemp, Warning, TEXT("Hex Q:%d|R:%d pathing updated. Readjusting priorities..."), Next->Q, Next->R); // debug
				if (!PQ.IsEmpty())
				{
					int32 OldPrio;
					int32 OldIndex = PQ.Num() - 1; // To be inserted as lowest priority by default

					for (AHexTile* Hex : PQ)
					{
						OldPrio = Hex->CostSoFar + Hex->Distance(Goal);
						if (NewPrio <= OldPrio) // looking for 1. Hex in "PQ" with a lower priority than that of "Next"
						{
							PQ.Find(Hex, OldIndex); // redefining of "OldIndex"
							break;
						}
					}
					UE_LOG(LogTemp, Warning, TEXT("Inserting Hex at priority %d"), OldIndex); // debug
					PQ.Insert(Next, OldIndex);
				}
				else
				{
					PQ.Add(Next);
					UE_LOG(LogTemp, Warning, TEXT("Adding one last Candidate.")); // debug
				}
			}
		}	
	}
	TArray<AHexTile*> Path;
	AHexTile* Hex = Goal;
	while (Hex != Start)
	{
		Path.Emplace(Hex);
		Hex = Hex->CameFrom;
	}
	Algo::Reverse(Path);
	return Path;
}

/*
// alternative implementation using faster built in priority queue data structure
TArray<AHexTile*> AAdventureMap::FindPathAStarPQ(AHexTile* Start, AHexTile* Goal)
{
	// TArray<AHexTile*> PQ;
	std::priority_queue<AHexTile*, std::vector<AHexTile*>> PQ; // currently missing a custom comparator as third template arg (designating effective priority of pq elements)
	std::unordered_map<AHexTile*, AHexTile*> CameFrom; // if in doubt: switch to templates instead of predefined hex types
	// PQ.Init(Start, 1);
	PQ.push(Start);
	CameFrom[Start] = Start;

	// while (!PQ.IsEmpty())
	while (!PQ.empty())
	{
		AHexTile* Current = PQ.top();
		// PQ.RemoveAt(0);
		PQ.pop();
		if (Current == Goal)
		{
			UE_LOG(LogTemp, Warning, TEXT("Goal found!")); // debug
			break;
		}

		// Expanding the Frontier
		for (AHexTile* Next : Neighbors(Current))
		{
			int32 NewCost = Current->CostSoFar + Next->MoveCost;
			// UE_LOG(LogTemp, Warning, TEXT("Cost calculated.")); // debug

			if (!PQ.Contains(Next) || NewCost < Next->CostSoFar)
			{
				// UE_LOG(LogTemp, Warning, TEXT("New candidate found.")); // debug
				Next->CostSoFar = NewCost;
				int32 NewPrio = NewCost + Next->Distance(Goal);

				// Adjust the Priority Queue
				if (PQ.Contains(Next)) { PQ.Remove(Next); }
				for (AHexTile* Hex : PQ) // at this point PQ is empty, need to make sure it's not.
				{
					int32 OldPrio = Hex->CostSoFar + Hex->Distance(Goal);
					int32 Index;
					PQ.Find(Hex, Index);
					// UE_LOG(LogTemp, Warning, TEXT("Comparing priorities...")); // debug

					if (OldPrio > NewPrio)
					{
						PQ.Insert(Next, Index);
						Next->CameFrom = Current;
						// UE_LOG(LogTemp, Warning, TEXT("Looks promising!")); // debug
						break;
					}

					if (Index == PQ.Num() - 1 && OldPrio <= NewPrio)
					{
						PQ.Emplace(Next);
						Next->CameFrom = Current;
						// UE_LOG(LogTemp, Warning, TEXT("Low prio added")); // debug
						break;
					}
				}

				if (PQ.IsEmpty()) { PQ.Emplace(Next); }
			}
		}
	}

	TArray<AHexTile*> Path;
	AHexTile* Hex = Goal;
	while (Hex != Start)
	{
		Path.Emplace(Hex);
		Hex = Hex->CameFrom;
	}

	Algo::Reverse(Path);
	return Path;
}
*/