public void EmpiezaMovimiento(Pos pos)
{
_logicaTanke.SetFlecha(new Pos(pos.GetX(), pos.GetY()));
_flecha.transform.position = new Vector3(pos.GetX() * GameManager.Distancia, -pos.GetY() * GameManager.Distancia, 0);
_flecha.SetActive(true);
GameManager.instance.SetSeleccionado(ColorUnidad.ninguno, null);
SetSpriteDeseleccionado();
_reloj.Reset();
_reloj.Start();
AEstrella A = new AEstrella(GameManager.instance.GetLogicaTablero().GetMatriz(), _logicaTanke.GetPos(), pos);
_reloj.Stop();
GameManager.instance.escribeTiempo(_reloj.ElapsedMilliseconds.ToString());
DisplayPath(A.GetCamino());
Mueve(A.GetCamino());
}
private void mostrarRuta()
{
if (tablero == null)
{
print("El tablero no ha sido creado");
}
if (hayRutaMostrada)
{
this.ocultarRuta();
}
algoritmoEstrella = estrella.GetComponent <AEstrella>();
algoritmoEstrella.inicializar();
bool state = algoritmoEstrella.accion(this.hayDiagonales); // Se realiza el algoritmo de estrella.
if (state)
{
tablero.setRuta(algoritmoEstrella.obtenerMejorRuta());
tablero.dibujarRutaOptima();
hayRutaMostrada = true;
playAudio(audioRoute);
}
else
{
audioNoRoute.Play();
}
}
void Awake()
{
currentInstance = this;
ComunicationsEnabeled = true;
aStar = this.GetComponent <AEstrella>();
grafoTotal = CG.nodeMap;
mapResourceReference = new List <GameObject> ();
}
public void AEstrella_heurística_DevuelveValorCorrectoCero()
{
Vector2 nodoA = Vector2.zero;
Vector2 nodoB = Vector2.zero;
float valorEsperado = 0;
float valorObtenido = AEstrella.heurística(nodoA, nodoB);
Assert.AreEqual(valorEsperado, valorObtenido);
}
public void AEstrella_heurística_DevuelveValorCorrectoComplejo()
{
// Se usa el típico triángulo rectángulo 3, 4, 5. Reposicionado en (4, 8).
Vector2 nodoA = Vector2.zero + new Vector2(4, 8);
Vector2 nodoB = new Vector2(3, 4) + new Vector2(4, 8);
float valorEsperado = 5;
float valorObtenido = AEstrella.heurística(nodoA, nodoB);
Assert.AreEqual(valorEsperado, valorObtenido);
}
public void SetUp()
{
ControladorJuego controlador = new GameObject("ControladorJuego").AddComponent <ControladorJuego>();
nodoInicio = new Vector2(2, 3);
nodoDestino = new Vector2(23, 13);
nodoPruebas = new Vector2(6, 7);
nodoPruebasVecino = new Vector2(6, 8);
tamaño = TamañoEntidad.NORMAL;
aEstrella = new AEstrella(nodoInicio, nodoDestino, tamaño);
}
/// <summary>
/// Encuentra la ruta más corta desde el casillero de inicio, a un casillero
/// adyacente al personaje.
/// Se usa para hacer pathfinding. El algoritmo utilizado es A*.
/// Si no es alcanzable, se devuelve una lista vacía.
/// </summary>
/// <param name="inicio">Casillero de inicio.</param>
/// <returns>Lista de casilleros que forman la ruta óptima, incluyendo
/// inicio y destino.</returns>
public List <Vector2> encontrarRutaÓptima(Vector2 inicio)
{
AEstrella aEstrella = new AEstrella(inicio, Tamaño);
return(aEstrella.calcularRutaÓptima());
}
public void AEstrella_constructorSinDestino_ValorDestinoEsNegativeInfinity()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.AreEqual(aEstrella.Destino, Vector2.negativeInfinity);
}
public void AEstrella_constructorSinDestino_ValorInicioEsInicio()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.AreEqual(aEstrella.Inicio, nodoInicio);
}
public void AEstrella_constructorSinDestino_ValorInicialPuntajeGNodoInicioEsCero()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.AreEqual(aEstrella.PuntajeG[aEstrella.Inicio], 0);
}
public void AEstrella_constructorSinDestino_AgregaNodoInicioADiccionarioNodoAnterior()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.IsTrue(aEstrella.NodoAnterior.ContainsKey(nodoInicio));
}
public void AEstrella_constructorSinDestino_CreaDiccionarioNodoAnterior()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.IsInstanceOf <Dictionary <Vector2, Vector2> >(aEstrella.NodoAnterior);
}
public void AEstrella_constructorSinDestino_AgregaValorDeNodoInicioAPuntajeG()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.IsTrue(aEstrella.PuntajeG.ContainsKey(nodoInicio));
}
public void AEstrella_constructorSinDestino_NodoAnteriorDeNodoInicioEsNegativeInfinity()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.AreEqual(aEstrella.NodoAnterior[aEstrella.Inicio], Vector2.negativeInfinity);
}
public void AEstrella_constructorSinDestino_ColocaElNodoInicioEnNodosAbiertos()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.Contains(nodoInicio, aEstrella.NodosAbiertos);
}
public void AEstrella_constructorSinDestino_CreaLaListaDeNodosCerrados()
{
aEstrella = new AEstrella(nodoInicio, TamañoEntidad.NORMAL);
Assert.IsInstanceOf <List <Vector2> >(aEstrella.NodosCerrados);
}