protected HashSet <ROL> rolesParaLaClase(StatsInfo.TIPO_PERSONAJE clase)
{
HashSet <ROL> roles = new HashSet <ROL>();
switch (clase)
{
case StatsInfo.TIPO_PERSONAJE.INFANTERIA:
roles.Add(ROL.FLANQUEADOR);
roles.Add(ROL.MELEE);
break;
case StatsInfo.TIPO_PERSONAJE.ARQUERO:
roles.Add(ROL.SNIPER);
roles.Add(ROL.RANGED);
break;
case StatsInfo.TIPO_PERSONAJE.PESADA:
roles.Add(ROL.DEFENSOR);
roles.Add(ROL.MELEE);
break;
case StatsInfo.TIPO_PERSONAJE.MAJITO:
roles.Add(ROL.CASTER);
roles.Add(ROL.RANGED);
break;
}
return(roles);
}
protected internal void applyTipo(StatsInfo.TIPO_PERSONAJE tipo)
{
this.tipo = tipo;
this.health = StatsInfo.healthPerClass[(int)tipo];
/*switch (tipo)
* {
* case UnitsInfo.TIPO_PERSONAJE.INFANTERIA:
* bodyMesh.material.color = UnitsInfo.colorInfanteria;
* maxMovementSpeed = UnitsInfo.velocidadUnidadPorTerreno[0][(int)tipo];
* break;
* case UnitsInfo.TIPO_PERSONAJE.ARQUERO:
* bodyMesh.material.color = UnitsInfo.colorArquero;
* maxMovementSpeed = UnitsInfo.velocidadArquero;
* break;
* case UnitsInfo.TIPO_PERSONAJE.PESADA:
* bodyMesh.material.color = UnitsInfo.colorPesada;
* maxMovementSpeed = UnitsInfo.velocidadPesada;
* break;
* }*/
bodyMesh.material.color = StatsInfo.coloresUnidades[(int)tipo];
maxMovementSpeed = StatsInfo.velocidadUnidades[(int)tipo];
posiblesAcciones = StatsInfo.accionesDeUnidades[(int)tipo];
if (this is PersonajePlayer)
{
//headMesh.material.color = StatsInfo.colorPlayerTeam;
hPMarker.setHpColor(StatsInfo.colorPlayerTeam);
}
else
{
//headMesh.material.color = StatsInfo.colorIATeam;
hPMarker.setHpColor(StatsInfo.colorIATeam);
}
}
internal static List <Vector3> aStarPathV3(Vector2 origen, Vector2 end, StatsInfo.TIPO_PERSONAJE tipo, bool team)
{
List <Vector2> camino = aStarPath(origen, end, tipo, team);
List <Vector3> caminoV3 = new List <Vector3>();
foreach (Vector2 pos in camino)
{
caminoV3.Add(gridToPosition(pos));
}
return(caminoV3);
}
public LinkedList <NodoGrafoAStar> calcularAdyacentes(NodoGrafoAStar actual, StatsInfo.TIPO_PERSONAJE type)
{
LinkedList <NodoGrafoAStar> listanodos = new LinkedList <NodoGrafoAStar>();
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
if (i != 0 || j != 0)
{
Vector2 newPosi = new Vector2(actual.posicionGrid.x + i, actual.posicionGrid.y + j);
if (terrenos[(int)newPosi.x][(int)newPosi.y] != StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
float inversaVelocidad = 1 / StatsInfo.velocidadUnidadPorTerreno[(int)terrenos[(int)newPosi.x][(int)newPosi.y]][(int)type];
float newG = actual.costFromOrigin + (destino - newPosi).magnitude * inversaVelocidad;
listanodos.AddLast(new NodoGrafoAStar(newPosi, (destino - newPosi).magnitude, newG, actual));
}
}
}
}
return(listanodos);
}
private static LinkedList <NodoGrafoAStar> calcularAdyacentes(NodoGrafoAStar actual, Vector2 destino, NodoGrafoAStar[][] nodosUsados, StatsInfo.TIPO_PERSONAJE type, bool team)
{
LinkedList <NodoGrafoAStar> listanodos = new LinkedList <NodoGrafoAStar>();
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
//8 vecinos
if (i != 0 || j != 0)
//4 vecinos
//if (System.Math.Abs(i) != System.Math.Abs(j))
{
Vector2 newPosi = new Vector2(actual.posicionGrid.x + i, actual.posicionGrid.y + j);
if (terrenos[(int)newPosi.x][(int)newPosi.y] != StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
NodoGrafoAStar nodoActual = nodosUsados[(int)newPosi.x][(int)newPosi.y];
if (nodoActual != null)
{
listanodos.AddLast(nodoActual);
}
else
{
float inversaVelocidad = 1 / StatsInfo.velocidadUnidadPorTerreno[(int)terrenos[(int)newPosi.x][(int)newPosi.y]][(int)type];
float newG = (int)(actual.costFromOrigin + (actual.posicionGrid - newPosi).magnitude * inversaVelocidad);
float influencePenalty = calculateInfluencePenalty(team, newPosi);
float terrainPenalty = inversaVelocidad * 70;
NodoGrafoAStar nuevoNodo = new NodoGrafoAStar(newPosi, getDistance(newPosi, destino) + influencePenalty + terrainPenalty, newG, actual);
listanodos.AddLast(nuevoNodo);
nodosUsados[(int)newPosi.x][(int)newPosi.y] = nuevoNodo;
}
}
}
}
}
return(listanodos);
}
internal static List <Vector2> aStarPath(Vector2 origen, Vector2 end, StatsInfo.TIPO_PERSONAJE tipo, bool team)
{
NodoGrafoAStar nodoOrigen = new NodoGrafoAStar(origen, (end - origen).magnitude, 0f, null);
LinkedList <Vector2> recorrido = new LinkedList <Vector2>();
float estimatedCost = (end - origen).magnitude;
if (origen == end || terrenos[(int)end.x][(int)end.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
return(new List <Vector2>());
}
NodoGrafoAStar[][] nodos = new NodoGrafoAStar[165][];
for (int i = 0; i < nodos.Length; i++)
{
nodos[i] = new NodoGrafoAStar[65];
}
HashSet <Vector2> closedPositions = new HashSet <Vector2>();
Heap <NodoGrafoAStar> openPositions = new Heap <NodoGrafoAStar>(maxHeapSize);
openPositions.Add(nodoOrigen);
NodoGrafoAStar nodoActual = null;
while (openPositions.Count > 0)
{
nodoActual = openPositions.RemoveFirst();
closedPositions.Add(nodoActual.posicionGrid);
if (nodoActual.posicionGrid == end)
{
break;
}
LinkedList <NodoGrafoAStar> adyacentes = calcularAdyacentes(nodoActual, end, nodos, tipo, team);
//LinkedList<NodoGrafoAStar> adyacentesFiltrados
foreach (NodoGrafoAStar nodito in adyacentes)
{
//if closed.contains(neighbour)
bool estaEnListaClosed = closedPositions.Contains(nodito.posicionGrid);
if (estaEnListaClosed)
{
continue;
}
//calculamos distancia al siguiente nodo desde el que estamos
float inversaVelocidad = 1 / StatsInfo.velocidadUnidadPorTerreno[(int)terrenos[(int)nodito.posicionGrid.x][(int)nodito.posicionGrid.y]][(int)tipo];
//float newG = nodoActual.costFromOrigin + (nodoActual.posicionGrid - nodito.posicionGrid).magnitude * inversaVelocidad;
float newG = (int)(nodoActual.costFromOrigin + Mathf.RoundToInt((nodoActual.posicionGrid - nodito.posicionGrid).magnitude * inversaVelocidad));
if (newG < nodito.costFromOrigin || (nodos[(int)nodito.posicionGrid.x][(int)nodito.posicionGrid.y] != null && !openPositions.Contains(nodito)))
{
nodito.costFromOrigin = newG;
//nodito.estimatedCost = (end-nodito.posicionGrid).magnitude;
float influencePenalty = calculateInfluencePenalty(team, nodito.posicionGrid);
float terrainPenalty = inversaVelocidad * 70;
nodito.estimatedCost = getDistance(nodito, end) + influencePenalty + terrainPenalty;
nodito.padre = nodoActual;
if (nodos[(int)nodito.posicionGrid.x][(int)nodito.posicionGrid.y] != null && !openPositions.Contains(nodito))
{
openPositions.Add(nodito);
}
else
{
openPositions.UpdateItem(nodito);
}
}
}
}
//Calculamos el camino a seguir en base a los padres del nodo destino
NodoGrafoAStar aux = nodoActual;
while (aux.padre != null)
{
recorrido.AddFirst(aux.posicionGrid);
aux = aux.padre;
}
return(new List <Vector2>(recorrido));
}
