260 lines
6.9 KiB
C++
260 lines
6.9 KiB
C++
// 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;
|
|
}
|
|
*/ |