public ColapseNode next()
{
if (iterator >= (queue.Count - 1))
{
iterator = 0;
}
else
{
iterator++;
}
if (queue.Count == 0)
{
Debug.LogError("Queue vazia!");
return(null);
}
if (queue[iterator].Count > 0)
{
ColapseNode aux = queue[iterator][0];
queue[iterator].RemoveAt(0);
return(aux);
}
queue.RemoveAt(iterator);
return(next());
}
public void toCheck(ColapseNode node)
{
foreach (List <ColapseNode> list in queue)
{
list.Find(
elem =>
{
return(elem.pos == node.pos);
}
);
}
}
public void add(ColapseNode node)
{
int i;
for (i = 0; i < queue.Count; i++)
{
if (queue[iterator][i].totalDistance > node.totalDistance)
{
break;
}
}
queue[iterator].Insert(i, node);
}
public UnitQueue(List <Vector2Int> unities, Vector2Int target)
{
if (unities.Count == 0 || target == null)
{
Debug.LogError("unidades ou posicao alvo invalidas");
return;
}
queue = new List <List <ColapseNode> >();
foreach (Vector2Int unit in unities)
{
List <ColapseNode> listAux = new List <ColapseNode>();
ColapseNode nodeAux = new ColapseNode(unit, null, target);
listAux.Add(nodeAux);
queue.Add(listAux);
}
iterator = queue.Count;
}
public ColapseNode(Vector2Int pos, ColapseNode parent, Vector2Int endingPos)
{
this.pos = pos;
//this.parent = new List<AStarNode>();
this.parent = parent;
heuristicDistance = Mathf.Sqrt(Mathf.Pow(pos.x - endingPos.x, 2) + Mathf.Pow(pos.y - endingPos.y, 2));
if (parent != null)
{
//this.parent.Add(parent);
realDistance = parent.realDistance
+ Mathf.Sqrt(Mathf.Pow(pos.x - parent.pos.x, 2) + Mathf.Pow(pos.y - parent.pos.y, 2));
totalDistance = realDistance + heuristicDistance;
}
else
{
totalDistance = heuristicDistance;
}
}
public void PathfinderColapso()
{
if (_targetPos == null || _unitiesToTest == null || _unitiesToTest.Count == 0)
{
Debug.LogError("Selecione um teste!");
return;
}
List <ColapseNode> checkedList = new List <ColapseNode>();
UnitQueue unitQueue = new UnitQueue(_unitiesToTest, _targetPos);
ColapseNode nodeAtual = unitQueue.next();
while (nodeAtual != null)
{
//foreach (var neighbour in neighbourAux) {
// Vector2Int posAux = nodeAtual.pos + neighbour;
// if (posAux == _targetPos) {
// print("Encontrado!");
// List<Vector2Int> caminhoFinal = new List<Vector2Int>();
// caminhoFinal.Add(posAux);
// caminhoFinal.Add(nodeAtual.pos);
// auxNode = nodeAtual.parent;
// while (auxNode != null) {
// caminhoFinal.Add(auxNode.pos);
// auxNode = auxNode.parent;
// }
// caminhoFinal.Reverse();
// foreach (var elem in caminhoFinal) {
// print(elem);
// //Instantiate(DebugPathMark, new Vector3(elem.x, elem.y, -2f), Quaternion.identity, transform);
// }
// for (int i = 1; i < caminhoFinal.Count; i++) {
// Debug.DrawLine(
// new Vector3(caminhoFinal[i - 1].x, caminhoFinal[i - 1].y, 0f),
// new Vector3(caminhoFinal[i].x, caminhoFinal[i].y, 0f),
// Color.blue,
// 30);
// }
// return;
// }
// TileType tileType = TileMapController.Instance.ValidTile(posAux);
// if (tileType == TileType.Pathable) {
// auxNode = new AStarNode(posAux, nodeAtual, _targetPos);
// var auxAuxNode1 = toCheckList.Find(x => {
// if (x.pos == auxNode.pos) {
// return x.totalDistance < auxNode.totalDistance;
// }
// return false;
// });
// var auxAuxNode2 = checkedList.Find(x => {
// if (x.pos == auxNode.pos) {
// return x.totalDistance < auxNode.totalDistance;
// }
// return false;
// });
// if (auxAuxNode1 == null && auxAuxNode2 == null) {
// unitQueue.add(auxNode);
// Instantiate(DebugMark, new Vector3(auxNode.pos.x, auxNode.pos.y, -1f), Quaternion.identity, transform);
// }
// } else if (tileType == TileType.Blocked) {
// // tratamento da pedra
// /**
// * Expandir e encontrar todos os bloqueios adjecentes, salvar posicao, largura e altura da pedra
// */
// FindObstacleByTile(posAux);
// }
//}
//checkedList.Add(nodeAtual);
nodeAtual = unitQueue.next();
}
// Botar uma lista pra cada unidade e só botar a melhor opcao de cada uma na fila pro proximo ciclo?
// Isso + o colapso pode fazer bem menos choques de checks
}