/// <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); }