protected internal override Steering getSteering(PersonajeBase personaje)
{
_finishedLinear = _finishedAngular = false;
Vector3 newOffset = SimulationManager.DirectionToVector(_target.orientacion + SimulationManager.VectorToDirection(offsetPosition)) * offsetPosition.magnitude;
Vector2 destino = SimManagerFinal.positionToGrid(_target.posicion + newOffset);
if (destino != lastDestiny)
{
Vector2 origen = SimManagerFinal.positionToGrid(personaje.posicion);
List <Vector3> recorrido = SimManagerFinal.aStarPathV3(origen, destino, personaje.tipo, personaje is PersonajePlayer);
lastDestiny = destino;
followPath = new PathFollowEndSD(recorrido);
}
if (followPath.finishedLinear)
{
personaje.fakeAlign.orientacion = _target.orientacion + offsetOrientation;
if (personaje.fakeAlign.orientacion < -System.Math.PI)
{
personaje.fakeAlign.orientacion += 2 * (float)System.Math.PI;
}
else if (personaje.fakeAlign.orientacion > System.Math.PI)
{
personaje.fakeAlign.orientacion -= 2 * (float)System.Math.PI;
}
personaje.fakeAlign.transform.eulerAngles = new Vector3(0, (_target.orientacion + offsetOrientation) * Bodi.RadianesAGrados, 0);
faceSD.target = personaje.fakeAlign;
parada.getSteering(personaje);
return(faceSD.getSteering(personaje));
}
else
{
return(followPath.getSteering(personaje));
}
}
protected internal override void tioMuerto(PersonajeBase tio)
{
recoveringGroup.Remove(tio);
siegeGroup.Remove(tio);
defensiveGroup.Remove(tio);
ofensiveGroup.Remove(tio);
}
public AggresiveTM(Vector2 _baseCoords, Vector2 _enemyBaseCoords, List <PersonajeBase> _npcs, List <PersonajeBase> _players, bool _team) : base(_baseCoords, _enemyBaseCoords, _npcs, _players, _team)
{
Random rd = new Random();
BridgeAttacked = (int)System.Math.Ceiling(Random.value * 2);
patrullero = allies[1];
}
private Vector2 randomPointInBridge(int bridge, PersonajeBase unit)
{
int whereToGoX = 0;
int whereToGoY = 0;
switch (bridge)
{
case 1:
if (unit.tipo == StatsInfo.TIPO_PERSONAJE.INFANTERIA || unit.tipo == StatsInfo.TIPO_PERSONAJE.PESADA)
{
whereToGoX = Mathf.RoundToInt(Random.Range(74f, 81f));
whereToGoY = Mathf.RoundToInt(Random.Range(19f, 24f));
}
else
{
whereToGoX = Mathf.RoundToInt(Random.Range(82f, 89f));
whereToGoY = Mathf.RoundToInt(Random.Range(19f, 24f));
}
break;
case 2:
if (unit.tipo == StatsInfo.TIPO_PERSONAJE.INFANTERIA || unit.tipo == StatsInfo.TIPO_PERSONAJE.PESADA)
{
whereToGoX = Mathf.RoundToInt(Random.Range(74f, 81f));
whereToGoY = Mathf.RoundToInt(Random.Range(39f, 44f));
}
else
{
whereToGoX = Mathf.RoundToInt(Random.Range(82f, 89f));
whereToGoY = Mathf.RoundToInt(Random.Range(39f, 44f));
}
break;
}
return(new Vector2(whereToGoX, whereToGoY));
}
public FormacionCuadrado(PersonajeBase lider) : base(lider, 5)
{
for (int i = 0; i < maximoMiembros - 1; i++)
{
if (i == 0)
{
offsetPositions[i] = new Vector3(-7.5f, 0, 7.5f);
}
else if (i == 1)
{
offsetPositions[i] = new Vector3(7.5f, 0, 7.5f);
}
else if (i == 2)
{
offsetPositions[i] = new Vector3(-7.5f, 0, -7.5f);
}
else
{
offsetPositions[i] = new Vector3(7.5f, 0, -7.5f);
}
}
for (int i = 0; i < maximoMiembros - 1; i++)
{
float offsetRotation = SimulationManager.VectorToDirection(offsetPositions[i]);
if (offsetRotation > Math.PI)
{
offsetRotation -= (float)Math.PI * 2;
}
else if (offsetRotation < Math.PI)
{
offsetRotation += (float)Math.PI * 2;
}
offsetRotations[i] = offsetRotation;
}
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
_finishedLinear = false;
Steering st = new Steering();
float distance = (_target.posicion - personaje.posicion).magnitude;
if (distance > _target.innerDetector)
{
//2nda manera, acumulación de velocidad
//st.linear = ((_target.posicion - personaje.posicion) + _target.velocidad * Time.fixedDeltaTime).normalized * personaje.movAcc;
// AAA Un poco de predicsion AAA
//1ra manera, superposición de velocidad (velocidad deseada en el primer frame) velocidad desada = velocidad que tienes + velocidad que pasa el steering
// --> velocidad que pasa el steering = velocidad deseada - velocidad que tienes
Vector3 desiredSpeed = (_target.posicion - personaje.posicion).normalized * System.Math.Min(personaje.maxMovSpeed, distance);
st.linear = (desiredSpeed - personaje.velocidad + _target.velocidad * Time.fixedDeltaTime).normalized * personaje.movAcc;
// AAA Un poco de predicsion AAA
_finishedLinear = false;
}
else
{
st.linear = -personaje.velocidad.normalized * System.Math.Min(personaje.velocidad.magnitude, personaje.movAcc);
_finishedLinear = true;
}
return(st);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
if (!setup)
{
float minDist = Mathf.Infinity;
int nearestPoint = -1;
for (int i = 0; i < path.Count; i++)
{
if ((path[i] - personaje.posicion).magnitude < minDist)
{
nearestPoint = i;
minDist = (path[i] - personaje.posicion).magnitude;
}
}
setup = true;
currentPoint = nearestPoint;
}
if (pursueSD.finishedLinear)
{
currentPoint = (currentPoint + 1) % path.Count;
}
pursueSD.target = personaje.fakeMovement;
personaje.fakeMovement.posicion = path[currentPoint];
personaje.fakeMovement.moveTo(path[currentPoint]);
return(pursueSD.getSteering(personaje));
}
internal void actualizeAgentDebugInfo(PersonajeBase character)
{
debugAgentName.text = "Agent Name: " + character.nick;
if (character.selectedBehaviour != null)
{
debugAgentBehaviour.text = "Selected Behaviour: " + character.selectedBehaviour.GetType().Name;
}
else
{
debugAgentBehaviour.text = "Selected Behaviour: No behaviour";
}
debugAgentLookingDirectionAngle.text = "Looking Direction Angle: " + character.orientacion;
if (character.steeringActual != null)
{
debugAgentSteeringLinear.text = "Linear Steering: " + character.steeringActual.linear;
debugAgentSteeringAngular.text = "Angular Steering: " + character.steeringActual.angular;
}
else
{
debugAgentSteeringLinear.text = "Linear Steering: (0, 0, 0)";
debugAgentSteeringAngular.text = "Angular Steering: 0";
}
if ((character.selectedBehaviour as FlockingSD) != null)
{
debugAgentSteeringCombination.gameObject.SetActive(true);
FlockingSD flocking = (character.selectedBehaviour as FlockingSD);
debugAgentSteeringCombination.text = "Dyn Priority: Ch[" + System.Math.Round(flocking.chPercentDyn, 2)
+ "] Sep[" + System.Math.Round(flocking.sepPercentDyn, 2) + "] Foll[" + System.Math.Round(flocking.followLeaderPercentDyn, 2) + "]";
}
else
{
debugAgentSteeringCombination.gameObject.SetActive(false);
}
}
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);
* }*/
}
/*private Vector2 nextMove(int[] minimalSpace, Vector2 position)
* {
*
* int minorCostIndex = -1, minorCost = int.MaxValue;
* for (int i = 0; i < minimalSpace.Length; i++)
* {
* if (minimalSpace[i] < minorCost)
* {
* minorCost = minimalSpace[i];
* minorCostIndex = i;
* }
* }
* switch (minorCostIndex)
* {
* case 0: return new Vector2(0, 1);
* case 1: return new Vector2(1, 0);
* case 2: return new Vector2(0, -1);
* case 3: return new Vector2(-1, 0);
* default: return new Vector2(0, 0);
* }
* }*/
protected internal override Steering getSteering(PersonajeBase personaje)
{
Vector2 personajePos = SimManagerLRTA.positionToGrid(personaje.posicion);
if (pesos[(int)Math.Round(personajePos.x)][(int)Math.Round(personajePos.y)] != 0)
{
if (setup || pursueSD.finishedLinear)
{
minimalSpace(personajePos);
NodoGrafo nextNode = nextMove();
pesos[(int)personajePos.x][(int)personajePos.y] = pesos[(int)nextNode.posicionGrid.x][(int)nextNode.posicionGrid.y] + 1;
personaje.fakeMovement.posicion = SimManagerLRTA.gridToPosition(nextNode.posicionGrid);
personaje.fakeMovement.transform.position = SimManagerLRTA.gridToPosition(nextNode.posicionGrid);
//personaje.innerDetector = 0.5f;
personaje.fakeMovement.innerDetector = personaje.innerDetector;
pursueSD.target = personaje.fakeMovement;
setup = false;
nodoActual = nextNode;
}
return(pursueSD.getSteering(personaje));
}
else
{
_finishedLinear = true;
return(new Steering());
}
}
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 override Steering getSteering(PersonajeBase personaje)
{
Steering st = base.getSteering(personaje);
st.linear = st.linear * (float)offsetRandomizer.NextDouble(); //random offset
return(st);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
_finishedLinear = _finishedAngular = false;
Vector3 newOffset = SimulationManager.DirectionToVector(_target.orientacion + SimulationManager.VectorToDirection(offsetPosition)) * offsetPosition.magnitude;
opSD.target = _target;
opSD.offset = newOffset;
Steering st = opSD.getSteering(personaje);
if (opSD.finishedLinear)
{
personaje.fakeAlign.orientacion = _target.orientacion + offsetOrientation;
if (personaje.fakeAlign.orientacion < -System.Math.PI)
{
personaje.fakeAlign.orientacion += 2 * (float)System.Math.PI;
}
else if (personaje.fakeAlign.orientacion > System.Math.PI)
{
personaje.fakeAlign.orientacion -= 2 * (float)System.Math.PI;
}
personaje.fakeAlign.transform.eulerAngles = new Vector3(0, (_target.orientacion + offsetOrientation) * Bodi.RadianesAGrados, 0);
faceSD.target = personaje.fakeAlign;
st.angular = faceSD.getSteering(personaje).angular;
}
//_finishedLinear = opSD.finishedLinear;
//_finishedAngular = faceSD.finishedAngular;
return(st);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
Steering st = new Steering();
st.angular = SimulationManager.TurnAmountInDirection(personaje.orientacion, SimulationManager.VectorToDirection(personaje.velocidad));
_finishedAngular = st.angular == 0;
return(st);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
_finishedLinear = _finishedAngular = stopwatch.ElapsedMilliseconds > milis;
Steering st = new Steering();
st.linear = -personaje.velocidad;
return(st);
}
public void OnTriggerStay(Collider other)
{
PersonajeBase person = other.gameObject.GetComponent <PersonajeBase>();
if (!owner.group.Contains(person))
{
owner.group.Add(person);
}
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
Steering st = new Steering();
float angularVariation = (float)randomizer.NextDouble() * rotationLimit - rotationLimit / 2; //rotacion random entre orientacion - limite/2 y orientacion+limite/2
float nuevoAngulo = personaje.orientacion + angularVariation;
st.angular = SimulationManager.TurnAmountInDirection(personaje.orientacion, SimulationManager.VectorToDirection(personaje.velocidad)); //rotacion random entre orientacion - limite/2 y orientacion+limite/2
st.linear = SimulationManager.DirectionToVector(nuevoAngulo) * offset;
return(st);
}
internal void removeMiembro(PersonajeBase person)
{
for (int i = 0; i < miembros.Length; i++)
{
if (miembros[i] != person)
{
miembros[i] = null;
}
}
}
public Formacion(PersonajeBase lider, int maximoMiembros)
{
n_miembros = 1;
this.maximoMiembros = maximoMiembros;
miembros = new PersonajeBase[maximoMiembros];
miembros[0] = lider;
offsetPositions = new Vector3[maximoMiembros - 1];
offsetRotations = new float[maximoMiembros - 1];
stopwatch.Start();
}
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);
}
internal virtual bool addMiembro(PersonajeBase nuevo)
{
if (n_miembros < maximoMiembros)
{
miembros[n_miembros] = nuevo;
n_miembros++;
return(true);
}
return(false);
}
protected internal void AddMatraca(PersonajeBase matraca)
{
if (matraca is PersonajePlayer)
{
personajesPlayer.Add(matraca as PersonajePlayer);
}
else
{
personajesNPC.Add(matraca as PersonajeNPC);
}
}
protected static internal AccionCompuesta createAttackingAction(PersonajeBase sujeto, PersonajeBase receptor)
{
ActionGo goToEnemy = new ActionGo(sujeto, SimManagerFinal.positionToGrid(receptor.posicion), receptor);
AccionAttack attackEnemy = new AccionAttack(sujeto, receptor);
List <Accion> orders = new List <Accion> {
goToEnemy, attackEnemy
};
AccionCompuesta ac = new AccionCompuesta(sujeto, orders, true);
return(ac);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
Steering st = new Steering();
st.linear = skAccSt.getSteering(personaje).linear;
st.angular = face.getSteering(personaje).angular;
_finishedLinear = skAccSt.finishedLinear;
_finishedAngular = face.finishedAngular;
return(st);
}
private bool alreadyGoingToBridge(PersonajeBase npc, int whichBridge)
{
if (npc.currentAction is ActionGo)
{
if (pointInBridge(((ActionGo)npc.currentAction).getDestiny(), whichBridge))
{
return(true);
}
}
return(false);
}
public FormacionTriangulo(PersonajeBase lider) : base(lider, 4)
{
for (int i = 0; i < maximoMiembros - 1; i++)
{
offsetPositions[i] = new Vector3((-10f + (i * 10f)), 0, -10f);//Valores de z para el segundo vector -> -5 0 5
}
for (int i = 0; i < maximoMiembros - 1; i++)
{
offsetRotations[i] = 0;
}
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
Steering st = new Steering();
/*if ((_target.posicion - personaje.posicion).magnitude > _target.innerDetector)
* {
* st.linear = (personaje.posicion - _target.posicion).normalized * personaje.movAcc;
* }*/
//NECESITAMOS UNA CONDICION DE CIERRE AQUI TAMBIEN
st.linear = (personaje.posicion - _target.posicion).normalized /*- personaje.velocidad.normalized*Time.fixedDeltaTime).normalized*/ * personaje.movAcc;
return(st);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
personaje.fakeMovement.posicion = _target.posicion + offset;
personaje.fakeMovement.innerDetector = personaje.innerDetector;
personaje.fakeMovement.moveTo(_target.posicion + offset);
pursueSD.target = personaje.fakeMovement;
Steering st = pursueSD.getSteering(personaje);
_finishedLinear = pursueSD.finishedLinear;
_finishedAngular = pursueSD.finishedAngular;
return(st);
}
protected static internal void addMuerto(PersonajeBase muerto)
{
if (muerto is PersonajePlayer)
{
muertosAllys.AddLast(muerto as PersonajePlayer);
playerIA.tioMuerto(muerto);
}
else
{
muertosEnemys.AddLast(muerto as PersonajeNPC);
enemyIA.tioMuerto(muerto);
}
}
public ActionGo(PersonajeBase _sujeto, Vector2 destiny, PersonajeBase receptor) : base(_sujeto)
{
if (receptor)
{
nombreAccion = "PERSEGUIR";
this.receptor = receptor;
}
else
{
nombreAccion = "MOVER";
}
this.destiny = destiny;
}
