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 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();
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 OnDrawGizmos()
{
Vector3 origin = posicion + Vector3.up;
//Drawing gizmos
//Whiskers
Gizmos.color = Color.green;
/*if (velocidad != Vector3.zero)
* {
* Gizmos.DrawLine(origin, origin + velocidad.normalized * maxMovementSpeed);
* Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(SimulationManager.VectorToDirection(velocidad) + outterAngleVision).normalized * maxMovementSpeed / 2);
* Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(SimulationManager.VectorToDirection(velocidad) - outterAngleVision).normalized * maxMovementSpeed / 2);
* }
* else
* {*/
//Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(orientacion) * velocidad.magnitude*2.5f);
Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(orientacion) * maxMovementSpeed * 2f);
float leftOri = orientacion - outterAngleVision;
if (leftOri > System.Math.PI)
{
leftOri -= 2 * (float)System.Math.PI;
}
else if (leftOri < -System.Math.PI)
{
leftOri += 2 * (float)System.Math.PI;
}
//Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(leftOri) * velocidad.magnitude * 1.5f);
Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(leftOri) * maxMovementSpeed * 1.5f);
float rightOri = orientacion + outterAngleVision;
if (rightOri > System.Math.PI)
{
rightOri -= 2 * (float)System.Math.PI;
}
else if (rightOri < -System.Math.PI)
{
rightOri += 2 * (float)System.Math.PI;
}
//Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(rightOri) * velocidad.magnitude * 1.5f);
Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(rightOri) * maxMovementSpeed * 1.5f);
//}
//Area detectors
Gizmos.color = Color.grey;
//Gizmos.DrawSphere(posicion, innerDetector);
Gizmos.color = Color.black;
//Gizmos.DrawSphere(posicion, outterDetector);
//Bodi vars
Gizmos.color = Color.blue;
Gizmos.DrawLine(origin + Vector3.up / 2, origin + Vector3.up / 2 + velocidad);
Gizmos.color = Color.yellow;
Gizmos.DrawLine(origin + Vector3.up / 2, origin + Vector3.up / 2 + aceleracion);
}
protected internal override Steering getSteering(PersonajeBase personaje)
{
if (pursueSD.finishedLinear || setup)
{
setup = false;
float angularVariation = (float)randomizer.NextDouble() * rotationLimit * 2 - rotationLimit; //rotacion random entre orientacion - limite/2 y orientacion+limite/2
float nuevoAngulo = personaje.orientacion + angularVariation;
Vector3 wanderCenter = personaje.posicion + SimulationManager.DirectionToVector(personaje.orientacion) * offset;
float secondAngularVariation = (float)randomizer.NextDouble() * wanderLimit * 2 - wanderLimit;
Vector3 wanderTarget = wanderCenter + SimulationManager.DirectionToVector(nuevoAngulo + secondAngularVariation) * wanderRadius;
//personaje.fakeMovement.posicion = personaje.posicion + SimulationManager.DirectionToVector(nuevoAngulo) * offset;
personaje.fakeMovement.posicion = wanderTarget;
personaje.fakeMovement.moveTo(wanderTarget);
}
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 internal override Steering getSteering(PersonajeBase personaje)
{
secondaryWhiskersAngle = personaje.outterAngleVision;
//secondaryWhiskersLength = personaje.velocidad.magnitude*1.5f;
//primaryWhiskerLenght = personaje.velocidad.magnitude*2.5f;
secondaryWhiskersLength = personaje.maxMovSpeed * 1.5f * multiplier;
primaryWhiskerLenght = personaje.maxMovSpeed * 2f * multiplier;
wallOffset = personaje.innerDetector * 1.1f * multiplier;
RaycastHit leftWHit, rightWHit, midWHit;
float leftOri = personaje.orientacion - secondaryWhiskersAngle;
if (leftOri > System.Math.PI)
{
leftOri -= 2 * (float)System.Math.PI;
}
else if (leftOri < -System.Math.PI)
{
leftOri += 2 * (float)System.Math.PI;
}
float rightOri = personaje.orientacion + secondaryWhiskersAngle;
if (rightOri > System.Math.PI)
{
rightOri -= 2 * (float)System.Math.PI;
}
else if (rightOri < -System.Math.PI)
{
rightOri += 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 leftWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftOri), out leftWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
bool rightWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightOri), out rightWHit, secondaryWhiskersLength, 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);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
}
else if (leftWhisker && !rightWhisker)
{
_finishedLinear = _finishedAngular = false;
float hipotenusa = leftWHit.distance;
float transversalDistance = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
float longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
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);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
}
else if (rightWhisker && !leftWhisker)
{
_finishedLinear = _finishedAngular = false;
float hipotenusa = rightWHit.distance;
float transversalDistance = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
float longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
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);
personaje.fakeAvoid.posicion = newPos;
personaje.fakeAvoid.innerDetector = personaje.innerDetector;
personaje.fakeAvoid.moveTo(newPos);
}
else if (_finishedLinear || (!_finishedLinear && pursueSD.finishedLinear))
{
_finishedLinear = _finishedAngular = true;
return(new Steering());
}
pursueSD.target = personaje.fakeAvoid;
return(pursueSD.getSteering(personaje));
}