AI Director

// Discern possible horde spawn zone before next wave
myPossibleHordeSpawnZones.Clear();
myPossibleHordeSpawnZones = myActiveArea;
myPossibleHordeSpawnZones += myExitedArea;

AreaSet impossibleZones;
impossibleZones.Insert(playerCell);

const Tga::Vector3f playerCellPosition = GetXZPositionFromIndex(playerCell);
for (const int cell : myPossibleHordeSpawnZones.GetCells())
{
	// minimum distance check
	const Tga::Vector3f otherCellPosition = GetXZPositionFromIndex(cell);
	const Tga::Vector3f cellToPlayer = (playerCellPosition - otherCellPosition);
	const float distance = cellToPlayer.Length();

	// lower number means more generous inclusion
	if (distance < (myActiveAreaRadius * HORDE_AREA_FIDELITY))
	{
		impossibleZones.Insert(cell);
		continue;
	}

	const Tga::Vector3f cellToPlayerNormalized = cellToPlayer.GetNormalized();
	constexpr float traceFidelity = 0.25f; // lower number means higher fidelity;
	const int steps = static_cast<int>(distance / (myGridCellHalfLength * traceFidelity));
	const float increment = distance / static_cast<float>(steps);


	// check if player can see the spawn zone by quickly tracing a line from the zone to the player
	bool isPossible = false;

	for (int step = 0; step < steps; ++step)
	{
		const int cellToCheck = GetCellIndexFromPosition(otherCellPosition + (cellToPlayerNormalized * increment * static_cast<float>(step + 1)));
		if (myGrid[cellToCheck].status == CellStatus::Invalid)
		{
			isPossible = true;
			break;
		}
	}

	if (!isPossible)
	{
		impossibleZones.Insert(cell);
	}

}

myPossibleHordeSpawnZones -= impossibleZones;
    

auto sortClosestToPlayer = [this, playerCellPosition](const int cellA, const int cellB)
	{
		const float lengthSqrToA = (playerCellPosition - GetXZPositionFromIndex(cellA)).LengthSqr();
		const float lengthSqrToB = (playerCellPosition - GetXZPositionFromIndex(cellB)).LengthSqr();
		return lengthSqrToA < lengthSqrToB;
	};

if (myPossibleHordeSpawnZones.GetCells().empty()) return;

std::ranges::sort(myPossibleHordeSpawnZones.AccessCells().begin(), myPossibleHordeSpawnZones.AccessCells().end(), sortClosestToPlayer);

// only keep the closest ones
const int maxZones = std::clamp(static_cast<int>(myPossibleHordeSpawnZones.GetCells().size()), 0, SPAWN_ZONE_ROOF);

if (maxZones == 0) { return; }

myPossibleHordeSpawnZones.AccessCells() = std::vector(myPossibleHordeSpawnZones.GetCells().begin(), myPossibleHordeSpawnZones.GetCells().begin() + maxZones);
    

std::vector<std::pair<int, size_t>> cellWithFlowDistance;

cellWithFlowDistance.reserve(myPossibleHordeSpawnZones.Size());

const Tga::Vector3f levelEnd = myLevelEnd->GetTransform().GetPosition();

for (const int cell : myPossibleHordeSpawnZones.GetCells())
{
	const size_t flowDistance = myNavmesh->AStarPathfind(GetXZPositionFromIndex(cell), levelEnd).size();

	cellWithFlowDistance.emplace_back(cell, flowDistance);

}

const size_t playerFlowDistance = myNavmesh->AStarPathfind(playerPos, myLevelEnd->GetTransform().GetPosition()).size();

auto weightedSort = [this, playerFlowDistance, cellWithFlowDistance](const int cellA, const int cellB)
	{

		auto scoreCell = [this, playerFlowDistance, cellWithFlowDistance](const int aCell, int& aScore)
			{

				auto iterator = std::ranges::find_if(cellWithFlowDistance.begin(), cellWithFlowDistance.end(), [aCell](const std::pair<int, size_t>& pair) {return pair.first == aCell; });
				// behind player relative to goal
				if (iterator != cellWithFlowDistance.end() && iterator->second > playerFlowDistance)
				{
					++aScore;
				}
				// not in view frustum, i.e player is facing a way from spawn zone
				if (!CheckIfXZPlanePosInFrustum(myPlayerFrustum, GetXZPositionFromIndex(aCell)))
				{
					++aScore;
				}
				// on main path
				if (myGrid[aCell].status == CellStatus::MainPath)
				{
					++aScore;
				}

			};

		int scoreA = 0;
		int scoreB = 0;

		scoreCell(cellA, scoreA);
		scoreCell(cellB, scoreB);

		return scoreA > scoreB;
	};

std::ranges::sort(myPossibleHordeSpawnZones.AccessCells().begin(), myPossibleHordeSpawnZones.AccessCells().end(), weightedSort);