unreal/AdventureMap.cpp

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


#include "AdventureMap.h"
#include "HexTile.h"
#include "AdventurePlayerController.h"
#include "Kismet/GameplayStatics.h"
#include "Algo/Reverse.h"

// Sets default values
AAdventureMap::AAdventureMap()
{
	FHexVector NBs[] = { NNE, E, SSE, SSW, W, NNW };
	NeighborUnitVectors.Append(NBs, UE_ARRAY_COUNT(NBs));
	FHexVector DNBs[] = { N, ENE, ESE, S, WSW, WNW };
	DiagonalUnitVectors.Append(DNBs, UE_ARRAY_COUNT(DNBs));
}

// 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);
			Grid.Add(Tile);
			Tile->Q = q - 1 + QOffset;
			Tile->R = r - 1;
		}
	}
	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 Axial 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 = FMath::RandRange(0, GridSize*GridSize-1);
	return Grid[RandHex];
}

TArray<AHexTile*> AAdventureMap::Neighbors(AHexTile* OfHex, bool bFreeOnly = false)
{
	TArray<AHexTile*> Results;
	for (auto& V : NeighborUnitVectors) {
		int32 I = GridIndex(OfHex->Q + V.Q, OfHex->R + V.R);
		if (Grid.IsValidIndex(I)) { 
			AHexTile* H = Grid[I];
			if (bFreeOnly && !H->bFree) { continue; }
			if (H->Distance(OfHex) == 1) { Results.Add(H); }
		}
	}
	return Results;
}

TArray<AHexTile*> AAdventureMap::FreeDiagonals(AHexTile* OfHex)
{
	TArray<AHexTile*> Results;
	for (auto& V : DiagonalUnitVectors) {
		int32 I = GridIndex(OfHex->Q + V.Q, OfHex->R + V.R);
		if (!Grid.IsValidIndex(I)) { continue; }
		else {
			bool bReachable = true;
			for (AHexTile* PotentialBlock : Neighbors(OfHex)) {
				if (PotentialBlock->Distance(Grid[I]) != 1) { continue; }
				if (!PotentialBlock->bFree) {
					bReachable = false;
					break;
				}
			}
			if (bReachable) { Results.Add(Grid[I]); }
		}
	}
	return Results;
}

TSet<AHexTile*> AAdventureMap::BreadthFirstSearch(AHexTile* Start, int32 Radius)
{
	TSet<AHexTile*> Results;
	TArray<AHexTile*> ToExamine;
	TSet<AHexTile*> Processed;
	Results.Add(Start);
	ToExamine.Add(Start);

	while (!ToExamine.IsEmpty()) {
		AHexTile* Candidate = ToExamine[0];
		Processed.Add(Candidate);
		ToExamine.Remove(Candidate);

		for (AHexTile* Neighbor : Neighbors(Candidate)) {
			if (Neighbor->Distance(Candidate) > 1)	{ continue; }
			if (Processed.Contains(Neighbor))		{ continue; }
			if (Neighbor->Distance(Start) > Radius)	{ continue; }

			ToExamine.Add(Neighbor);
			Results.Add(Neighbor);
		}
	}
	return Results;
}

TArray<AHexTile*> AAdventureMap::FindPathAStar(AHexTile* Start, AHexTile* Goal, bool bDiags)
{
	TArray<AHexTile*> ToExamine;
	TSet<AHexTile*> Processed;
	ToExamine.Add(Start);

	while (!ToExamine.IsEmpty()) {
		AHexTile* Candidate = ToExamine[0];
		ToExamine.Remove(Candidate);
		// try for Hex with lower estimatet (F)cost
		for (AHexTile* t : ToExamine) {
			t->FCost = t->GCost + t->HCost;
			if (t->FCost < Candidate->FCost || t->FCost == Candidate->FCost && t->HCost < Candidate->HCost) { Candidate = t; }
		}

		Processed.Add(Candidate);
		// exit
		if (Candidate == Goal) { break; }

		// expand frontier & adjust path data
		for (AHexTile* Neighbor : Neighbors(Candidate, true)) {
			if (!Neighbor->bFree) { continue; }
			if (Processed.Contains(Neighbor)) { continue; }

			bool bInToExamine = ToExamine.Contains(Neighbor);
			float NewGCost = Candidate->GCost + Neighbor->MoveCost;

			if (NewGCost < Neighbor->GCost || !bInToExamine) {
				Neighbor->GCost = NewGCost;
				Neighbor->CameFrom = Candidate; // chain
				Neighbor->bDiagMove = false;

				if (!bInToExamine) {
					Neighbor->HCost = Neighbor->Distance(Goal);
					ToExamine.Add(Neighbor);
			}	}
		}
		/*
		if (bDiags) {
			for (AHexTile* Diag : FreeDiagonals(Candidate)) {
				if (!Diag->bFree) { continue; }
				if (Processed.Contains(Diag)) { continue; }

				bool bInToExamine = ToExamine.Contains(Diag);
				float NewGCost = Candidate->GCost + Diag->MoveCost;

				if (NewGCost < Diag->GCost || !bInToExamine) {
					Diag->GCost = NewGCost;
					Diag->CameFrom = Candidate; // chain
					Diag->bDiagMove = true;

					if (!bInToExamine) {
						Diag->HCost = Diag->Distance(Goal);
						ToExamine.Add(Diag);
				}	}
			}
		}*/
	}
	TArray<AHexTile*> Path;
	if (!IsValid(Goal->CameFrom)) { return Path; }
	AHexTile* iPathNode = Goal;
	while (iPathNode != Start) {
		Path.Emplace(iPathNode);
		iPathNode = iPathNode->CameFrom;
	}
	Algo::Reverse(Path);

	if (bDiags) {
		Path = ShortcutAStar(Path);
	}

	return Path;
}


TArray<AHexTile*> AAdventureMap::ShortcutAStar(TArray<AHexTile*> Path) 
{
	TArray<AHexTile*> Shortcut;
	int32 Len = Path.Num();
	AHexTile* Milestone;
	int32 BeforeBend;
	int32 AfterBend;
	int32 HexIter = 1;
	FHexVector pDir;
	FHexVector DirA;
	FHexVector DirB;
	AHexTile* Current = Path[0]; // beginning of curve (starts at Start)

	while (Milestone != Path[Len - 1]) {
		// find Milestone (i.e. end of first curve) & determine curve data
		BeforeBend = 1;
		for (HexIter; HexIter < Len; HexIter++) {
			pDir = FHexVector(Path[HexIter], Path[HexIter - 1]);
			DirA = FHexVector(Path[HexIter + 1], Path[HexIter]);
			if (DirA == pDir) { BeforeBend++; }
			else { break; }
		}
		AfterBend = 1;
		for (HexIter; HexIter < Len; HexIter++) {
			pDir = FHexVector(Path[HexIter], Path[HexIter - 1]);
			DirB = FHexVector(Path[HexIter + 1], Path[HexIter]);
			if (DirB == pDir) { AfterBend++; }
			else { break; }
		}
		FHexVector Diag = UnitDiagFromUnitNB(DirA, DirB); // cardinal direction for potential shortcut
		TArray<AHexTile*> WorkingSegment; // current curve
		for (int32 i = Path.Find(Current); i < HexIter; i++) { WorkingSegment.Add(Path[i]); }
		Milestone = Path[HexIter]; // end of curve
		int32 ShoCutLen;
		int32 NumDiags; // max number of tries to take a Diagonal
		if (BeforeBend >= AfterBend) {
			ShoCutLen = BeforeBend;
			NumDiags = AfterBend;
		}
		if (BeforeBend < AfterBend) {
			ShoCutLen = AfterBend;
			NumDiags = BeforeBend;
		}

		TArray<AHexTile*> NewSegment;
		// link from Current to Milestone with diagonals
		for (int32 i = 0; i < NumDiags; i++) {
			AHexTile* NewCandidate = Grid[GridIndex(Current->Q + Diag.Q, Current->R + Diag.R)];

			if (i==0 && !DiagIsReachable(Current, Diag) || i==0 && !NewCandidate->bFree) {
				Current = WorkingSegment[i + 1];
				i++;
				continue;
			}
			NewSegment.Add(NewCandidate);
		}
		// connect the rest via A* probably, think about checking whether the result is really shorter
		int32 CIndex = WorkingSegment.Find(Current);
		while (Current != Milestone) {
			Current = WorkingSegment[CIndex];
			NewSegment.Add(Current);
			CIndex++;
		}

		
	}

	// Construct shortcut
	return Shortcut;
}


FHexVector AAdventureMap::UnitDiagFromUnitNB(FHexVector InVecA, FHexVector InVecB) {
	if (InVecA == NNW && InVecB == NNE||InVecB == NNW && InVecA == NNE)	{ return N; }
	if (InVecA == NNE && InVecB == E  ||InVecB == NNE && InVecA == E)	{ return ENE; }
	if (InVecA == E   && InVecB == SSE||InVecB == E   && InVecA == SSE)	{ return ESE; }
	if (InVecA == SSE && InVecB == SSW||InVecB == SSE && InVecA == SSW)	{ return S; }
	if (InVecA == SSW && InVecB == W  ||InVecB == SSW && InVecA == W)	{ return WSW; }
	if (InVecA == W   && InVecB == NNW||InVecB == W   && InVecA == NNW)	{ return WNW; }
	return FHexVector();
}
bool AAdventureMap::DiagIsReachable(AHexTile* InStart, FHexVector InDiagUnitVec) {
	FHexVector BlockA;
	FHexVector BlockB;
	if (InDiagUnitVec == N) { BlockA = NNW, BlockB = NNE; }
	if (InDiagUnitVec == ENE) { BlockA = NNE, BlockB = E; }
	if (InDiagUnitVec == ESE) { BlockA = E, BlockB = SSE; }
	if (InDiagUnitVec == S)	{ BlockA = SSE, BlockB = SSW; }
	if (InDiagUnitVec == WSW) { BlockA = SSW, BlockB = W; }
	if (InDiagUnitVec == WNW) { BlockA = W, BlockB = NNW; }
	AHexTile* HexA = Grid[GridIndex(InStart->Q + BlockA.Q, InStart->R + BlockA.R)];
	AHexTile* HexB = Grid[GridIndex(InStart->Q + BlockB.Q, InStart->R + BlockB.R)];
	return (HexA->bFree && HexB->bFree);
}