protected internal override Steering getSteering(PersonajeBase personaje)
{
if (currentPoint >= path.Count)
{
_finishedAngular = _finishedLinear = true;
Vector3 cuadrao = SimManagerFinal.gridToPosition(SimManagerFinal.positionToGrid(personaje.posicion));
personaje.fakeAvoid.posicion = cuadrao;
personaje.fakeAvoid.moveTo(cuadrao);
personaje.fakeMovement.posicion = cuadrao;
personaje.fakeMovement.moveTo(cuadrao);
return(new Steering());
}
personaje.fakeAvoid.posicion = pathEnd;
personaje.fakeAvoid.moveTo(pathEnd);
personaje.fakeMovement.posicion = path[currentPoint];
personaje.fakeMovement.moveTo(path[currentPoint]);
pursueSD.target = personaje.fakeMovement;
Steering movActual = pursueSD.getSteering(personaje);
if (pursueSD.finishedLinear)
{
currentPoint++;
}
return(movActual);
}
protected internal Vector2 getUnitPointOnBase(PersonajeBase person, Vector2 basePos)
{
int index = 0;
foreach (PersonajeBase ppl in allies)
{
if (person == ppl)
{
break;
}
index++;
}
int angle = index * 360 / allies.Count;
Vector3 radio = new Vector3((float)System.Math.Cos(angle), 0, (float)System.Math.Sin(angle)) * StatsInfo.baseDistaciaCuracion * 0.75f;
Vector3 destino = SimManagerFinal.gridToPosition(basePos) + radio;
return(SimManagerFinal.positionToGrid(destino));
/*Vector3 distance = SimManagerFinal.gridToPosition(basePos) - person.posicion;
* if (distance.magnitude < StatsInfo.baseDistaciaCuracion)
* {
* return SimManagerFinal.positionToGrid(person.posicion);
* }
* else
* {
* distance = distance.normalized* (distance.magnitude - StatsInfo.baseDistaciaCuracion + 5);
* return SimManagerFinal.positionToGrid(person.posicion + distance);
* }*/
}
protected internal bool alreadyComingToBase(PersonajeBase unit)
{
Vector3 destino = Vector3.zero;
if (unit.currentAction != null && unit.currentAction is ActionGo)
{
destino = SimManagerFinal.gridToPosition(((ActionGo)unit.currentAction).getDestiny());
}
return((destino - SimManagerFinal.gridToPosition(baseCoords)).magnitude <= StatsInfo.baseDistaciaCuracion);
}
protected internal bool ourBaseIsUnderAttack()
{
foreach (PersonajeBase pp in enemies)
{
if (pp.isAlive() && ((pp.posicion - SimManagerFinal.gridToPosition(baseCoords)).magnitude <= StatsInfo.baseDistaciaCuracion))
{
return(true);
}
}
return(false);
}
protected internal List <PersonajeBase> enemiesOnBase() //comprobar si hay enemigos en la base atacando
{
List <PersonajeBase> enemies_attacking = new List <PersonajeBase>();
foreach (PersonajeBase pp in enemies)
{
if (pp.isAlive() && ((pp.posicion - SimManagerFinal.gridToPosition(baseCoords)).magnitude <= StatsInfo.baseDistaciaCuracion))
{
enemies_attacking.Add(pp);
}
}
return(enemies_attacking);
}
private bool tooFarAwayFromBase(PersonajeBase unit)
{
PersonajeBase enemyToAttack = null;
if (unit.currentAction != null && (unit.currentAction is AccionCompuesta))
{
AccionCompuesta ac = (AccionCompuesta)unit.currentAction;
ActionGo ag = (ActionGo)ac.acciones[0];
enemyToAttack = ag.receptor;
}
if (enemyToAttack != null)
{
return((enemyToAttack.posicion - SimManagerFinal.gridToPosition(baseCoords)).magnitude > (StatsInfo.baseDistaciaCuracion * 2));
}
else
{
return(false);
}
}
protected static internal Vector2 getUnitPointOnBaseStatic(PersonajeBase person, Vector2 basePos, List <PersonajeBase> alice)
{
int index = 0;
foreach (PersonajeBase ppl in alice)
{
if (person == ppl)
{
break;
}
index++;
}
int angle = index * 360 / alice.Count;
Vector3 radio = new Vector3((float)System.Math.Cos(angle), 0, (float)System.Math.Sin(angle)) * StatsInfo.baseDistaciaCuracion * 0.75f;
Vector3 destino = SimManagerFinal.gridToPosition(basePos) + radio;
return(SimManagerFinal.positionToGrid(destino));
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
if (!setup)
{
Vector3 puntoActual = path[0];
for (int i = 1; i < path.Count; i++)
{
List <Vector3> recorridoActual = SimManagerFinal.aStarPathV3(puntoActual, path[i], personaje.tipo, personaje is PersonajePlayer);
ruta.AddRange(recorridoActual);
puntoActual = path[i];
}
List <Vector3> recorridoFinal = SimManagerFinal.aStarPathV3(path[path.Count - 1], path[0], personaje.tipo, personaje is PersonajePlayer);
ruta.AddRange(recorridoFinal);
float minDist = Mathf.Infinity;
int nearestPoint = -1;
for (int i = 0; i < ruta.Count; i++)
{
if ((ruta[i] - personaje.posicion).magnitude < minDist)
{
nearestPoint = i;
minDist = (ruta[i] - personaje.posicion).magnitude;
}
}
setup = true;
currentStartingPoint = nearestPoint;
startingruta = SimManagerFinal.aStarPathV3(SimManagerFinal.positionToGrid(personaje.posicion), SimManagerFinal.positionToGrid(ruta[nearestPoint]), personaje.tipo, personaje is PersonajePlayer);
}
if (!startingsetup)
{
if (startingruta.Count > 0)
{
//preguntar a alex si se acuerda
personaje.fakeMovement.innerDetector = personaje.innerDetector;
personaje.fakeMovement.posicion = startingruta[currentPoint];
personaje.fakeMovement.moveTo(startingruta[currentPoint]);
personaje.fakeAvoid.posicion = startingruta[startingruta.Count - 1];
personaje.fakeAvoid.moveTo(startingruta[startingruta.Count - 1]);
if (pursueSD.finishedLinear)
{
currentPoint = (currentPoint + 1);
if (currentPoint >= startingruta.Count)
{
startingsetup = true;
currentPoint = currentStartingPoint;
for (int i = currentPoint; i < ruta.Count; i++)
{
bool found = false;
for (int j = 0; j < path.Count; j++)
{
if (ruta[i] == SimManagerFinal.gridToPosition(path[j]))
{
personaje.fakeAvoid.posicion = ruta[i];
personaje.fakeAvoid.moveTo(ruta[i]);
found = true;
break;
}
}
if (found)
{
break;
}
}
}
}
}
else
{
startingsetup = true;
currentPoint = currentStartingPoint;
for (int i = currentPoint; i < ruta.Count; i++)
{
bool found = false;
for (int j = 0; j < path.Count; j++)
{
if (ruta[i] == SimManagerFinal.gridToPosition(path[j]))
{
personaje.fakeAvoid.posicion = ruta[i];
personaje.fakeAvoid.moveTo(ruta[i]);
found = true;
break;
}
}
if (found)
{
break;
}
}
}
}
else
{
if (pursueSD.finishedLinear)
{
for (int i = 0; i < path.Count; i++)
{
if (path[i] == SimManagerFinal.positionToGrid(ruta[currentPoint]))
{
int next = (i + 1) % path.Count;
Vector3 nextRoutePoint = SimManagerFinal.gridToPosition(path[next]);
personaje.fakeAvoid.posicion = nextRoutePoint;
personaje.fakeAvoid.moveTo(nextRoutePoint);
}
}
currentPoint = (currentPoint + 1) % ruta.Count;
}
personaje.fakeMovement.innerDetector = personaje.innerDetector;
personaje.fakeMovement.posicion = ruta[currentPoint];
personaje.fakeMovement.moveTo(ruta[currentPoint]);
}
pursueSD.target = personaje.fakeMovement;
return(pursueSD.getSteering(personaje));
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
terciaryWhiskersAngle = personaje.outterAngleVision;
secondaryWhiskersAngle = personaje.outterAngleVision / 2;
//secondaryWhiskersLength = personaje.velocidad.magnitude*1.5f;
//primaryWhiskerLenght = personaje.velocidad.magnitude*2.5f;
terciaryWhiskersLength = personaje.maxMovSpeed * multiplier * 0.5f;
secondaryWhiskersLength = personaje.maxMovSpeed * 0.75f * multiplier;
primaryWhiskerLenght = personaje.maxMovSpeed * 1.5f * multiplier;
wallOffset = personaje.innerDetector * 1.5f;
RaycastHit leftSWHit, leftTWHit, rightSWHit, rightTWHit, midWHit;
float leftSecondaryOri = personaje.orientacion - secondaryWhiskersAngle;
if (leftSecondaryOri > System.Math.PI)
{
leftSecondaryOri -= 2 * (float)System.Math.PI;
}
else if (leftSecondaryOri < -System.Math.PI)
{
leftSecondaryOri += 2 * (float)System.Math.PI;
}
float leftTerciaryOri = personaje.orientacion - terciaryWhiskersAngle;
if (leftTerciaryOri > System.Math.PI)
{
leftTerciaryOri -= 2 * (float)System.Math.PI;
}
else if (leftTerciaryOri < -System.Math.PI)
{
leftTerciaryOri += 2 * (float)System.Math.PI;
}
float rightSecondaryOri = personaje.orientacion + secondaryWhiskersAngle;
if (rightSecondaryOri > System.Math.PI)
{
rightSecondaryOri -= 2 * (float)System.Math.PI;
}
else if (rightSecondaryOri < -System.Math.PI)
{
rightSecondaryOri += 2 * (float)System.Math.PI;
}
float rightTerciaryOri = personaje.orientacion + terciaryWhiskersAngle;
if (rightTerciaryOri > System.Math.PI)
{
rightTerciaryOri -= 2 * (float)System.Math.PI;
}
else if (rightTerciaryOri < -System.Math.PI)
{
rightTerciaryOri += 2 * (float)System.Math.PI;
}
bool midWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(personaje.orientacion), out midWHit, primaryWhiskerLenght, 1 << 9 | 1 << 8 | 1 << 13);
bool leftSWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftSecondaryOri), out leftSWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
bool rightSWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightSecondaryOri), out rightSWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
bool leftTWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftTerciaryOri), out leftTWHit, terciaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
bool righTWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightTerciaryOri), out rightTWHit, terciaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
if (midWhisker)
{
_finishedLinear = _finishedAngular = false;
Vector3 newPos = midWHit.point + midWHit.normal.normalized * wallOffset;
newPos = new Vector3(newPos.x, 0, newPos.z);
Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
newPos2d = getVecinoFranqueable(newPos2d);
}
newPos = SimManagerFinal.gridToPosition(newPos2d);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
pursueSD.target = personaje.fakeAvoid;
}
else if ((leftSWhisker || leftTWhisker) && !rightSWhisker && !righTWhisker)
{
_finishedLinear = _finishedAngular = false;
float hipotenusa = 0;
float transversalDistance = 0;
float longitudinalDistance = 0;
if (leftSWhisker)
{
hipotenusa = leftSWHit.distance;
transversalDistance = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
}
else if (leftTWhisker)
{
hipotenusa = leftTWHit.distance;
transversalDistance = hipotenusa * (float)System.Math.Sin(terciaryWhiskersAngle);
longitudinalDistance = hipotenusa * (float)System.Math.Cos(terciaryWhiskersAngle);
}
else
{
hipotenusa = (leftSWHit.distance + leftTWHit.distance) / 2;
transversalDistance = hipotenusa * (float)System.Math.Sin((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
longitudinalDistance = hipotenusa * (float)System.Math.Cos((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
}
float transversalOri = personaje.orientacion + 90 * Bodi.GradosARadianes;
if (transversalOri > (float)System.Math.PI)
{
transversalOri -= 2 * (float)System.Math.PI;
}
else if (transversalOri < (float)System.Math.PI)
{
transversalOri += 2 * (float)System.Math.PI;
}
//CUSTOM FOR INNER CORNERS
Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
+ SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);
newPos = new Vector3(newPos.x, 0, newPos.z);
Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
newPos2d = getVecinoFranqueable(newPos2d);
}
newPos = SimManagerFinal.gridToPosition(newPos2d);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
pursueSD.target = personaje.fakeAvoid;
}
else if ((rightSWhisker || righTWhisker) && !leftSWhisker && !leftTWhisker)
{
_finishedLinear = _finishedAngular = false;
float hipotenusa = 0;
float transversalDistance = 0;
float longitudinalDistance = 0;
if (rightSWhisker)
{
hipotenusa = leftSWHit.distance;
transversalDistance = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
}
else if (righTWhisker)
{
hipotenusa = leftTWHit.distance;
transversalDistance = hipotenusa * (float)System.Math.Sin(terciaryWhiskersAngle);
longitudinalDistance = hipotenusa * (float)System.Math.Cos(terciaryWhiskersAngle);
}
else
{
hipotenusa = (leftSWHit.distance + leftTWHit.distance) / 2;
transversalDistance = hipotenusa * (float)System.Math.Sin((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
longitudinalDistance = hipotenusa * (float)System.Math.Cos((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
}
float transversalOri = personaje.orientacion - 90 * Bodi.GradosARadianes;
if (transversalOri > (float)System.Math.PI)
{
transversalOri -= 2 * (float)System.Math.PI;
}
else if (transversalOri < (float)System.Math.PI)
{
transversalOri += 2 * (float)System.Math.PI;
}
//CUSTOM FOR INNER CORNERS
Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
+ SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);
newPos = new Vector3(newPos.x, 0, newPos.z);
Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
{
newPos2d = getVecinoFranqueable(newPos2d);
}
newPos = SimManagerFinal.gridToPosition(newPos2d);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
pursueSD.target = personaje.fakeAvoid;
}
else if (_finishedLinear || (!_finishedLinear && pursueSD.finishedLinear))
{
_finishedLinear = _finishedAngular = true;
return(new Steering());
}
return(pursueSD.getSteering(personaje));
}
protected static internal bool isInBaseRange(PersonajeBase person, Vector2 baseCoord)
{
return((person.posicion - SimManagerFinal.gridToPosition(baseCoord)).magnitude <= StatsInfo.baseDistaciaCuracion);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
if (!setupAEstrella)
{
LinkedList <NodoGrafoAStar> closedPositions = new LinkedList <NodoGrafoAStar>();
closedPositions.AddLast(nodoOrigen);
LinkedList <NodoGrafoAStar> openPositions = new LinkedList <NodoGrafoAStar>();
NodoGrafoAStar nodoActual = nodoOrigen;
while (!setupAEstrella)
{
LinkedList <NodoGrafoAStar> adyacentes = calcularAdyacentes(nodoActual, personaje.tipo);
//LinkedList<NodoGrafoAStar> adyacentesFiltrados
foreach (NodoGrafoAStar nodito in adyacentes)
{
//Observamos lista closed
bool estaEnListaClosed = false;
foreach (NodoGrafoAStar noditoClosed in closedPositions)
{
//Si el nodo ya está en la lista closed, no se considera
if (noditoClosed.posicionGrid == nodito.posicionGrid)
{
estaEnListaClosed = true;
break;
}
}
if (estaEnListaClosed)
{
continue;
}
//Observamos lista open
NodoGrafoAStar posibleaASustituir = null;
bool estaEnListaOpen = false;
foreach (NodoGrafoAStar noditoOpen in openPositions)
{
if (nodito.posicionGrid == noditoOpen.posicionGrid)
{
estaEnListaOpen = true;
if (noditoOpen.totalCost > nodito.totalCost)
{
posibleaASustituir = noditoOpen;
}
break;
}
}
if (posibleaASustituir != null)
{
openPositions.Remove(posibleaASustituir);
openPositions.AddLast(nodito);
}
else if (!estaEnListaOpen)
{
openPositions.AddLast(nodito);
}
}
//Calculamos siguiente nodo
float minorCost = float.MaxValue;
NodoGrafoAStar next = null;
foreach (NodoGrafoAStar noditoOpen in openPositions)
{
if (noditoOpen.totalCost < minorCost)
{
minorCost = noditoOpen.totalCost;
next = noditoOpen;
}
}
nodoActual = next;
openPositions.Remove(nodoActual);
closedPositions.AddLast(nodoActual);
//Comprobacion de parada(llegamos al destina)
foreach (NodoGrafoAStar noditoClosed in closedPositions)
{
if (noditoClosed.posicionGrid == destino)
{
setupAEstrella = true;
}
}
}
//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;
}
}
if (pursue.finishedLinear || !setupRecorrido)
{
if (pasoActual >= recorrido.Count - 1)
{
_finishedLinear = true;
_finishedAngular = true;
return(new Steering());
}
else
{
pasoActual++;
personaje.fakeMovement.posicion = SimManagerFinal.gridToPosition(recorrido.ElementAt(pasoActual));
personaje.fakeMovement.moveTo(SimManagerFinal.gridToPosition(recorrido.ElementAt(pasoActual)));
pursue.target = personaje.fakeMovement;
setupRecorrido = true;
return(pursue.getSteering(personaje));
}
}
else
{
return(pursue.getSteering(personaje));
}
}