/// <summary>
/// Créer tous les chemins possibles entrent deux points donnés
/// </summary>
/// <param name='startPoint'>
/// La position de départ du chemin
/// </param>
/// <param name='endPoint'>
/// La position de fin du chemin
/// </param>
/// <param name='walls'>
/// Les WallVectors du niveau. Ce sont les murs que le tank doit éviter.
/// </param>
/// <returns>
/// Tous les chemins créés
/// </returns>
private Path[] createPathBetweenPoints(Vector3 startPoint, Vector3 endPoint, WallVector[] walls)
{
List <Path> possiblePaths = new List <Path>();
Path basePath = new Path(startPoint, endPoint);
//Trouver le premier obstacle qui bloque le chemin, s'il y en a un
WallVector obstacle = findFirstObstacle(startPoint, endPoint, walls);
if (obstacle != null)
{
if (!obstacles.Contains(obstacle))
{
Path[] createdPaths;
//Trouver les deux waypoints pour éviter l'obstacle FIXME
Vector3 firstWaypoint = obstacle.getWaypointFromStart(valueScript.waypointsDistanceFromWall);
Vector3 secondWaypoint = obstacle.getWaypointFromEnd(valueScript.waypointsDistanceFromWall);
obstacles.Add(obstacle); //Ajouter l'obstacle à liste des obstacles
//Créer les paths pour le premier waypoint
createdPaths = createPathToAndFromWaypoint(startPoint, endPoint, firstWaypoint, walls);
if (createdPaths.Length > 0)
{
foreach (Path path in createdPaths)
{
possiblePaths.Add(path);
}
}
createdPaths = null;
//Créer les paths pour le second waypoint
createdPaths = createPathToAndFromWaypoint(startPoint, endPoint, secondWaypoint, walls);
if (createdPaths.Length > 0)
{
foreach (Path path in createdPaths)
{
possiblePaths.Add(path);
}
}
obstacles.Remove(obstacle);
}
}
else
{
possiblePaths.Add(basePath);
}
return(possiblePaths.ToArray());
}
public bool checkWaypoint(Vector3 waypoint, WallVector[] walls)
{
bool isWaypointValid = true;
if (valueScript.enemyAI.path != null)
{
WallVector obstacle = findFirstObstacle(transform.position, waypoint, walls);
if (obstacle != null)
{
isWaypointValid = false;
}
}
return(isWaypointValid);
}
/// <summary>
/// Vérifier le WallVecteur donné à ce WallVecteur. Les deux vecteurs doivent avoir la même direction et partager
/// au moins un point d'intersection pour être fusionné.
/// </summary>
/// <param name='wall'>
/// Le WallVector à fusionner.
/// </param>
/// <returns>
/// True si le point a été fusionné, false sinon.
/// </returns>
public bool fusionner(WallVector wall)
{
bool hasFuse = false;
//Vérifier que le début où la fin du mur à fusionné se trouve sur ce mur
if (this.isPointOnVector(wall.startPoint) || this.isPointOnVector(wall.endPoint))
{
//Vérifier que le mur à fusionné à la même direction que ce mur
if (Vector3.Angle(this.vector, wall.vector) == 0f || Vector3.Angle(this.vector, wall.vector) == 180f)
{
foreach (Vector3 point in wall.points)
{
this.addPoint(point);
}
hasFuse = true;
}
}
return(hasFuse);
}
/// <summary>
/// Trouver le WallVector la plus proche qui agit commme obstacle entre les deux positions données
/// </summary>
/// <param name='startPoint'>
/// La position de départ du chemin. C'est à partir de se point qu'est calculé la distance avec les obstacles.
/// </param>
/// <param name='endPoint'>
/// La position de fin du chemin
/// </param>
/// <param name='walls'>
/// Les WallVectors du niveau. Ce sont les murs que le tank doit éviter.
/// </param>
/// <returns>
/// Le WallVector le plus proche
/// </returns>
private WallVector findFirstObstacle(Vector3 startPoint, Vector3 endPoint, WallVector[] walls)
{
WallVector closestObstacle = null; //Le mur obstacle le plus proche
float minDistance = Mathf.Infinity; //Distance du mur obstacle le plus proche
//Créer une droite entre le point et la cible
Vector2 startPoint2D = new Vector2(startPoint.x, startPoint.z);
Vector2 endPoint2D = new Vector2(endPoint.x, endPoint.z);
Droite2D droiteToTarget = new Droite2D(startPoint2D, endPoint2D, true);
//Vérifier les points d'intersections avec tous les murs de la scène
foreach (WallVector wall in walls)
{
if (wall.startPoint != wall.endPoint)
{
//Créer la droite du mur
Vector2 wallStartPoint2D = new Vector2(wall.startPoint.x, wall.startPoint.z);
Vector2 wallEndPoint2D = new Vector2(wall.endPoint.x, wall.endPoint.z);
Droite2D droiteMur = new Droite2D(wallStartPoint2D, wallEndPoint2D, true);
//Trouver le point d'intersection
Vector3 intersection;
if (findIntersection(droiteToTarget, droiteMur, out intersection))
{
//Vérifier cet obstacle est plus proche que le précédent obstacle le plus proche
if (Vector3.Distance(startPoint, intersection) < minDistance)
{
minDistance = Vector3.Distance(startPoint, intersection);
closestObstacle = wall;
}
}
}
}
return(closestObstacle);
}
// override object.Equals()
public override bool Equals(object obj)
{
bool isEqual = true;
if (obj == null || GetType() != obj.GetType())
{
isEqual = false;
}
else
{
WallVector wall = (WallVector)obj;
if (wall.startPoint != startPoint)
{
isEqual = false;
}
else if (wall.endPoint != endPoint)
{
isEqual = false;
}
}
return(isEqual);
}
