294 lines
8.6 KiB
C++
294 lines
8.6 KiB
C++
// 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 = Path[0];
|
|
int32 BeforeBend;
|
|
int32 AfterBend;
|
|
int32 HexIter = 1;
|
|
FHexVector pDir;
|
|
FHexVector DirA;
|
|
FHexVector DirB;
|
|
AHexTile* Current;
|
|
|
|
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); // (exact diagonal) cardinal direction for shortcut
|
|
TArray<AHexTile*> WorkingSegment;
|
|
for (int32 i = Path.Find(Milestone); i < HexIter; i++) { WorkingSegment.Add(Path[i]); }
|
|
Milestone = WorkingSegment.Last();
|
|
Current = WorkingSegment[0];
|
|
bool bFirstDiagTaken = false;
|
|
TArray<AHexTile*> NewSegment; // ideally the entire shortcut (ends at bBlock, whence we continue by A*)
|
|
|
|
// link from Current to Milestone
|
|
for (int32 i = 0; i < BeforeBend; i++) {
|
|
Current = WorkingSegment[i];
|
|
AHexTile* NewCandidate = Grid[GridIndex(Current->Q + Diag.Q, Current->R + Diag.R)];
|
|
if (!DiagIsReachable(Current, Diag) || !NewCandidate->bFree) {
|
|
if (bFirstDiagTaken) { break; }
|
|
NewSegment.Add(Current);
|
|
continue;
|
|
}
|
|
NewSegment.Add(NewCandidate);
|
|
bFirstDiagTaken = true;
|
|
}
|
|
|
|
// Check how much remains until we reach milestone and
|
|
// Connect the rest recursively via A* (with shortcuts)
|
|
// Consider whether the resulting path really is shorter
|
|
|
|
Shortcut.Append(NewSegment);
|
|
}
|
|
|
|
// 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);
|
|
} |