private void seleccionarUnidad()
{
if (Input.GetMouseButtonDown(0))
{
foreach (Unidad u in unidades)
{
u.setSeleccionada(false);
}
selected.GetComponent <MeshRenderer>().enabled = false;
bool unidadEncontrada = false;
int i = 0;
int size = unidades.Count;
CasillaGrid casillaObjetivo = getCasillaRaton();
if (casillaObjetivo == null)
{
return;
}
while (i < size && !unidadEncontrada)
{
if (unidades[i].getCoordenadas() == casillaObjetivo.getPosicionGrid())
{
unidadEncontrada = true;
unidades[i].setSeleccionada(true);
unidadSeleccionada = unidades[i];
return;
}
i++;
}
}
}
// Start is called before the first frame update
void Awake()
{
//tilemap = GameObject.FindGameObjectWithTag("TileGrid").GetComponent<Tilemap>();
Vector3 posicionGlobal = Vector3.zero;
casillas = new CasillaGrid[dim, dim];
mapaInfluencia = new float[dim, dim];
for (int i = 0; i < dim; i++)
{
for (int j = 0; j < dim; j++)
{
posicionGlobal = new Vector3((float)0.5 * j + (float)0.5 * i, (float)-0.25 * j + (float)0.25 * i, 0);
casillas[i, j] = new CasillaGrid(posicionGlobal, new Vector2(i, j));
}
}
getName();
inicializarAdyacentes();
baseA = getCasillaAt(6, 2);
baseB = getCasillaAt(37, 36);
tiempoBaseA = 0;
tiempoBaseB = 0;
}
public CasillaGrid(CasillaGrid casilla)
{
posicion = casilla.getPosicion();
coordenadas = casilla.getPosicionGrid();
adyacentes = casilla.getAdyacentes();
tipo = casilla.getTipoCasilla();
}
/**
* A* y métodos asociados
* */
protected List <NodoA> AStar(CasillaGrid actual, CasillaGrid goal, Dictionary <TipoCasilla, float> moveIndex)
{
//List<NodoA> cerrados = new List<NodoA>();
//List<NodoA> abiertos = new List<NodoA>();
Dictionary <Vector2, NodoA> cerrados = new Dictionary <Vector2, NodoA>();
Dictionary <Vector2, NodoA> abiertos = new Dictionary <Vector2, NodoA>();
CasillaGrid target = goal;
NodoA starter = new NodoA(actual, null, 0);
abiertos.Add(starter.getCasilla().getPosicionGrid(), starter);
while (abiertos.Count != 0)
{
NodoA bestNode = GetLowestCostNode(abiertos);
abiertos.Remove(bestNode.getCasilla().getPosicionGrid());
cerrados.Add(bestNode.getCasilla().getPosicionGrid(), bestNode);
if (bestNode.getCasilla().getPosicionGrid() == goal.getPosicionGrid())
{
ICollection <NodoA> camino = cerrados.Values;
return(ReconstructPath(camino));
}
List <NodoA> vecinos = Neighbours(bestNode.getCasilla(), moveIndex);
foreach (NodoA n in vecinos)
{
if (cerrados.ContainsKey(n.getCasilla().getPosicionGrid()))
{
continue;
}
float costeNodo = bestNode.g + EuclideanDistance(bestNode.getCasilla().getPosicionGrid(), n.getCasilla().getPosicionGrid()) + moveIndex[n.getCasilla().getTipoCasilla()];
n.g = +costeNodo;
n.h = EuclideanDistance(n.getCasilla().getPosicionGrid(), goal.getPosicionGrid());
n.setPadre(bestNode.getCasilla());
if (abiertos.ContainsKey(n.getCasilla().getPosicionGrid()))
{
continue;
}
abiertos.Add(n.getCasilla().getPosicionGrid(), n);
}
}
return(null);
}
public List <NodoA> Neighbours(CasillaGrid casilla, Dictionary <TipoCasilla, float> moveIndex)
{
NodoA aux = null;
List <NodoA> listNodes = new List <NodoA>();
List <CasillaGrid> adyacentes = casilla.getAdyacentes();
foreach (CasillaGrid c in adyacentes)
{
if (moveIndex[c.getTipoCasilla()] == Mathf.Infinity)
{
continue;
}
aux = new NodoA(c, casilla, moveIndex[c.getTipoCasilla()]);
listNodes.Add(aux);
}
return(listNodes);
}
private CasillaGrid getCasillaObjetivo(Vector2 posicionImpacto)
{
float distanciaMinima = Mathf.Infinity;
float distancia;
Vector3 posicionImpactoMundo = new Vector3(posicionImpacto.x, posicionImpacto.y, 0);
CasillaGrid objetivo = null;
foreach (CasillaGrid c in casillas)
{
distancia = (c.getPosicion() - posicionImpactoMundo).magnitude;
if (distancia < distanciaMinima)
{
distanciaMinima = distancia;
objetivo = c;
}
}
return(objetivo);
}
public CasillaGrid getClosest(CasillaGrid current, CasillaGrid goal)
{
float bestDist = Mathf.Infinity;
float bestCost = Mathf.Infinity;
CasillaGrid best = null;
List <CasillaGrid> adyacentes = goal.getAdyacentes();
foreach (CasillaGrid c in adyacentes)
{
/*
* TODO
* Antes de comprobar el adyacente más cercano al actual, comprobar el adyacente de menor coste.
* Si todos tienen el mismo coste, comprobar distancias.
*
* */
if (moveIndex[c.getTipoCasilla()] < bestCost)
{
bestDist = calcDist(current, c);
best = c;
bestCost = moveIndex[c.getTipoCasilla()];
}
}
if (bestCost == Mathf.Infinity)
{
foreach (CasillaGrid c in adyacentes)
{
if (calcDist(current, c) <= bestDist)
{
bestDist = calcDist(current, c);
best = c;
bestCost = moveIndex[c.getTipoCasilla()];
}
}
}
if (bestCost == Mathf.Infinity)
{
best = getClosest(current, best);
}
return(best);
}
public List <NodoA> ReconstructPath(ICollection <NodoA> lista)
{
List <NodoA> path = new List <NodoA>();
List <NodoA> aux = new List <NodoA>(lista);
aux.Reverse();
CasillaGrid padre = null;
if (lista == null || lista.Count == 0)
{
return(null);
}
foreach (NodoA current in aux)
{
if (current.getPadre() != null)
{
if (path.Count == 0)
{
path.Add(current);
padre = current.getPadre();
}
else if (current.getCasilla() == padre)
{
path.Add(current);
padre = current.getPadre();
}
}
else
{
path.Add(current);
}
}
path.Reverse();
return(path);
}
public float getInfluenciaAt(CasillaGrid cg)
{
return(getInfluenciaAt(cg.getPosicionGrid()));
}
public void setTarget(CasillaGrid objetivo)
{
this.target = objetivo;
}
public NodoA(CasillaGrid casilla, CasillaGrid pred, float coste)
{
c = casilla;
padre = pred;
g = coste;
}
// Start is called before the first frame update
protected void Start()
{
coordenadas = Vector2.zero;
ataqueDisponible = true;
unidadViva = true;
canMove = true;
batallaTotal = false;
enemigos = new List <Unidad>();
Unidad[] unidades = GameObject.FindObjectsOfType <Unidad>();
foreach (Unidad u in unidades)
{
if (bando != u.getBando())
{
enemigos.Add(u);
}
}
// Definimos los rallypoints
rallypoints = new List <RallyPoint>();
rallypoints.Add(new RallyPoint(new Vector2(6, 2), TipoRallyPoint.baseA));
rallypoints.Add(new RallyPoint(new Vector2(37, 36), TipoRallyPoint.baseB));
rallypoints.Add(new RallyPoint(new Vector2(9, 16), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(9, 20), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(32, 11), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(32, 15), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(13, 4), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(35, 6), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(4, 23), TipoRallyPoint.paso));
rallypoints.Add(new RallyPoint(new Vector2(30, 18), TipoRallyPoint.paso));
if (bando)
{
baseUnidad = controlador.getCasillaAt(6, 2);
}
else
{
baseUnidad = controlador.getCasillaAt(37, 36);
}
// Inicializamos las casillas de las patrullas
patrullas = new List <CasillaGrid> [6];
CasillaGrid pasoA1 = controlador.getCasillaAt(9, 16);
CasillaGrid pasoA2 = controlador.getCasillaAt(32, 11);
CasillaGrid pasoA3 = controlador.getCasillaAt(13, 4);
CasillaGrid pasoA4 = controlador.getCasillaAt(35, 6);
CasillaGrid curacionA = controlador.getCasillaAt(13, 4);
CasillaGrid pasoB1 = controlador.getCasillaAt(9, 20);
CasillaGrid pasoB2 = controlador.getCasillaAt(6, 35);
CasillaGrid pasoB3 = controlador.getCasillaAt(30, 18);
CasillaGrid baseB = controlador.getCasillaAt(37, 36);
List <CasillaGrid> patrullaRioNorte = new List <CasillaGrid>();
patrullaRioNorte.Add(pasoA1);
patrullaRioNorte.Add(pasoA2);
List <CasillaGrid> patrullaNorte = new List <CasillaGrid>();
patrullaNorte.Add(pasoA3);
patrullaNorte.Add(pasoA4);
List <CasillaGrid> patrullaBosque = new List <CasillaGrid>();
patrullaBosque.Add(pasoA3);
patrullaBosque.Add(pasoA1);
patrullaBosque.Add(pasoA2);
List <CasillaGrid> patrullaRioSur = new List <CasillaGrid>();
patrullaRioSur.Add(pasoB1);
patrullaRioSur.Add(pasoB3);
List <CasillaGrid> patrullaSur = new List <CasillaGrid>();
patrullaSur.Add(pasoB2);
patrullaSur.Add(baseB);
List <CasillaGrid> patrullaCuadrado = new List <CasillaGrid>();
patrullaCuadrado.Add(pasoB1);
patrullaCuadrado.Add(pasoB2);
patrullaCuadrado.Add(baseB);
patrullaCuadrado.Add(pasoB3);
// Asignamos todas las patrullas a la estructura de datos patrullas.
// Cada unidad tendrá asignada una patrulla por medio de un parámetro
patrullas[0] = patrullaRioNorte;
patrullas[1] = patrullaNorte;
patrullas[2] = patrullaBosque;
patrullas[3] = patrullaRioSur;
patrullas[4] = patrullaSur;
patrullas[5] = patrullaCuadrado;
spriteBuscaEnemigo = Resources.Load <Sprite>("buscaEnemigo");
spritePatrulla = Resources.Load <Sprite>("patrulla");
spriteAtacaBaseEnemiga = Resources.Load <Sprite>("atacaBaseEnemiga");
spriteDefiendeBase = Resources.Load <Sprite>("defiendeBase");
spriteCuracion = Resources.Load <Sprite>("curacion");
}
public float calcDist(Vector3 origen, CasillaGrid fin)
{
return(Mathf.Sqrt(Mathf.Pow((origen.x - fin.getPosicionGrid().x), 2) + Mathf.Pow((origen.y - fin.getPosicionGrid().y), 2)));
}
protected void Update()
{
actualizaBarraSalud();
if (seleccionada)
{
controlador.selected.GetComponent <MeshRenderer>().enabled = true;
controlador.selected.transform.position = new Vector3(transform.position.x, transform.position.y, controlador.selected.transform.position.z);
}
int coordenadaGridX = (int)controlador.getCasillaActual(this).getPosicionGrid().x;
int coordenadaGridY = (int)controlador.getCasillaActual(this).getPosicionGrid().y;
Accion a = Accion.buscaEnemigo;
this.setCoordenadas(coordenadaGridX, coordenadaGridY);
bool click = Input.GetMouseButtonDown(1);
if (seleccionada && click || path.Count > 0)
{
path.Clear();
if (click)
{
target = controlador.getCasillaRaton();
}
if (target != null)
{
cg = controlador.getCasillaActual(this);
adyacentes = cg.getAdyacentes();
if (moveIndex[target.getTipoCasilla()] == Mathf.Infinity)
{
target = getClosest(cg, target);
}
setPath(AStar(cg, target, moveIndex));
MovePlayer();
}
}
if (!seleccionada)
{
a = sbr.tomaDecision(this);
target = new CasillaGrid(parseAction(a));
if (target != null)
{
if (patrullando)
{
List <CasillaGrid> patrullaActual = patrullas[numeroPatrulla];
int size = patrullaActual.Count;
if (Vector3.Distance(transform.position, target.getPosicion()) < 0.5f)
{
indicePatrulla = (indicePatrulla + 1) % size;
target = patrullaActual[indicePatrulla];
}
}
//TODO: hacer que se compruebe constantemente la posición del target, y cuando cambie, volver a lanzar el A*
//COMPROBAR LA POSICIÓN FINAL DEL TARGET DE CADA UNIDAD
cg = controlador.getCasillaActual(this);
adyacentes = cg.getAdyacentes();
setPath(AStar(cg, target, moveIndex));
MovePlayer();
}
}
actualizarIcono(a);
}
public void setPadre(CasillaGrid pred)
{
this.padre = pred;
}
public void AddAdyacente(CasillaGrid casilla)
{
adyacentes.Add(casilla);
}
public void setCasilla(CasillaGrid casilla)
{
this.c = casilla;
}